From c40d1a5b09026d2c7b52dfd029326bcaa23dff82 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Bar=C4=B1=C5=9F=20Metin?= Date: Tue, 22 Dec 2009 12:02:27 +0000 Subject: [PATCH] move pcucontrol package into pcucontrol module. --- pcucontrol/__init__.py | 0 pcucontrol/models/APCControl.py | 177 + pcucontrol/models/BayTech.py | 336 + pcucontrol/models/BlackBoxPSMaverick.py | 65 + pcucontrol/models/CustomPCU.py | 26 + pcucontrol/models/DRAC.py | 164 + pcucontrol/models/HPiLO.py | 60 + pcucontrol/models/IPAL.py | 152 + pcucontrol/models/IntelAMT.py | 21 + pcucontrol/models/ManualPCU.py | 13 + pcucontrol/models/OpenIPMI.py | 25 + pcucontrol/models/PM211MIP.py | 5 + pcucontrol/models/WTIIPS4.py | 18 + pcucontrol/models/X10Toggle.py | 49 + pcucontrol/models/__init__.py | 14 + pcucontrol/models/ePowerSwitch.py | 122 + .../models/hpilo/iloxml/Get_Network.xml | 7 + .../models/hpilo/iloxml/PowerOff_Server.xml | 46 + .../models/hpilo/iloxml/PowerOn_Server.xml | 46 + .../models/hpilo/iloxml/Reset_Server.xml | 48 + pcucontrol/models/hpilo/locfg.pl | 132 + .../intelamt/Include/CommonDefinitions.h | 289 + pcucontrol/models/intelamt/Include/IMRSDK.h | 260 + .../intelamt/Include/StatusCodeDefinitions.h | 386 + .../WSDL/AgentWatchdogLocalInterface.wsdl | 146 + .../WSDL/AgentWatchdogRemoteInterface.wsdl | 373 + .../intelamt/Include/WSDL/CertStore.xsd | 31 + .../Include/WSDL/CircuitBreakerInterface.wsdl | 1029 + .../models/intelamt/Include/WSDL/Common.xsd | 59 + .../intelamt/Include/WSDL/EITInterface.wsdl | 136 + .../EndpointAccessControlAdminInterface.wsdl | 137 + .../WSDL/EndpointAccessControlInterface.wsdl | 103 + .../WSDL/EndpointAccessControlInterface.xsd | 135 + .../WSDL/EventManagerClientInterface.wsdl | 87 + .../Include/WSDL/EventManagerInterface.wsdl | 780 + .../Include/WSDL/EventManagerInterface.xsd | 271 + .../Include/WSDL/FirmwareUpdateInterface.wsdl | 149 + .../Include/WSDL/GeneralInfoInterface.wsdl | 582 + .../Include/WSDL/HardwareAssetInterface.wsdl | 271 + .../WSDL/NetworkAdministrationInterface.wsdl | 784 + .../Include/WSDL/NetworkTimeInterface.wsdl | 111 + .../Include/WSDL/RedirectionInterface.wsdl | 171 + .../Include/WSDL/RemoteControlInterface.wsdl | 231 + .../WSDL/SecurityAdministrationInterface.wsdl | 2905 + .../WSDL/SecurityAdministrationInterface.xsd | 550 + .../WSDL/StorageAdministrationInterface.wsdl | 591 + .../Include/WSDL/StorageInterface.wsdl | 55 + .../WSDL/UserNotificationInterface.wsdl | 122 + .../WSDL/WirelessConfigurationInterface.wsdl | 291 + .../WSDL/WirelessConfigurationInterface.xsd | 224 + .../models/intelamt/Include/WSDL/XProfile.xsd | 118 + .../intelamt/Include/WSDL/gNameSpaces.dat | 27 + .../models/intelamt/Include/WSDL/wsman.wsdl | 474 + .../models/intelamt/Include/WSDL/wsman.xsd | 403 + .../models/intelamt/Include/WSDL/wsmancat.xsd | 132 + pcucontrol/models/intelamt/Include/digcalc.h | 60 + .../models/intelamt/Include/httpDigest.h | 48 + pcucontrol/models/intelamt/Include/iamt_api.h | 592 + pcucontrol/models/intelamt/Include/soapH.h | 16266 ++ pcucontrol/models/intelamt/Include/soapStub.h | 15001 ++ pcucontrol/models/intelamt/Include/stdsoap2.h | 2153 + pcucontrol/models/intelamt/Makefile | 43 + pcucontrol/models/intelamt/README | 34 + .../models/intelamt/RemoteControlSample.cpp | 950 + .../intelamt/RemoteControlSoapBinding.nsmap | 27 + .../models/intelamt/RemoteControlTypes.h | 222 + pcucontrol/models/intelamt/Utils.cpp | 775 + pcucontrol/models/intelamt/digcalc.cpp | 153 + pcucontrol/models/intelamt/httpDigest.cpp | 715 + pcucontrol/models/intelamt/soapC.cpp | 152355 +++++++++++++++ pcucontrol/models/intelamt/soapClient.cpp | 10812 + pcucontrol/models/intelamt/stdsoap2.cpp | 13925 ++ pcucontrol/models/racadm.py | 124 + pcucontrol/reboot.py | 478 + pcucontrol/transports/__init__.py | 0 pcucontrol/transports/pyssh/.cvsignore | 1 + pcucontrol/transports/pyssh/__init__.py | 336 + pcucontrol/transports/pyssh/fssa.py | 75 + pcucontrol/transports/pyssh/nbpipe.py | 111 + pcucontrol/transports/pyssh/ptyext.py | 209 + pcucontrol/transports/ssh/LICENSE | 21 + pcucontrol/transports/ssh/__init__.py | 0 pcucontrol/transports/ssh/fdpexpect.py | 73 + pcucontrol/transports/ssh/pexpect.py | 1397 + pcucontrol/transports/ssh/pxssh.py | 137 + pcucontrol/transports/telnetlib.py | 659 + pcucontrol/util/__init__.py | 0 pcucontrol/util/command.py | 244 + 88 files changed, 231935 insertions(+) create mode 100644 pcucontrol/__init__.py create mode 100644 pcucontrol/models/APCControl.py create mode 100644 pcucontrol/models/BayTech.py create mode 100644 pcucontrol/models/BlackBoxPSMaverick.py create mode 100644 pcucontrol/models/CustomPCU.py create mode 100644 pcucontrol/models/DRAC.py create mode 100644 pcucontrol/models/HPiLO.py create mode 100644 pcucontrol/models/IPAL.py create mode 100644 pcucontrol/models/IntelAMT.py create mode 100644 pcucontrol/models/ManualPCU.py create mode 100644 pcucontrol/models/OpenIPMI.py create mode 100644 pcucontrol/models/PM211MIP.py create mode 100644 pcucontrol/models/WTIIPS4.py create mode 100644 pcucontrol/models/X10Toggle.py create mode 100644 pcucontrol/models/__init__.py create mode 100644 pcucontrol/models/ePowerSwitch.py create mode 100644 pcucontrol/models/hpilo/iloxml/Get_Network.xml create mode 100644 pcucontrol/models/hpilo/iloxml/PowerOff_Server.xml create mode 100644 pcucontrol/models/hpilo/iloxml/PowerOn_Server.xml create mode 100644 pcucontrol/models/hpilo/iloxml/Reset_Server.xml create mode 100755 pcucontrol/models/hpilo/locfg.pl create mode 100644 pcucontrol/models/intelamt/Include/CommonDefinitions.h create mode 100644 pcucontrol/models/intelamt/Include/IMRSDK.h create mode 100644 pcucontrol/models/intelamt/Include/StatusCodeDefinitions.h create mode 100644 pcucontrol/models/intelamt/Include/WSDL/AgentWatchdogLocalInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/AgentWatchdogRemoteInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/CertStore.xsd create mode 100644 pcucontrol/models/intelamt/Include/WSDL/CircuitBreakerInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/Common.xsd create mode 100644 pcucontrol/models/intelamt/Include/WSDL/EITInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlAdminInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlInterface.xsd create mode 100644 pcucontrol/models/intelamt/Include/WSDL/EventManagerClientInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/EventManagerInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/EventManagerInterface.xsd create mode 100644 pcucontrol/models/intelamt/Include/WSDL/FirmwareUpdateInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/GeneralInfoInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/HardwareAssetInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/NetworkAdministrationInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/NetworkTimeInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/RedirectionInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/RemoteControlInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/SecurityAdministrationInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/SecurityAdministrationInterface.xsd create mode 100644 pcucontrol/models/intelamt/Include/WSDL/StorageAdministrationInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/StorageInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/UserNotificationInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/WirelessConfigurationInterface.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/WirelessConfigurationInterface.xsd create mode 100644 pcucontrol/models/intelamt/Include/WSDL/XProfile.xsd create mode 100644 pcucontrol/models/intelamt/Include/WSDL/gNameSpaces.dat create mode 100644 pcucontrol/models/intelamt/Include/WSDL/wsman.wsdl create mode 100644 pcucontrol/models/intelamt/Include/WSDL/wsman.xsd create mode 100644 pcucontrol/models/intelamt/Include/WSDL/wsmancat.xsd create mode 100644 pcucontrol/models/intelamt/Include/digcalc.h create mode 100644 pcucontrol/models/intelamt/Include/httpDigest.h create mode 100644 pcucontrol/models/intelamt/Include/iamt_api.h create mode 100644 pcucontrol/models/intelamt/Include/soapH.h create mode 100644 pcucontrol/models/intelamt/Include/soapStub.h create mode 100644 pcucontrol/models/intelamt/Include/stdsoap2.h create mode 100644 pcucontrol/models/intelamt/Makefile create mode 100644 pcucontrol/models/intelamt/README create mode 100644 pcucontrol/models/intelamt/RemoteControlSample.cpp create mode 100644 pcucontrol/models/intelamt/RemoteControlSoapBinding.nsmap create mode 100644 pcucontrol/models/intelamt/RemoteControlTypes.h create mode 100644 pcucontrol/models/intelamt/Utils.cpp create mode 100644 pcucontrol/models/intelamt/digcalc.cpp create mode 100644 pcucontrol/models/intelamt/httpDigest.cpp create mode 100644 pcucontrol/models/intelamt/soapC.cpp create mode 100644 pcucontrol/models/intelamt/soapClient.cpp create mode 100644 pcucontrol/models/intelamt/stdsoap2.cpp create mode 100755 pcucontrol/models/racadm.py create mode 100755 pcucontrol/reboot.py create mode 100644 pcucontrol/transports/__init__.py create mode 100644 pcucontrol/transports/pyssh/.cvsignore create mode 100644 pcucontrol/transports/pyssh/__init__.py create mode 100644 pcucontrol/transports/pyssh/fssa.py create mode 100644 pcucontrol/transports/pyssh/nbpipe.py create mode 100644 pcucontrol/transports/pyssh/ptyext.py create mode 100644 pcucontrol/transports/ssh/LICENSE create mode 100644 pcucontrol/transports/ssh/__init__.py create mode 100644 pcucontrol/transports/ssh/fdpexpect.py create mode 100644 pcucontrol/transports/ssh/pexpect.py create mode 100644 pcucontrol/transports/ssh/pxssh.py create mode 100644 pcucontrol/transports/telnetlib.py create mode 100644 pcucontrol/util/__init__.py create mode 100644 pcucontrol/util/command.py diff --git a/pcucontrol/__init__.py b/pcucontrol/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pcucontrol/models/APCControl.py b/pcucontrol/models/APCControl.py new file mode 100644 index 0000000..59cc649 --- /dev/null +++ b/pcucontrol/models/APCControl.py @@ -0,0 +1,177 @@ +from pcucontrol.reboot import * + +class APCControl(PCUControl): + supported_ports = [22,23,80,443] + reboot_sequence = [] + + def run(self, node_port, dryrun): + print "RUNNING!!!!!!!!!!!!" + if self.transport.type == Transport.HTTPS or self.type == Transport.HTTP: + print "APC via http...." + return self.run_http_or_https(node_port, dryrun) + else: + print "APC via telnet/ssh...." + return self.run_telnet_or_ssh(node_port, dryrun) + + def run_ssh(self, node_port, dryrun): + return self.run_telnet_or_ssh(node_port, dryrun) + def run_telnet(self, node_port, dryrun): + return self.run_telnet_or_ssh(node_port, dryrun) + + def run_telnet_or_ssh(self, node_port, dryrun): + self.transport.open(self.host, self.username) + self.transport.sendPassword(self.password) + + first = True + for val in self.reboot_sequence: + if first: + self.transport.ifThenSend("\r\n> ", val, ExceptionPassword) + first = False + else: + self.transport.ifThenSend("\r\n> ", val) + + if not dryrun: + self.transport.ifThenSend("Enter 'YES' to continue or to cancel", + "YES\r\n", + ExceptionSequence) + else: + self.transport.ifThenSend("Enter 'YES' to continue or to cancel", + "", ExceptionSequence) + self.transport.ifThenSend("Press to continue...", "", ExceptionSequence) + + self.transport.close() + return 0 + + def run_http(self, node_port, dryrun): + return self.run_http_or_https(node_port, dryrun) + def run_https(self, node_port, dryrun): + return self.run_http_or_https(node_port, dryrun) + + def run_http_or_https(self, node_port, dryrun): + if not dryrun: + # send reboot signal. + # TODO: send a ManualPCU() reboot request for this PCU. + # NOTE: this model defies automation because, the port numbering + # and the form numbers are not consistent across models. There is + # not direct mapping from port# to form#. + return "Manual Reboot Required" + + else: + # TODO: also send message for https, since that doesn't work this way... + if self.transport.type == Transport.HTTPS: + cmd = self.get_https_cmd() + elif self.transport.type == Transport.HTTP: + cmd = self.get_http_cmd() + else: + raise ExceptionNoTransport("Unsupported transport for http command") + + cmd = cmd % ( self.username, self.password, self.host) + print "CMD: %s" % cmd + + p = os.popen(cmd) + result = p.read() + if len(result.split('\n')) > 2: + self.logout() + return 0 + else: + # NOTE: an error has occurred, so no need to log out. + print "RESULT: ", result + return result + + def get_https_cmd(self): + version = self.get_version() + print "VERSION: %s" % version + if "AP96" in version: + cmd = "curl -s --insecure --user '%s:%s' https://%s/outlets.htm " + \ + " | grep -E '^[^<]+' " + \ + " | grep -v 'Protected Object' " + else: + # NOTE: no other case known right now... + cmd = "curl -s --insecure --user '%s:%s' https://%s/outlets.htm " + \ + " | grep -E '^[^<]+' " + \ + " | grep -v 'Protected Object' " + + return cmd + + def get_http_cmd(self): + version = self.get_version() + print "VERSION: %s" % version + if "AP7900" in version: + cmd = "curl -s --anyauth --user '%s:%s' http://%s/rPDUout.htm | grep -E '^[^<]+'" + elif "AP7920" in version: + cmd = "curl -s --anyauth --user '%s:%s' http://%s/ms3out.htm | grep -E '^[^<]+' " + else: + # default case... + print "USING DEFAULT" + cmd = "curl -s --anyauth --user '%s:%s' http://%s/ms3out.htm | grep -E '^[^<]+' " + + return cmd + + def get_version(self): + # NOTE: this command returns and formats all data. + #cmd = """curl -s --anyauth --user '%s:%s' http://%s/about.htm """ + + # """ | sed -e "s/<[^>]*>//g" -e "s/ //g" -e "/^$/d" """ + + # """ | awk '{line=$0 ; if ( ! /:/ && length(pline) > 0 ) \ + # { print pline, line } else { pline=line} }' """ + + # """ | grep Model """ + + # NOTE: we may need to return software version, no model version to + # know which file to request on the server. + + if self.transport.type == Transport.HTTP: + cmd = """curl -s --anyauth --user '%s:%s' http://%s/about.htm """ + \ + """ | sed -e "s/<[^>]*>//g" -e "s/ //g" -e "/^$/d" """ + \ + """ | grep -E "AP[[:digit:]]+" """ + #""" | grep -E "v[[:digit:]].*" """ + elif self.transport.type == Transport.HTTPS: + cmd = """curl -s --insecure --user '%s:%s' https://%s/about.htm """ + \ + """ | sed -e "s/<[^>]*>//g" -e "s/ //g" -e "/^$/d" """ + \ + """ | grep -E "AP[[:digit:]]+" """ + #""" | grep -E "v[[:digit:]].*" """ + else: + raise ExceptionNoTransport("Unsupported transport to get version") + + cmd = cmd % ( self.username, self.password, self.host) + p = os.popen(cmd) + result = p.read() + return result.strip() + + def logout(self): + # NOTE: log out again, to allow other uses to access the machine. + if self.transport.type == Transport.HTTP: + cmd = """curl -s --anyauth --user '%s:%s' http://%s/logout.htm """ + \ + """ | grep -E '^[^<]+' """ + elif self.transport.type == Transport.HTTPS: + cmd = """curl -s --insecure --user '%s:%s' http://%s/logout.htm """ + \ + """ | grep -E '^[^<]+' """ + else: + raise ExceptionNoTransport("Unsupported transport to logout") + + cmd = cmd % ( self.username, self.password, self.host) + p = os.popen(cmd) + print p.read() + +class APCControl12p3(APCControl): + def run_telnet_or_ssh(self, node_port, dryrun): + self.reboot_sequence = ["1", "2", str(node_port), "3"] + return super(APCControl12p3, self).run_telnet_or_ssh(node_port, dryrun) + +class APCControl1p4(APCControl): + def run_telnet_or_ssh(self, node_port, dryrun): + self.reboot_sequence = ["1", str(node_port), "4"] + return super(APCControl1p4, self).run_telnet_or_ssh(node_port, dryrun) + +class APCControl121p3(APCControl): + def run_telnet_or_ssh(self, node_port, dryrun): + self.reboot_sequence = ["1", "2", "1", str(node_port), "3"] + return super(APCControl121p3, self).run_telnet_or_ssh(node_port, dryrun) + +class APCControl121p1(APCControl): + def run_telnet_or_ssh(self, node_port, dryrun): + self.reboot_sequence = ["1", "2", "1", str(node_port), "1", "3"] + return super(APCControl121p1, self).run_telnet_or_ssh(node_port, dryrun) + +class APCControl13p13(APCControl): + def run_telnet_or_ssh(self, node_port, dryrun): + self.reboot_sequence = ["1", "3", str(node_port), "1", "3"] + return super(APCControl13p13, self).run_telnet_or_ssh(node_port, dryrun) diff --git a/pcucontrol/models/BayTech.py b/pcucontrol/models/BayTech.py new file mode 100644 index 0000000..fecabd6 --- /dev/null +++ b/pcucontrol/models/BayTech.py @@ -0,0 +1,336 @@ +from pcucontrol.reboot import * + +class BayTechRPC3NC(PCUControl): + supported_ports = [22,23] + def run_telnet(self, node_port, dryrun): + return self.run_ssh(node_port, dryrun) + + def run_ssh(self, node_port, dryrun): + self.transport.open(self.host, self.username, None, "Enter user name:") + self.transport.sendPassword(self.password, "Enter Password:") + + #self.transport.ifThenSend("RPC-16>", "Status") + self.transport.ifThenSend("RPC3-NC>", "Reboot %d" % node_port) + + # Reboot Outlet N (Y/N)? + if dryrun: + self.transport.ifThenSend("(Y/N)?", "N") + else: + self.transport.ifThenSend("(Y/N)?", "Y") + self.transport.ifThenSend("RPC3-NC>", "") + + self.transport.close() + return 0 + +class BayTechGeorgeTown(PCUControl): + supported_ports = [22,23] + def run_telnet(self, node_port, dryrun): + return self.run_ssh(node_port, dryrun) + def run_ssh(self, node_port, dryrun): + # NOTE: The georgetown pcu always drops the first connection, + self.transport.open(self.host, self.username, None, "Enter") + self.transport.close() + time.sleep(1) + self.transport.open(self.host, self.username, None, "Enter user name:") + self.transport.sendPassword(self.password, "Enter Password:") + + self.transport.ifThenSend("RPC-16>", "Reboot %d" % node_port) + + # Reboot Outlet N (Y/N)? + if dryrun: + self.transport.ifThenSend("(Y/N)?", "N") + else: + self.transport.ifThenSend("(Y/N)?", "Y") + self.transport.ifThenSend("RPC-16>", "") + + self.transport.close() + return 0 + + +class BayTechRPC16(PCUControl): + supported_ports = [22,23] + def run_telnet(self, node_port, dryrun): + return self.run_ssh(node_port, dryrun) + def run_ssh(self, node_port, dryrun): + self.transport.open(self.host, self.username, None, "Enter user name:") + self.transport.sendPassword(self.password, "Enter Password:") + + #self.transport.ifThenSend("RPC-16>", "Status") + + self.transport.ifThenSend("RPC-16>", "Reboot %d" % node_port) + + # Reboot Outlet N (Y/N)? + if dryrun: + self.transport.ifThenSend("(Y/N)?", "N") + else: + self.transport.ifThenSend("(Y/N)?", "Y") + self.transport.ifThenSend("RPC-16>", "") + + self.transport.close() + return 0 + +class BayTechCtrlCUnibe(PCUControl): + """ + For some reason, these units let you log in fine, but they hang + indefinitely, unless you send a Ctrl-C after the password. No idea + why. + """ + supported_ports = [22] + def run_ssh(self, node_port, dryrun): + print "BayTechCtrlC %s" % self.host + + ssh_options="-o StrictHostKeyChecking=no -o PasswordAuthentication=yes -o PubkeyAuthentication=no" + s = pxssh.pxssh() + if not s.login(self.host, self.username, self.password, ssh_options): + raise ExceptionPassword("Invalid Password") + # Otherwise, the login succeeded. + + # Send a ctrl-c to the remote process. + print "sending ctrl-c" + s.send(chr(3)) + + # Control Outlets (5 ,1).........5 + try: + #index = s.expect("Enter Request") + index = s.expect(["Enter Request :"]) + + if index == 0: + print "3" + s.send("3\r\n") + time.sleep(5) + index = s.expect(["DS-RPC>", "Enter user name:"]) + if index == 1: + s.send(self.username + "\r\n") + time.sleep(5) + index = s.expect(["DS-RPC>"]) + + if index == 0: + print "Reboot %d" % node_port + time.sleep(5) + s.send("Reboot %d\r\n" % node_port) + + time.sleep(5) + index = s.expect(["\(Y/N\)\?", "Port in use", "DS-RPC>"]) + if index == 0: + if dryrun: + print "sending N" + s.send("N\r\n") + else: + print "sending Y" + s.send("Y\r\n") + elif index == 1: + raise ExceptionPrompt("PCU Reported 'Port in use.'") + elif index == 2: + raise ExceptionSequence("Issued command 'Reboot' failed.") + + time.sleep(5) + index = s.expect(["DS-RPC>"]) + #print "got prompt back" + + s.close() + + except pexpect.EOF: + raise ExceptionPrompt("EOF before expected Prompt") + except pexpect.TIMEOUT: + raise ExceptionPrompt("Timeout before expected Prompt") + + return 0 + +class BayTechCtrlC(PCUControl): + """ + For some reason, these units let you log in fine, but they hang + indefinitely, unless you send a Ctrl-C after the password. No idea + why. + """ + supported_ports = [22] + def run_ssh(self, node_port, dryrun): + print "BayTechCtrlC %s" % self.host + + ssh_options="-o StrictHostKeyChecking=no -o PasswordAuthentication=yes -o PubkeyAuthentication=no" + s = pxssh.pxssh() + try: + if not s.login(self.host, self.username, self.password, ssh_options): + raise ExceptionPassword("Invalid Password") + except pexpect.EOF: + raise ExceptionNoTransport("No Connection Possible") + + + # Otherwise, the login succeeded. + + # Send a ctrl-c to the remote process. + print "SENDING ctrl-c" + s.send(chr(3)) + + # Control Outlets (5 ,1).........5 + try: + print "EXPECTING: ", "Enter Request :" + index = s.expect(["Enter Request :"]) + + if index == 0: + print "SENDING: 5" + s.send("5\r\n") + print "EXPECTING: ", "DS-RPC>" + index = s.expect(["DS-RPC>", "Enter user name:", "Port in use."]) + if index == 1: + print "sending username" + s.send(self.username + "\r\n") + index = s.expect(["DS-RPC>"]) + elif index == 2: + raise ExceptionPrompt("PCU Reported 'Port in use.'") + + if index == 0: + print "SENDING: Reboot %d" % node_port + s.send("Reboot %d\r\n" % node_port) + + print "SLEEPING: 5" + time.sleep(5) + print "EXPECTING: ", "Y/N?" + index = s.expect(["\(Y/N\)\?", "Port in use", "DS-RPC>"]) + if index == 0: + if dryrun: + print "sending N" + s.send("N\r\n") + else: + print "SENDING: Y" + s.send("Y\r\n") + elif index == 1: + raise ExceptionPrompt("PCU Reported 'Port in use.'") + elif index == 2: + raise ExceptionSequence("Issued command 'Reboot' failed.") + + # NOTE: for some reason, the script times out with the + # following line. In manual tests, it works correctly, but + # with automated tests, evidently it fails. + print "SLEEPING: 5" + time.sleep(5) + #print "TOTAL--", s.allstr, "--EOT" + index = s.expect(["DS-RPC>"]) + print "got prompt back" + + s.close() + + except pexpect.EOF: + raise ExceptionPrompt("EOF before 'Enter Request' Prompt") + except pexpect.TIMEOUT: + raise ExceptionPrompt("Timeout before Prompt") + + return 0 + + +class BayTech5CtrlC(PCUControl): + """ + For some reason, these units let you log in fine, but they hang + indefinitely, unless you send a Ctrl-C after the password. No idea + why. + """ + supported_ports = [22] + def run_ssh(self, node_port, dryrun): + print "BayTech5CtrlC %s" % self.host + + ssh_options="-o StrictHostKeyChecking=no -o PasswordAuthentication=yes -o PubkeyAuthentication=no" + s = pxssh.pxssh() + try: + if not s.login(self.host, self.username, self.password, ssh_options): + raise ExceptionPassword("Invalid Password") + except pexpect.EOF: + raise ExceptionNoTransport("No Connection Possible") + + + # Otherwise, the login succeeded. + # Control Outlets (5 ,1).........5 + try: + print "EXPECTING: ", "Enter Request :" + s.send("\r\n") + time.sleep(2) + index = s.expect(["Enter Request"]) + + if index == 0: + print "SENDING: 5" + s.send("5\r\n") + print "EXPECTING: ", "DS-RPC>" + time.sleep(3) + # Send a ctrl-c to the remote process. + #print "SENDING ctrl-c" + #s.send(chr(3)) + + index = s.expect(["DS-RPC>", "Enter user name:", "Port in use."]) + if index == 1: + print "sending username" + s.send(self.username + "\r\n") + index = s.expect(["DS-RPC>"]) + elif index == 2: + raise ExceptionPrompt("PCU Reported 'Port in use.'") + + if index == 0: + print "SENDING: Reboot %d" % node_port + #s.send("Reboot %d\r\n" % node_port) + s.send("Reboot %d\r" % node_port) + + print "SLEEPING: 5" + time.sleep(5) + print "EXPECTING: ", "Y/N?" + index = s.expect(["\(Y/N\)\?", "Port in use", "DS-RPC>"]) + if index == 0: + if dryrun: + print "sending N" + s.send("N\r\n") + else: + print "SENDING: Y" + s.send("Y\r\n") + elif index == 1: + raise ExceptionPrompt("PCU Reported 'Port in use.'") + elif index == 2: + raise ExceptionSequence("Issued command 'Reboot' failed.") + + # NOTE: for some reason, the script times out with the + # following line. In manual tests, it works correctly, but + # with automated tests, evidently it fails. + print "SLEEPING: 5" + time.sleep(5) + #print "TOTAL--", s.allstr, "--EOT" + index = s.expect(["DS-RPC>"]) + print "got prompt back" + + s.close() + + except pexpect.EOF: + raise ExceptionPrompt("EOF before 'Enter Request' Prompt") + except pexpect.TIMEOUT: + raise ExceptionPrompt("Timeout before Prompt") + + return 0 + +class BayTech(PCUControl): + supported_ports = [22,23] + + def run_telnet(self, node_port, dryrun): + return self.run_ssh(node_port, dryrun) + + def run_ssh(self, node_port, dryrun): + self.transport.open(self.host, self.username) + self.transport.sendPassword(self.password) + + # Control Outlets (5 ,1).........5 + self.transport.ifThenSend("Enter Request :", "5") + + # Reboot N + try: + self.transport.ifThenSend("DS-RPC>", "Reboot %d" % node_port, ExceptionNotFound) + except ExceptionNotFound, msg: + # one machine is configured to ask for a username, + # even after login... + print "msg: %s" % msg + self.transport.write(self.username + "\r\n") + time.sleep(5) + self.transport.ifThenSend("DS-RPC>", "Reboot %d" % node_port) + + # Reboot Outlet N (Y/N)? + if dryrun: + self.transport.ifThenSend("(Y/N)?", "N") + else: + self.transport.ifThenSend("(Y/N)?", "Y") + time.sleep(5) + self.transport.ifThenSend("DS-RPC>", "") + + self.transport.close() + return 0 diff --git a/pcucontrol/models/BlackBoxPSMaverick.py b/pcucontrol/models/BlackBoxPSMaverick.py new file mode 100644 index 0000000..ee414dc --- /dev/null +++ b/pcucontrol/models/BlackBoxPSMaverick.py @@ -0,0 +1,65 @@ +from pcucontrol.reboot import * + +### rebooting european BlackBox PSE boxes +# Thierry Parmentelat - May 11 2005 +# tested on 4-ports models known as PSE505-FR +# uses http to POST a data 'P=r' +# relies on basic authentication within http1.0 +# first curl-based script was +# curl --http1.0 --basic --user : --data P=r \ +# http://:/cmd.html && echo OK + +# log in: + +## BB PSMaverick +class BlackBoxPSMaverick(PCUControl): + supported_ports = [80] + + def run_http(self, node_port, dryrun): + if not dryrun: + # send reboot signal. + cmd = "curl -s --data 'P%s=r' --anyauth --user '%s:%s' http://%s/config/home_f.html" % ( node_port, self.username, self.password, self.host) + else: + # else, just try to log in + cmd = "curl -s --anyauth --user '%s:%s' http://%s/config/home_f.html" % ( self.username, self.password, self.host) + + p = os.popen(cmd) + result = p.read() + print "RESULT: ", result + + if len(result.split()) > 3: + return 0 + else: + return result + +def bbpse_reboot (pcu_ip,username,password,port_in_pcu,http_port, dryrun): + + global verbose + + url = "http://%s:%d/cmd.html" % (pcu_ip,http_port) + data= "P%d=r" % port_in_pcu + if verbose: + logger.debug("POSTing '%s' on %s" % (data,url)) + + authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm() + uri = "%s:%d" % (pcu_ip,http_port) + authinfo.add_password (None, uri, username, password) + authhandler = urllib2.HTTPBasicAuthHandler( authinfo ) + + opener = urllib2.build_opener(authhandler) + urllib2.install_opener(opener) + + if (dryrun): + return 0 + + try: + f = urllib2.urlopen(url,data) + + r= f.read() + if verbose: + logger.debug(r) + return 0 + + except urllib2.URLError,err: + logger.info('Could not open http connection', err) + return "bbpse error" diff --git a/pcucontrol/models/CustomPCU.py b/pcucontrol/models/CustomPCU.py new file mode 100644 index 0000000..60de348 --- /dev/null +++ b/pcucontrol/models/CustomPCU.py @@ -0,0 +1,26 @@ +# Each method follows the following format: +# CustomPCU_loginbase() +# +# This provides a simple means of lookup given the custom type. +# The only problem might come up if a single site has multiple custom PCUs. +# That would be pretty wierd though... + +from pcucontrol.reboot import * + +class CustomPCU_uniklu(PCUControl): + def run_http(self, node_port, dryrun): + url = "https://www-itec.uni-klu.ac.at/plab-pcu/index.php" + + if not dryrun: + # Turn host off, then on + formstr = "plab%s=off" % node_port + os.system("curl --user %s:%s --form '%s' --insecure %s" % (self.username, self.password, formstr, url)) + time.sleep(5) + formstr = "plab%s=on" % node_port + os.system("curl --user %s:%s --form '%s' --insecure %s" % (self.username, self.password, formstr, url)) + else: + os.system("curl --user %s:%s --insecure %s" % (self.username, self.password, url)) + + + + diff --git a/pcucontrol/models/DRAC.py b/pcucontrol/models/DRAC.py new file mode 100644 index 0000000..898b5e5 --- /dev/null +++ b/pcucontrol/models/DRAC.py @@ -0,0 +1,164 @@ +from pcucontrol.reboot import * +import time + +class DRAC(PCUControl): + supported_ports = [22,443,5869] + def run_drac(self, node_port, dryrun): + print "trying racadm_reboot..." + return racadm_reboot(self.host, self.username, self.password, node_port, dryrun) + + def run_ssh(self, node_port, dryrun): + ssh_options="-o StrictHostKeyChecking=no "+\ + "-o PasswordAuthentication=yes "+\ + "-o PubkeyAuthentication=no" + s = pxssh.pxssh() + try: + if not s.login(self.host, self.username, self.password, ssh_options, + original_prompts="Dell", login_timeout=Transport.TELNET_TIMEOUT): + raise ExceptionPassword("Invalid Password") + except pexpect.EOF: + raise ExceptionPrompt("Disconnect before login prompt") + + print "logging in... %s" % self.host + s.send("\r\n\r\n") + try: + # Testing Reboot ? + #index = s.expect(["DRAC 5", "[%s]#" % self.username ]) + # NOTE: be careful to escape any characters used by 're.compile' + index = s.expect(["\$", "\[%s\]#" % self.username, "/.*>" ]) + print "INDEX:", index + print s + if dryrun: + if index == 0: + s.sendline("racadm getsysinfo") + elif index == 1: + s.sendline("getsysinfo") + elif index == 2: + s.sendline("racadm getsysinfo") + else: + print "serveraction powercycle" + if index == 0: + s.sendline("racadm serveraction powercycle") + elif index == 1: + s.sendline("serveraction powercycle") + elif index == 2: + s.sendline("racadm serveraction powercycle") + + # TODO: this is really lousy. Without the sleep, the sendlines + # don't completely get through. Even the added, expect line + # returns right away without waiting for the commands above to + # complete... Therefore, this delay is guaranteed to fail in some + # other context... + s.send("\r\n\r\n") + time.sleep(20) + index = s.expect(["\$", "\[%s\]#" % self.username, "/.*>" ]) + print s + print "INDEX 2:", index + s.sendline("exit") + + except pexpect.EOF: + raise ExceptionPrompt("EOF before expected Prompt") + except pexpect.TIMEOUT: + print s + raise ExceptionPrompt("Timeout before expected Prompt") + + s.close() + + return 0 + +### rebooting Dell systems via RAC card +# Marc E. Fiuczynski - June 01 2005 +# tested with David Lowenthal's itchy/scratchy nodes at UGA +# +def runcmd(command, args, username, password, timeout = None): + + result = [None] + result_ready = threading.Condition() + + def set_result(x): + + result_ready.acquire() + try: + result[0] = x + finally: + result_ready.notify() + result_ready.release() + + def do_command(command, username, password): + + try: + # Popen4 is a popen-type class that combines stdout and stderr + p = popen2.Popen4(command) + + # read all output data + p.tochild.write("%s\n" % username) + p.tochild.write("%s\n" % password) + p.tochild.close() + data = p.fromchild.read() + + while True: + # might get interrupted by a signal in poll() or waitpid() + try: + retval = p.wait() + set_result((retval, data)) + break + except OSError, ex: + if ex.errno == errno.EINTR: + continue + raise ex + except Exception, ex: + set_result(ex) + + if args: + command = " ".join([command] + args) + + worker = threading.Thread(target = do_command, args = (command, username, password, )) + worker.setDaemon(True) + result_ready.acquire() + worker.start() + result_ready.wait(timeout) + try: + if result == [None]: + raise Exception, "command timed-out: '%s'" % command + finally: + result_ready.release() + result = result[0] + + if isinstance(result, Exception): + raise result + else: + (retval, data) = result + if os.WIFEXITED(retval) and os.WEXITSTATUS(retval) == 0: + return data + else: + out = "system command ('%s') " % command + if os.WIFEXITED(retval): + out += "failed, rc = %d" % os.WEXITSTATUS(retval) + else: + out += "killed by signal %d" % os.WTERMSIG(retval) + if data: + out += "; output follows:\n" + data + raise Exception, out + +def racadm_reboot(host, username, password, port, dryrun): + global verbose + + ip = socket.gethostbyname(host) + try: + cmd = "/usr/sbin/racadm" + os.stat(cmd) + if not dryrun: + output = runcmd(cmd, ["-r %s -i serveraction powercycle" % ip], + username, password) + else: + output = runcmd(cmd, ["-r %s -i getsysinfo" % ip], + username, password) + + print "RUNCMD: %s" % output + if verbose: + print output + return 0 + + except Exception, err: + print "runcmd raised exception %s" % err + return str(err) diff --git a/pcucontrol/models/HPiLO.py b/pcucontrol/models/HPiLO.py new file mode 100644 index 0000000..78ceb0a --- /dev/null +++ b/pcucontrol/models/HPiLO.py @@ -0,0 +1,60 @@ +from pcucontrol.reboot import * +from distutils.sysconfig import get_python_lib; + +class HPiLO(PCUControl): + supported_ports = [22,443] + def run(self, node_port, dryrun): + if self.type == Transport.SSH: + return self.run_ssh(node_port, dryrun) + elif self.type == Transport.HTTP or self.type == Transport.HTTPS: + return self.run_https(node_port, dryrun) + else: + raise ExceptionNoTransport("Unimplemented Transport for HPiLO %s" % self.type) + + def run_ssh(self, node_port, dryrun): + + self.transport.open(self.host, self.username) + self.transport.sendPassword(self.password) + + # hpiLO-> + self.transport.ifThenSend("hpiLO->", "cd system1") + + # Reboot Outlet N (Y/N)? + if dryrun: + self.transport.ifThenSend("hpiLO->", "POWER") + else: + # Reset this machine + self.transport.ifThenSend("hpiLO->", "reset") + + self.transport.ifThenSend("hpiLO->", "exit") + + self.transport.close() + return 0 + + def run_https(self, node_port, dryrun): + + locfg = command.CMD() + + cmd_str = get_python_lib(1) + "/pcucontrol/models/hpilo/" + + cmd = cmd_str + "locfg.pl -s %s -f %s -u %s -p '%s' | grep 'MESSAGE' | grep -v 'No error'" % ( + self.host, cmd_str+"iloxml/Get_Network.xml", + self.username, self.password) + sout, serr = locfg.run_noexcept(cmd) + + if sout.strip() != "" or serr.strip() != "": + print "sout: %s" % sout.strip() + return sout.strip() + serr.strip() + + if not dryrun: + locfg = command.CMD() + cmd = cmd_str + "locfg.pl -s %s -f %s -u %s -p '%s' | grep 'MESSAGE' | grep -v 'No error'" % ( + self.host, cmd_str+"iloxml/Reset_Server.xml", + self.username, self.password) + sout, serr = locfg.run_noexcept(cmd) + + if sout.strip() != "": + print "sout: %s" % sout.strip() + #return sout.strip() + + return 0 diff --git a/pcucontrol/models/IPAL.py b/pcucontrol/models/IPAL.py new file mode 100644 index 0000000..8929946 --- /dev/null +++ b/pcucontrol/models/IPAL.py @@ -0,0 +1,152 @@ +from pcucontrol.reboot import * + +class IPAL(PCUControl): + """ + This now uses a proprietary format for communicating with the PCU. I + prefer it to Telnet, and Web access, since it's much lighter weight + and, more importantly, IT WORKS!! HHAHHHAHAHAHAHAHA! + """ + supported_ports = [9100,23,80] + + def format_msg(self, data, cmd): + esc = chr(int('1b',16)) + return "%c%s%c%s%c" % (esc, self.password, esc, data, cmd) # esc, 'q', chr(4)) + + def recv_noblock(self, s, count): + import errno + + try: + # TODO: make sleep backoff, before stopping. + time.sleep(8) + ret = s.recv(count, socket.MSG_DONTWAIT) + except socket.error, e: + if e[0] == errno.EAGAIN: + #raise Exception(e[1]) + raise ExceptionNotFound(e[1]) + elif e[0] == errno.ETIMEDOUT: + raise ExceptionTimeout(e[1]) + else: + # TODO: not other exceptions. + raise Exception(e) + return ret + + #def run(self, node_port, dryrun): + # if self.type == Transport.IPAL: + # ret = self.run_ipal(node_port, dryrun) + # if ret != 0: + # ret2 = self.run_telnet(node_port, dryrun) + # if ret2 != 0: + # return ret + # return ret2 + # return ret + # elif self.type == Transport.TELNET: + # return self.run_telnet(node_port, dryrun) + # else: + # raise ExceptionNoTransport("Unimplemented Transport for IPAL") + + def run_telnet(self, node_port, dryrun): + # TELNET version of protocol... + self.transport.open(self.host) + ## XXX Some iPals require you to hit Enter a few times first + self.transport.ifThenSend("Password >", "\r\n\r\n", ExceptionNotFound) + self.transport.ifThenSend("Password >", "\r\n\r\n", ExceptionNotFound) + # Login + self.transport.ifThenSend("Password >", self.password, ExceptionPassword) + self.transport.write("\r\n\r\n") + if not dryrun: # P# - Pulse relay + print "node_port %s" % node_port + self.transport.ifThenSend("Enter >", + "P%s"%node_port, + ExceptionNotFound) + print "send newlines" + self.transport.write("\r\n\r\n") + print "after new lines" + # Get the next prompt + print "wait for enter" + self.transport.ifElse("Enter >", ExceptionTimeout) + print "closing " + self.transport.close() + return 0 + + def run_ipal(self, node_port, dryrun): + import errno + + power_on = False + + print "open socket" + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + try: + print "connect" + s.connect((self.host, 9100)) + except socket.error, e: + s.close() + if e[0] == errno.ECONNREFUSED: + # cannot connect to remote host + raise ExceptionNotFound(e[1]) + elif e[0] == errno.ETIMEDOUT: + raise ExceptionTimeout(e[1]) + else: + # TODO: what other conditions are there? + raise Exception(e) + + # get current status + print "Checking status" + s.send(self.format_msg("", 'O')) + ret = self.recv_noblock(s, 8) + print "Current status is '%s'" % ret + + if ret == '': + raise Exception("Status returned 'another session already open' on %s %s : %s" % (self.host, node_port, ret)) + + if node_port < len(ret): + status = ret[node_port] + if status == '1': + # up + power_on = True + elif status == '0': + # down + power_on = False + elif status == '6': + raise ExceptionPort("IPAL reported 'Cable Error' on %s socket %s : %s" % (self.host, node_port, ret)) + else: + raise Exception("Unknown status for PCU %s socket %s : %s" % (self.host, node_port, ret)) + else: + raise Exception("Mismatch between configured port and PCU %s status: %s %s" % (self.host, node_port, ret)) + + + if not dryrun: + if power_on: + print "Pulsing %s" % node_port + s.send(self.format_msg("%s" % node_port, 'P')) + else: + # NOTE: turn power on ; do not pulse the port. + print "Power was off, so turning on ..." + s.send(self.format_msg("%s" % node_port, 'E')) + #s.send(self.format_msg("%s" % node_port, 'P')) + + print "Receiving response." + ret = self.recv_noblock(s, 8) + print "Current status is '%s'" % ret + + if node_port < len(ret): + status = ret[node_port] + if status == '1': + # up + power_on = True + elif status == '0': + # down + power_on = False + elif status == '6': + raise ExceptionPort("IPAL reported 'Cable Error' on %s socket %s : %s" % (self.host, node_port, ret)) + else: + raise Exception("Unknown status for PCU %s socket %s : %s" % (self.host, node_port, ret)) + else: + raise Exception("Mismatch between configured port and PCU %s status: %s %s" % (self.host, node_port, ret)) + + if power_on: + return 0 + else: + return "Failed Power On" + + s.close() + return 0 diff --git a/pcucontrol/models/IntelAMT.py b/pcucontrol/models/IntelAMT.py new file mode 100644 index 0000000..61e820d --- /dev/null +++ b/pcucontrol/models/IntelAMT.py @@ -0,0 +1,21 @@ +from pcucontrol.reboot import * +from distutils.sysconfig import get_python_lib; + +class IntelAMT(PCUControl): + supported_ports = [16992] + + def run_amt(self, node_port, dryrun): + + cmd = command.CMD() + # TODO: need to make this path universal; not relative to pwd. + cmd_str = get_python_lib(1) + "/pcucontrol/models/intelamt/remoteControl" + + if dryrun: + # NOTE: -p checks the power state of the host. + # TODO: parse the output to find out if it's ok or not. + cmd_str += " -p http://%s:16992/RemoteControlService -user admin -pass '%s' " % (self.host, self.password ) + else: + cmd_str += " -A http://%s:16992/RemoteControlService -user admin -pass '%s' " % (self.host, self.password ) + + print cmd_str + return cmd.system(cmd_str, Transport.TELNET_TIMEOUT) diff --git a/pcucontrol/models/ManualPCU.py b/pcucontrol/models/ManualPCU.py new file mode 100644 index 0000000..3a21cd9 --- /dev/null +++ b/pcucontrol/models/ManualPCU.py @@ -0,0 +1,13 @@ +from pcucontrol.reboot import * + +class ManualPCU(PCUControl): + supported_ports = [22,23,80,443] + + def run_http(self, node_port, dryrun): + if not dryrun: + # TODO: send email message to monitor admin requesting manual + # intervention. This should always be an option for ridiculous, + # custom jobs. + pass + return 0 + diff --git a/pcucontrol/models/OpenIPMI.py b/pcucontrol/models/OpenIPMI.py new file mode 100644 index 0000000..f52ea39 --- /dev/null +++ b/pcucontrol/models/OpenIPMI.py @@ -0,0 +1,25 @@ + +from pcucontrol.reboot import * + +class OpenIPMI(PCUControl): + + supported_ports = [80,443,623] + + # TODO: get exit codes to determine success or failure... + def run_https(self, node_port, dryrun): + + if not dryrun: + cmd = "ipmitool -I lanplus -H %s -U %s -P '%s' power cycle " + (i,p) = os.popen4(cmd % ( self.host, self.username, self.password) ) + result = p.read() + print "RESULT: ", result + else: + cmd = "ipmitool -I lanplus -H %s -U %s -P '%s' user list " + (i,p) = os.popen4(cmd % ( self.host, self.username, self.password) ) + result = p.read() + print "RESULT: ", result + + if "Error" in result: + return result + else: + return 0 diff --git a/pcucontrol/models/PM211MIP.py b/pcucontrol/models/PM211MIP.py new file mode 100644 index 0000000..007b307 --- /dev/null +++ b/pcucontrol/models/PM211MIP.py @@ -0,0 +1,5 @@ +from pcucontrol.reboot import * +from ManualPCU import * + +class PM211MIP(ManualPCU): + supported_ports = [80,443] diff --git a/pcucontrol/models/WTIIPS4.py b/pcucontrol/models/WTIIPS4.py new file mode 100644 index 0000000..aebde31 --- /dev/null +++ b/pcucontrol/models/WTIIPS4.py @@ -0,0 +1,18 @@ +from pcucontrol.reboot import * + +class WTIIPS4(PCUControl): + supported_ports = [23] + def run_telnet(self, node_port, dryrun): + self.transport.open(self.host) + self.transport.sendPassword(self.password, "Enter Password:") + + self.transport.ifThenSend("IPS> ", "/Boot %s" % node_port) + if not dryrun: + self.transport.ifThenSend("Sure? (Y/N): ", "N") + else: + self.transport.ifThenSend("Sure? (Y/N): ", "Y") + + self.transport.ifThenSend("IPS> ", "") + + self.transport.close() + return 0 diff --git a/pcucontrol/models/X10Toggle.py b/pcucontrol/models/X10Toggle.py new file mode 100644 index 0000000..20d7cef --- /dev/null +++ b/pcucontrol/models/X10Toggle.py @@ -0,0 +1,49 @@ + +from pcucontrol.reboot import * +### rebooting x10toggle based systems addressed by port +# Marc E. Fiuczynski - May 31 2005 +# tested on 4-ports models known as PSE505-FR +# uses ssh and password to login to an account +# that will cause the system to be powercycled. + +TELNET_TIMEOUT = 120 +def telnet_answer(telnet, expected, buffer): + global verbose + + output = telnet.read_until(expected, TELNET_TIMEOUT) + #if verbose: + # logger.debug(output) + if output.find(expected) == -1: + raise ExceptionNotFound, "'%s' not found" % expected + else: + telnet.write(buffer + "\r\n") + +def x10toggle_reboot(ip, username, password, port, dryrun): + global verbose + + ssh = None + try: + ssh = pyssh.Ssh(username, ip) + ssh.open() + + # Login + telnet_answer(ssh, "password:", password) + + if not dryrun: + # Reboot + telnet_answer(ssh, "x10toggle>", "A%d" % port) + + # Close + output = ssh.close() + if verbose: + logger.debug(output) + return 0 + + except Exception, err: + if verbose: + logger.debug(err) + if ssh: + output = ssh.close() + if verbose: + logger.debug(output) + return errno.ETIMEDOUT diff --git a/pcucontrol/models/__init__.py b/pcucontrol/models/__init__.py new file mode 100644 index 0000000..01d8f4b --- /dev/null +++ b/pcucontrol/models/__init__.py @@ -0,0 +1,14 @@ +from OpenIPMI import * +from OpenIPMI import OpenIPMI as IPMI +from IPAL import * +from APCControl import * +from IntelAMT import * +from DRAC import * +from HPiLO import * +from BayTech import * +from WTIIPS4 import * +from ePowerSwitch import * +from BlackBoxPSMaverick import * +from CustomPCU import * +from ManualPCU import * +from PM211MIP import * diff --git a/pcucontrol/models/ePowerSwitch.py b/pcucontrol/models/ePowerSwitch.py new file mode 100644 index 0000000..75e552a --- /dev/null +++ b/pcucontrol/models/ePowerSwitch.py @@ -0,0 +1,122 @@ +from pcucontrol.reboot import * + +class ePowerSwitchNew(PCUControl): + supported_ports = [80] + # NOTE: + # The old code used Python's HTTPPasswordMgrWithDefaultRealm() + # For some reason this both doesn't work and in some cases, actually + # hangs the PCU. Definitely not what we want. + # + # The code below is much simpler. Just letting things fail first, + # and then, trying again with authentication string in the header. + # + def run_http(self, node_port, dryrun): + self.transport = None + self.url = "http://%s:%d/" % (self.host,80) + uri = "%s:%d" % (self.host,80) + + req = urllib2.Request(self.url) + try: + handle = urllib2.urlopen(req) + except IOError, e: + # NOTE: this is expected to fail initially + pass + else: + print self.url + print "-----------" + print handle.read() + print "-----------" + return "ERROR: not protected by HTTP authentication" + + if not hasattr(e, 'code') or e.code != 401: + return "ERROR: failed for: %s" % str(e) + + base64data = base64.encodestring("%s:%s" % (self.username, self.password))[:-1] + # NOTE: assuming basic realm authentication. + authheader = "Basic %s" % base64data + req.add_header("Authorization", authheader) + + try: + f = urllib2.urlopen(req) + except IOError, e: + # failing here means the User/passwd is wrong (hopefully) + raise ExceptionPassword("Incorrect username/password") + + # NOTE: after verifying that the user/password is correct, + # actually reboot the given node. + if not dryrun: + try: + data = urllib.urlencode({'P%d' % node_port : "r"}) + req = urllib2.Request(self.url + "cmd.html") + req.add_header("Authorization", authheader) + # add data to handler, + f = urllib2.urlopen(req, data) + #if self.transport.verbose: print f.read() + except: + import traceback; traceback.print_exc() + + # fetch url one more time on cmd.html, econtrol.html or whatever. + # pass + else: + #if self.transport.verbose: print f.read() + pass + + return 0 + +class ePowerSwitchOld(PCUControl): + def run_http(self, node_port, dryrun): + self.url = "http://%s:%d/" % (self.host,80) + uri = "%s:%d" % (self.host,80) + + # create authinfo + authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm() + authinfo.add_password (None, uri, self.username, self.password) + authhandler = urllib2.HTTPBasicAuthHandler( authinfo ) + + # NOTE: it doesn't seem to matter whether this authinfo is here or not. + transport = urllib2.build_opener(authinfo) + f = transport.open(self.url) + if self.transport.verbose: print f.read() + + if not dryrun: + transport = urllib2.build_opener(authhandler) + f = transport.open(self.url + "cmd.html", "P%d=r" % node_port) + if self.transport.verbose: print f.read() + + self.transport.close() + return 0 + +class ePowerSwitchOld(PCUControl): + supported_ports = [80] + def run_http(self, node_port, dryrun): + self.url = "http://%s:%d/" % (self.host,80) + uri = "%s:%d" % (self.host,80) + + # TODO: I'm still not sure what the deal is here. + # two independent calls appear to need to be made before the + # reboot will succeed. It doesn't seem to be possible to do + # this with a single call. I have no idea why. + + # create authinfo + authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm() + authinfo.add_password (None, uri, self.username, self.password) + authhandler = urllib2.HTTPBasicAuthHandler( authinfo ) + + # NOTE: it doesn't seem to matter whether this authinfo is here or not. + transport = urllib2.build_opener() + f = transport.open(self.url + "elogin.html", "pwd=%s" % self.password) + if self.transport.verbose: print f.read() + + if not dryrun: + transport = urllib2.build_opener(authhandler) + f = transport.open(self.url + "econtrol.html", "P%d=r" % node_port) + if self.transport.verbose: print f.read() + + # data= "P%d=r" % node_port + #self.open(self.host, self.username, self.password) + #self.sendHTTP("elogin.html", "pwd=%s" % self.password) + #self.sendHTTP("econtrol.html", data) + #self.sendHTTP("cmd.html", data) + + #self.close() + return 0 diff --git a/pcucontrol/models/hpilo/iloxml/Get_Network.xml b/pcucontrol/models/hpilo/iloxml/Get_Network.xml new file mode 100644 index 0000000..fc7ae7b --- /dev/null +++ b/pcucontrol/models/hpilo/iloxml/Get_Network.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/pcucontrol/models/hpilo/iloxml/PowerOff_Server.xml b/pcucontrol/models/hpilo/iloxml/PowerOff_Server.xml new file mode 100644 index 0000000..2a91833 --- /dev/null +++ b/pcucontrol/models/hpilo/iloxml/PowerOff_Server.xml @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/hpilo/iloxml/PowerOn_Server.xml b/pcucontrol/models/hpilo/iloxml/PowerOn_Server.xml new file mode 100644 index 0000000..fc5f40c --- /dev/null +++ b/pcucontrol/models/hpilo/iloxml/PowerOn_Server.xml @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/hpilo/iloxml/Reset_Server.xml b/pcucontrol/models/hpilo/iloxml/Reset_Server.xml new file mode 100644 index 0000000..707331c --- /dev/null +++ b/pcucontrol/models/hpilo/iloxml/Reset_Server.xml @@ -0,0 +1,48 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/hpilo/locfg.pl b/pcucontrol/models/hpilo/locfg.pl new file mode 100755 index 0000000..0ff3529 --- /dev/null +++ b/pcucontrol/models/hpilo/locfg.pl @@ -0,0 +1,132 @@ +#!/usr/bin/perl +########################################################################### +## +## Simplified perl version of CPQLOCFG +## Copyright 2003,2007 Hewlett Packard Development Company, L.P. +## +## To use this program, you must have Net::SSLeay and IO::Socket::SSL +## installed. You may obtain these modules from http://www.cpan.org/ +## +## You may use and modify this program to suit your needs. +## +########################################################################### + +use IO::Socket::SSL; +use Getopt::Long; + + +sub usage +{ + print "Usage:\n"; + print " locfg -s server [-l logfile] -f inputfile [-u username -p password]\n"; + print " Note: Use -u and -p with caution as command line options are\n"; + print " visible on Linux.\n"; + exit 0; +} + +sub usage_err +{ + print "Note:\n"; + print " Both username and password must be specified with the -u and -p switches.\n"; + print " Use -u and -p with caution as command line options are visible on Linux.\n"; + exit 0; +} +########################################################################### +## +## Process options +## +########################################################################### + +my $host, $logfile, $file, $verbose, $help, $uname, $pword; +$verbose = 0; +$r = GetOptions("server|s=s" => \$host, + "logfile|l=s" => \$logfile, + "input|f=s" => \$file, + "u=s" => \$uname, + "p=s" => \$pword, + "verbose" => \$verbose, + "help|?" => \$help + ); + +if ($help || !$host || !$file) { + usage(); +} + +# Username and Password must be entered together +if( ($uname && !($pword)) || (!($uname) && $pword) ) { + usage_err(); +} + +if ($logfile) { + # If a logfile is specified, open it and select it as the default + # filehandle + open(L, ">$logfile") || die "Can't open $logfile\n"; + select(L); +} + +# Set the default SSL port number if no port is specified +$host .= ":443" unless ($host =~ m/:/); + +# Open the SSL connection and the input file +my $client = new IO::Socket::SSL->new(PeerAddr => $host); +if (!$client) { + print "ERROR: Failed to establish SSL connection with $host.\n"; + exit 1; +} + +open(F, "<$file") || die "Can't open $file\n"; + +# Send the XML header and begin processing the file +print $client '' . "\r\n"; +while($ln=) { + # Chomp of any EOL characters + $ln =~ s/\r|\n//g; + + # Find LOGIN tag. + if ((($ln =~ ?<[ ]*LOGIN[ ]?) || ($ln =~ ?<[ ]*LOGIN$?)) && ($pword) && ($uname)) { + while( !($ln =~ m/\>/i) ) { + $ln = ; + } + print $client "\n"; + print "\n\n" if ($verbose); + # print "\nOverriding credentials in scripts with those from command line.\n" if ($verbose); + next; + } + + # Special case: UPDATE_RIB_FIRMWARE violates XML. Send the full + # UPDATE firmware tag followed by the binary firmware image + if ($ln =~ m/UPDATE_RIB_FIRMWARE/i) { + if ($ln =~ m/IMAGE_LOCATION=\"(.*)\"/i) { + $firmware = $1; + open(G, "<$firmware") || die "Can't open $firmware\n"; + $len = (stat(G))[7]; + print $client "\r\n\r\n"; + print "\r\n\r\n" if ($verbose); + $x = read(G, $buf, $len); + print "Read $x bytes from $firmware\n" if ($verbose); + $x = $client->write($buf, $x); + print "Wrote $x bytes\n" if ($verbose); + close(G); + next; + } + # print "\nError: syntax error detected in $ln\n" if ($verbose); + } + # Send the script to the iLO board + print $ln . "\n" if ($verbose); + print $client $ln . "\r\n" ; +} +close(F); + +print "----\n" if ($verbose); + +# Ok, now read the responses back from iLO +while($ln=<$client>) { + last if (length($ln) == 0); + + # This isn't really required, but it makes the output look nicer + $ln =~ s/<\/RIBCL>/<\/RIBCL>\n/g; + print $ln; +} + +# All done +exit 0; diff --git a/pcucontrol/models/intelamt/Include/CommonDefinitions.h b/pcucontrol/models/intelamt/Include/CommonDefinitions.h new file mode 100644 index 0000000..79555ab --- /dev/null +++ b/pcucontrol/models/intelamt/Include/CommonDefinitions.h @@ -0,0 +1,289 @@ +//---------------------------------------------------------------------------- +// +// Copyright (C) Intel Corporation, 2004 - 2006. +// +// File: CommonDefinitions.h +// +// Contents: Sample code for an Intel® AMT Network client. +// +// Notes: This file contains type, function and constant definitions +// used throughout the code of the all sample applications. +// +//---------------------------------------------------------------------------- + +#ifndef COMMON_DEFINITIONS_H +#define COMMON_DEFINITIONS_H + + +#include "StatusCodeDefinitions.h" +#ifdef _WIN32 +/* + * gsoapWinHTTP.h for gSoap WinHTTP extension - needed for TLS support + */ +#include "gsoapWinHttp.h" +#include "StatusStrings.h" +#include +#else +/* + * httpDigest.h for gSoap HTTP Digest support + */ +#include "httpDigest.h" +#endif + +/* + * Function prototypes + */ +void PrintAuthenticationNote(); +bool CheckReturnStatus(unsigned int res, unsigned long status,const char *message); +bool ValidateIP(const char *uri); +void GetString(char *msg, char *s, bool hidden); +bool ChangeService(const char *uri, const char *newService, char *newUri); +bool DisplayWarning(const char *msg); +bool GetNumber(int *number); +void ReplaceSubstring(const char *oldString,const char *oldSubstr, + const char *newSubstr, char *newString); +void SetIPAddress(unsigned long &address, unsigned long bytes[]); +void NumberToIP(unsigned long address, unsigned long bytes[]); +void NumberToString(unsigned long number, char *string); +void IpToString(unsigned long address, char *string); +void StringToIP(const char *string, unsigned long &address); +void GuidToString(const unsigned char* guid, char* string); +bool ExtractIPFromUri(const char *uri, char *baseUrl); +void IsEmulator(const char *targetUrl, int *isEmulator); +bool GetOption(int *commandLineLength, char *argv[], int numOfArgs, + char **option, char **commandLine[]); +void PrintSuccess(bool print = true); +void FunctionCall(const char *message); +#ifdef _WIN32 +bool ParseCommandLine(int commandLineLength,char* commandLine[],char **target, + char **certName, bool *local, bool *krb,bool *verbose = NULL, + char **username = NULL, char **password = NULL); +#define CHAR _TCHAR +#else +bool ParseCommandLine(int commandLineLength,char* commandLine[],char **target, + char **certName = NULL,char **certPass = NULL, + bool *verbose = NULL, + char **username = NULL, char **password = NULL); +#define CHAR char +#endif + +/* + * Constants for the common use + */ +static const int MAX_LINE_LEN = 1024; +static const int TIMEOUT = 80; +static const char *DEFAULT_USERNAME = "admin"; +static const char *DEFAULT_PASSWORD = "admin"; +static const char *CERT_NAME = "-certName"; +static const char *USER = "-user"; +static const char *PASS = "-pass"; +static const char *VERBOSE = "-verbose"; +#ifdef _WIN32 +static const char *LOCAL = "-local"; +static const char *KRB = "-krb"; +#else +static const char *CERT_PASS = "-certPass"; +#endif + +/* + * The structure that represents + * the gSOAP rintime environment + */ +class Soap +{ +private: + struct soap *m_soap; + char *m_username; + char *m_password; + char *m_ip; + +public: + // Constructor +#ifdef _WIN32 + Soap(const char *url, const char *certName, + const char *username, const char *password, + bool local, bool krb) +#else + Soap(const char *url, const char *certName, + const char *certPass, const char *username, + const char *password) +#endif + { + m_username = new char[MAX_LINE_LEN]; + m_password = new char[MAX_LINE_LEN]; + m_ip = new char[MAX_LINE_LEN]; + SetIp(url); + SetUsername(DEFAULT_USERNAME); + SetPassword(DEFAULT_PASSWORD); + + if ( +#ifdef _WIN32 + krb == false && +#endif + !username) + { + // To use the default user name, comment the following line: + GetString("Username: ", m_username, false); + } + else + { + SetUsername(username); + } + + if ( +#ifdef _WIN32 + krb == false && +#endif + !password) + { + // To use the default password, comment the following line: + GetString("Password: ", m_password, true); + } + else + { + SetPassword(password); + } + m_soap = soap_new(); + if( m_soap ) + { +#ifdef _WIN32 + SetSoap(certName,local,krb); +#else + SetSoap(certName,certPass); +#endif + + } + } + + void Init(SOAP_NMAC struct Namespace *name = NULL) + { + m_soap->userid = m_username; + m_soap->passwd = m_password; + + if(name != NULL) + { + // setting namespace for the runtime environment + soap_set_namespaces(m_soap, name); + } + } + + char *GetIp() + { + return m_ip; + } + + char *GetUsername() + { + return m_username; + } + + char *GetPassword() + { + return m_password; + } + + struct soap *GetSoap() + { + return m_soap; + } + + void SetIp(const char *url) + { + memset(m_ip, 0, MAX_LINE_LEN); + if(url != NULL) + { + strncpy(m_ip, url, MAX_LINE_LEN - 1); + } + } + + void SetUsername(const char *username) + { + memset(m_username,0,MAX_LINE_LEN); + if(username != NULL) + { + strncpy(m_username, username, MAX_LINE_LEN - 1); + } + } + + void SetPassword(const char *password) + { + memset(m_password,0,MAX_LINE_LEN); + if(password != NULL) + { + strncpy(m_password, password, MAX_LINE_LEN - 1); + } + } + +#ifdef _WIN32 + void SetSoap(const CHAR *certName, bool local, bool krb) +#else + void SetSoap(const CHAR *certName, const char *certPass) +#endif + { + m_soap->recv_timeout = TIMEOUT; + m_soap->send_timeout = TIMEOUT; + m_soap->connect_timeout = TIMEOUT; + m_soap->accept_timeout = TIMEOUT; + +#ifdef _WIN32 + // gsoap winhttp extension + soap_register_plugin( m_soap, winhttp_plugin ); + soap_omode(m_soap, SOAP_IO_KEEPALIVE); + if( certName ) + { + winhttp_set_certificate_name(m_soap, certName); + } + + winhttp_set_local(m_soap,local); + winhttp_set_auth_scheme(m_soap,krb); +#else + // gsoap HTTP Digest plugin + if ( strncmp(m_ip+strlen(m_ip)-5, ".asmx", 5)) { + soap_register_plugin(m_soap, http_digest); + } + soap_omode(m_soap, SOAP_IO_KEEPALIVE); + soap_imode(m_soap, SOAP_IO_KEEPALIVE); + if ( !strncmp(m_ip, "https:", 6) ) + { + soap_ssl_client_context(m_soap, + SOAP_SSL_DEFAULT, + certName, + certPass, + "/usr/share/ssl/cert.pem", + "/usr/share/ssl/certs/", NULL); + } +#endif + } + + // Destructor + ~Soap() + { + if(m_username) + { + delete [] m_username; + m_username = NULL; + } + if(m_password) + { + delete [] m_password; + m_password = NULL; + } + if(m_ip) + { + delete [] m_ip; + m_ip = NULL; + } + if( m_soap ){ + soap_destroy(m_soap); + soap_end(m_soap); + soap_done(m_soap); + free(m_soap); + m_soap = NULL; + } + } +}; + + + + +#endif diff --git a/pcucontrol/models/intelamt/Include/IMRSDK.h b/pcucontrol/models/intelamt/Include/IMRSDK.h new file mode 100644 index 0000000..0fe9cea --- /dev/null +++ b/pcucontrol/models/intelamt/Include/IMRSDK.h @@ -0,0 +1,260 @@ +// Copyright (C) Intel Corporation, 2003 - 2006. + +#ifndef _IMR_SDK_H_ +#define _IMR_SDK_H_ + +#define EXPORTED_FUNC + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +#ifndef BOOL + typedef int BOOL; + #define TRUE 1 + #define FALSE 0 +#endif + +#define MAX_IP_LEN 128 +#define MAX_NAME_LEN 128 +#define MAX_COMP_NAME 128 +#define MAX_PSWD_LEN 128 +#define KEY_LEN 20 +#define GUID_LEN 16 + +// SOL spec defines text length as maximum 255 +#define MAX_SOL_MESSAGE 0xFF + +#define INVALID_CLIENT_ID (unsigned long)-1 +typedef unsigned long ClientID; + +#define INVALID_SESSION_ID (unsigned long)-1 +typedef unsigned long SessionID; + + +typedef enum { + IMR_RES_OK, + IMR_RES_ERROR, + IMR_RES_INVALID_PARAMETER, + IMR_RES_NOT_INITIALIZED, + IMR_RES_ALREADY_INITIALIZED, + IMR_RES_MEMALLOC_FAILED, + IMR_RES_UNSUPPORTED, + IMR_RES_CLIENT_NOT_FOUND, + IMR_RES_DUPLICATE_CLIENT, + IMR_RES_CLIENT_NOT_ACTIVE, + IMR_RES_CLIENT_ACTIVE, + IMR_RES_SESSION_ALREADY_OPEN, + IMR_RES_SESSION_CLOSED, + IMR_RES_SOCKET_ERROR, + IMR_RES_UNKNOWN_PROTOCOL, + IMR_RES_PROTOCOL_ALREADY_REGISTERED, + IMR_RES_PENDING, + IMR_RES_UNEXPECTED_PACKET, + IMR_RES_TIMEOUT, + IMR_RES_CORRUPT_PACKET, + IMR_RES_OS_ERROR, + IMR_RES_IDER_VERSION_NOT_SUPPORTED, + IMR_RES_IDER_COMMAND_RUNNING, + IMR_RES_STORAGE_FAILURE, + IMR_RES_UNKNOWN, + IMR_RES_AUTH_FAILED, + IMR_RES_CLIENT_TYPE_UNKNOWN, + IMR_RES_CLIENT_BUSY, + IMR_RES_CLIENT_UNSUPPORTED, + IMR_RES_CLIENT_ERROR, + IMR_RES_NOT_ENOUGH_SPACE, + IMR_RES_SESSION_LOOPBACK, + IMR_RES_TLS_CONNECTION_FAILED, + + IMR_RES_COUNT, // must be last entry +} IMRResult; + +typedef struct { + unsigned short major; + unsigned short minor; +} IMRVersion; + +typedef enum {CLI_TCP = 1, CLI_TLS = 2, CLI_UNKNOWN } ClientType; + + +typedef char GUIDType[GUID_LEN]; + +typedef struct { + ClientType type; + char ip[MAX_IP_LEN]; + GUIDType guid; +} ClientInfo; + + +//IN Parameter for IDER/SOL session + +typedef struct { + char user_name[MAX_NAME_LEN]; // user name - nul terminated string + char user_pswd[MAX_PSWD_LEN]; // user password - nul terminated string +} TCPSessionParams; + +//IN Parameter for SOL session +typedef struct { + unsigned short tx_over_timeout; + unsigned short tx_buf_timeout; + unsigned short hb_interval; + unsigned short fifo_rx_flush_timeout; + unsigned short rx_timeout; +} SOLTout; + +//IN Parameter for IDER session +typedef struct { + unsigned short rx_timeout; //client host RX timeout as defined in the IDER spec. + unsigned short tx_timeout; //client host TX timeout as defined in the IDER spec. + unsigned short hb_timeout; //client FW HB interval as defined in the IDER spec. +} IDERTout; + +//OUT parameter for querying supported IDER client features +typedef struct { + BOOL ider_dev_pri; //TRUE if client FW supports enable/disable of primary IDE devices + BOOL ider_dev_sec; //TRUE if client FW supports enable/disable of secondary IDE devices + BOOL reserved[30]; +}FeaturesSupported; + +typedef enum {IDER_ENABLE, IDER_DISABLE, IDER_NOP } SetOperation; +//Timing options for the IDE device enabling/disabling: +//ONRESET - Client should perform command at the next FW RESET. +//GRACEFULLY - Client should perform command if there is no other host command in progress. +//IMMEDIATELY - Client should perform command immediately. +typedef enum {IDER_SET_ONRESET, IDER_SET_GRACEFULLY, IDER_SET_IMMEDIATELY, } SetOption; + +typedef enum { IDER_DISABLED, IDER_ENABLED } DeviceState; + +//Client returns REJECTED if there is a Host Command in progress +//and the Disable/Enable command can't be performed at this time +typedef enum { IDER_REJECTED, IDER_DONE } SetResult; + +//IN parameter for querying client IDE devices state +typedef struct { + DeviceState pri_default; //Default primary devices state at the Client FW + DeviceState pri_current; //Current primary devices state at the Client FW + DeviceState sec_default; //Default secondary devices state at the Client FW + DeviceState sec_current; //Default secondary devices state at the Client FW +} IDERDeviceState; + +//IN paramter for changing client IDE devices state +typedef struct { + SetOperation pri_op; //Pimary device operation (enable or disable) + SetOption pri_timing; //Pimary device operation timing + SetOperation sec_op; //Not supported by the SDK yet + SetOption sec_timing; //Not supported by the SDK yet +} IDERDeviceCmd; + +//OUT parameter - IDERDeviceCmd execution result returned by the client +typedef struct { + SetResult pri_res; + SetResult sec_res; +} IDERDeviceResult; + +typedef struct { + BOOL error_state; //TRUE if session is in ERROR state + BOOL data_transfer; //TRUE if there is a read/write command in progress + unsigned short num_reopen; //number of session re-opens due to error recovery + unsigned long num_error; //number of ErrorOccured messages received + unsigned long num_reset; //number of ResetOccured messages received + unsigned long last_cmd_length;//last data transfer (read/write) length in bytes + unsigned long data_sent; //bytes of data sent to the client + unsigned long data_received; //bytes of data received from the client + unsigned long packets_sent; //mesages sent during the session + unsigned long packets_received;//messages received during the session +} IDERStatistics; + +typedef enum {SEC_LEVEL_NONE, SEC_LEVEL_AUTH, SEC_LEVEL_ENCR, SEC_LEVEL_AUTH_ENCR } SecLevel; + +typedef enum { SOL_LOOPBACK_NONE = 0, SOL_LOOPBACK_RS232C = 1 } SOLLoopbackMode; + + +//General: +EXPORTED_FUNC IMRResult IMR_Init(IMRVersion *version, char *ini_file); +EXPORTED_FUNC IMRResult IMR_Close(); +EXPORTED_FUNC IMRResult IMR_GetErrorStringLen(IMRResult, int * str_len); +EXPORTED_FUNC IMRResult IMR_GetErrorString(IMRResult, char *str); +EXPORTED_FUNC IMRResult IMR_SetCertificateInfo(const char *root_cert, const char *private_cert, const char *cert_pass); + +//Client List: +EXPORTED_FUNC IMRResult IMR_AddClient( ClientType new_client_type, char *client_ip, GUIDType client_guid, ClientID *new_client_id); +EXPORTED_FUNC IMRResult IMR_RemoveClient(ClientID client_id); +EXPORTED_FUNC IMRResult IMR_RemoveAllClients(); +EXPORTED_FUNC IMRResult IMR_GetAllClients(ClientID *client_list, int *client_list_size); + +EXPORTED_FUNC IMRResult IMR_GetClientInfo(ClientID client_id, ClientInfo * ); + + + +//SOL: +EXPORTED_FUNC IMRResult IMR_SOLOpenTCPSession(ClientID client_id, TCPSessionParams * params, + SOLTout* touts , SOLLoopbackMode *loopback); +EXPORTED_FUNC IMRResult IMR_SOLCloseSession(ClientID client_id); +EXPORTED_FUNC IMRResult IMR_SOLSendText(ClientID client_id, unsigned char *data, int data_len); +EXPORTED_FUNC IMRResult IMR_SOLReceiveText(ClientID client_id, unsigned char *data, int *data_len); + +//IDER: + +// +//client_id - unique client ID, as returned by the IMR_AddClient +//params - pointer to the IDER over TCP/TLS session paramters structure +//touts - pointer to the IDER over TCP/TLS session timeouts structure +//drive0 - floppy drive name for the IDER over TCP/TLS session. should be null terminated. +//drive1 - CD drive name for the IDER over TCP/TLS session. should be null terminated. +//returns - IMR_RES_OK on success, error otherwise. +// +//Use this function to establish a new IDER session with the client. +//Function will create a new connection and exchange messages needed in order +//to open IDER session. It will return only when the session is established, or +//error occured. After the session opening client will initiate data transfers. +EXPORTED_FUNC IMRResult IMR_IDEROpenTCPSession(ClientID client_id, TCPSessionParams * params, + IDERTout* touts , + char *drive0, char *drive1); +// +//client_id - unique client ID, as returned by the IMR_AddClient +//returns - IMR_RES_OK on success, error otherwise. +// +//Use this function to close an active IDER session. After the function returns +//no other operations can be done succesfully on the session. Closing a session during +//write data operation can cause data corruption. +EXPORTED_FUNC IMRResult IMR_IDERCloseSession(ClientID client_id); +// +//client_id - unique client ID, as returned by the IMR_AddClient +//supported - pointer to the FeaturesSupported structure filled by the SDK +//returns - IMR_RES_OK on success, error otherwise. +//Use this function to query the Client about the special features it supports. +//Currently the only special feature defined is an ability to disable/enable host IDE devices. +EXPORTED_FUNC IMRResult IMR_IDERClientFeatureSupported(ClientID client_id, FeaturesSupported *supported); +// +//client_id - unique client ID, as returned by the IMR_AddClient +//state - pointer to the IDERDeviceState structure filled by the SDK +//returns - IMR_RES_OK on success, error otherwise. +//Use this function to query host IDE device(s) state. +EXPORTED_FUNC IMRResult IMR_IDERGetDeviceState(ClientID client_id, IDERDeviceState *state); +// +//client_id - unique client ID, as returned by the IMR_AddClient +//cmd - pointer to the IDERDeviceCmd structure that shoudl contain disable/enable command and options +//result - pointer to the IDERDeviceResult structure filled by the SDK +//returns - IMR_RES_OK on success, error otherwise. +//Use this function to control host IDE device(s) state. Devices can be disabled/enabled through +//this API. +EXPORTED_FUNC IMRResult IMR_IDERSetDeviceState(ClientID client_id, IDERDeviceCmd *cmd, IDERDeviceResult *result); +// +//client_id - unique client ID, as returned by the IMR_AddClient +//stat - pointer to the IDERStatistics filled by the SDK +//returns - IMR_RES_OK on success, error otherwise. +// +//Use this functon in order to poll active IDER session. +//If the IDER session for the corresponding client was closed due to timeout/protocol error +//function will fill the stat structure with the latest data, but will return IMR_RES_SESSION_CLOSED. +EXPORTED_FUNC IMRResult IMR_IDERGetSessionStatistics(ClientID client_id, IDERStatistics * stat ); + + + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif //_IMR_SDK_H_ + diff --git a/pcucontrol/models/intelamt/Include/StatusCodeDefinitions.h b/pcucontrol/models/intelamt/Include/StatusCodeDefinitions.h new file mode 100644 index 0000000..7901613 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/StatusCodeDefinitions.h @@ -0,0 +1,386 @@ +//---------------------------------------------------------------------------- +// +// Copyright (C) Intel Corporation, 2004 - 2007 +// +// File: StatusCodeDefinitions.h +// +// Notes: This file contains the definitions of the status codes +// as defined in the Intel® AMT Network Design Guide. +// +//---------------------------------------------------------------------------- + +#ifndef STATUS_CODE_DEFINITIONS_H +#define STATUS_CODE_DEFINITIONS_H + +typedef unsigned int PT_STATUS; +typedef unsigned int AMT_STATUS; + +//Request succeeded +#define PT_STATUS_SUCCESS 0x0 +#define AMT_STATUS_SUCCESS 0x0 + +//An internal error in the Intel® AMT device has occurred +#define PT_STATUS_INTERNAL_ERROR 0x1 +#define AMT_STATUS_INTERNAL_ERROR 0x1 + +//Intel® AMT device has not progressed far enough in its +//initialization to process the command. +#define PT_STATUS_NOT_READY 0x2 +#define AMT_STATUS_NOT_READY 0x2 + +//Command is not permitted in current operating mode. +#define PT_STATUS_INVALID_PT_MODE 0x3 +#define AMT_STATUS_INVALID_PT_MODE 0x3 + +//Length field of header is invalid. +#define PT_STATUS_INVALID_MESSAGE_LENGTH 0x4 +#define AMT_STATUS_INVALID_MESSAGE_LENGTH 0x4 + +//The requested hardware asset inventory table +//checksum is not available. +#define PT_STATUS_TABLE_FINGERPRINT_NOT_AVAILABLE 0x5 +#define AMT_STATUS_TABLE_FINGERPRINT_NOT_AVAILABLE 0x5 + +//The Integrity Check Value field of the request +//message sent by Intel® AMT enabled device is invalid. +#define PT_STATUS_INTEGRITY_CHECK_FAILED 0x6 +#define AMT_STATUS_INTEGRITY_CHECK_FAILED 0x6 + +//The specified ISV version is not supported +#define PT_STATUS_UNSUPPORTED_ISVS_VERSION 0x7 +#define AMT_STATUS_UNSUPPORTED_ISVS_VERSION 0x7 + +//The specified queried application is not registered. +#define PT_STATUS_APPLICATION_NOT_REGISTERED 0x8 +#define AMT_STATUS_APPLICATION_NOT_REGISTERED 0x8 + +//Either an invalid name or a not previously registered +//“Enterprise” name was specified +#define PT_STATUS_INVALID_REGISTRATION_DATA 0x9 +#define AMT_STATUS_INVALID_REGISTRATION_DATA 0x9 + +//The application handle provided in the request +//message has never been allocated. +#define PT_STATUS_APPLICATION_DOES_NOT_EXIST 0xA +#define AMT_STATUS_APPLICATION_DOES_NOT_EXIST 0xA + +//The requested number of bytes cannot be allocated in ISV storage. +#define PT_STATUS_NOT_ENOUGH_STORAGE 0xB +#define AMT_STATUS_NOT_ENOUGH_STORAGE 0xB + +//The specified name is invalid. +#define PT_STATUS_INVALID_NAME 0xC +#define AMT_STATUS_INVALID_NAME 0xC + +//The specified block does not exist. +#define PT_STATUS_BLOCK_DOES_NOT_EXIST 0xD +#define AMT_STATUS_BLOCK_DOES_NOT_EXIST 0xD + +//The specified byte offset is invalid. +#define PT_STATUS_INVALID_BYTE_OFFSET 0xE +#define AMT_STATUS_INVALID_BYTE_OFFSET 0xE + +//The specified byte count is invalid. +#define PT_STATUS_INVALID_BYTE_COUNT 0xF +#define AMT_STATUS_INVALID_BYTE_COUNT 0xF + +//The requesting application is not +//permitted to request execution of the specified operation. +#define PT_STATUS_NOT_PERMITTED 0x10 +#define AMT_STATUS_NOT_PERMITTED 0x10 + +//The requesting application is not the owner of the block +//as required for the requested operation. +#define PT_STATUS_NOT_OWNER 0x11 +#define AMT_STATUS_NOT_OWNER 0x11 + +//The specified block is locked by another application. +#define PT_STATUS_BLOCK_LOCKED_BY_OTHER 0x12 +#define AMT_STATUS_BLOCK_LOCKED_BY_OTHER 0x12 + +//The specified block is not locked. +#define PT_STATUS_BLOCK_NOT_LOCKED 0x13 +#define AMT_STATUS_BLOCK_NOT_LOCKED 0x13 + +//The specified group permission bits are invalid. +#define PT_STATUS_INVALID_GROUP_PERMISSIONS 0x14 +#define AMT_STATUS_INVALID_GROUP_PERMISSIONS 0x14 + +//The specified group does not exist. +#define PT_STATUS_GROUP_DOES_NOT_EXIST 0x15 +#define AMT_STATUS_GROUP_DOES_NOT_EXIST 0x15 + +//The specified member count is invalid. +#define PT_STATUS_INVALID_MEMBER_COUNT 0x16 +#define AMT_STATUS_INVALID_MEMBER_COUNT 0x16 + +//The request cannot be satisfied because a maximum +//limit associated with the request has been reached. +#define PT_STATUS_MAX_LIMIT_REACHED 0x17 +#define AMT_STATUS_MAX_LIMIT_REACHED 0x17 + +//specified key algorithm is invalid. +#define PT_STATUS_INVALID_AUTH_TYPE 0x18 +#define AMT_STATUS_INVALID_AUTH_TYPE 0x18 + +//Not Used +#define PT_STATUS_AUTHENTICATION_FAILED 0x19 +#define AMT_STATUS_AUTHENTICATION_FAILED 0x19 + +//The specified DHCP mode is invalid. +#define PT_STATUS_INVALID_DHCP_MODE 0x1A +#define AMT_STATUS_INVALID_DHCP_MODE 0x1A + +//The specified IP address is not a valid IP unicast address. +#define PT_STATUS_INVALID_IP_ADDRESS 0x1B +#define AMT_STATUS_INVALID_IP_ADDRESS 0x1B + +//The specified domain name is not a valid domain name. +#define PT_STATUS_INVALID_DOMAIN_NAME 0x1C +#define AMT_STATUS_INVALID_DOMAIN_NAME 0x1C + +//Not Used +#define PT_STATUS_UNSUPPORTED_VERSION 0x1D +#define AMT_STATUS_UNSUPPORTED_VERSION 0x1D + +//The requested operation cannot be performed because a +//prerequisite request message has not been received. +#define PT_STATUS_REQUEST_UNEXPECTED 0x1E +#define AMT_STATUS_REQUEST_UNEXPECTED 0x1E + +//Not Used +#define PT_STATUS_INVALID_TABLE_TYPE 0x1F +#define AMT_STATUS_INVALID_TABLE_TYPE 0x1F + +//The specified provisioning mode code is undefined. +#define PT_STATUS_INVALID_PROVISIONING_STATE 0x20 +#define AMT_STATUS_INVALID_PROVISIONING_STATE 0x20 + +//Not Used +#define PT_STATUS_UNSUPPORTED_OBJECT 0x21 +#define AMT_STATUS_UNSUPPORTED_OBJECT 0x21 + +//The specified time was not accepted by the Intel® AMT device +//since it is earlier than the baseline time set for the device. +#define PT_STATUS_INVALID_TIME 0x22 +#define AMT_STATUS_INVALID_TIME 0x22 + +//StartingIndex is invalid. +#define PT_STATUS_INVALID_INDEX 0x23 +#define AMT_STATUS_INVALID_INDEX 0x23 + +//A parameter is invalid. +#define PT_STATUS_INVALID_PARAMETER 0x24 +#define AMT_STATUS_INVALID_PARAMETER 0x24 + +//An invalid netmask was supplied +//(a valid netmask is an IP address in which all ‘1Â’s are before +//the ‘0Â’ – e.g. FFFC0000h is valid, FF0C0000h is invalid). +#define PT_STATUS_INVALID_NETMASK 0x25 +#define AMT_STATUS_INVALID_NETMASK 0x25 + +//The operation failed because the Flash wear-out +//protection mechanism prevented a write to an NVRAM sector. +#define PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED 0x26 +#define AMT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED 0x26 + +//ME FW did not receive the entire image file. +#define PT_STATUS_INVALID_IMAGE_LENGTH 0x27 +#define AMT_STATUS_INVALID_IMAGE_LENGTH 0x27 + +//ME FW received an image file with an invalid signature. +#define PT_STATUS_INVALID_IMAGE_SIGNATURE 0x28 +#define AMT_STATUS_INVALID_IMAGE_SIGNATURE 0x28 + +//LME can not support the requested version. +#define PT_STATUS_PROPOSE_ANOTHER_VERSION 0x29 +#define AMT_STATUS_PROPOSE_ANOTHER_VERSION 0x29 + +//The PID must be a 64 bit quantity made up of ASCII codes +//of some combination of 8 characters – +//capital alphabets (A–Z), and numbers (0–9). +#define PT_STATUS_INVALID_PID_FORMAT 0x2A +#define AMT_STATUS_INVALID_PID_FORMAT 0x2A + +//The PPS must be a 256 bit quantity made up of ASCII codes +//of some combination of 32 characters – +//capital alphabets (A–Z), and numbers (0–9). +#define PT_STATUS_INVALID_PPS_FORMAT 0x2B +#define AMT_STATUS_INVALID_PPS_FORMAT 0x2B + +//Full BIST test has been blocked +#define PT_STATUS_BIST_COMMAND_BLOCKED 0x2C +#define AMT_STATUS_BIST_COMMAND_BLOCKED 0x2C + +//A TCP/IP connection could not be opened on with the selected port. +#define PT_STATUS_CONNECTION_FAILED 0x2D +#define AMT_STATUS_CONNECTION_FAILED 0x2D + +//Max number of connection reached. +//LME can not open the requested connection. +#define PT_STATUS_CONNECTION_TOO_MANY 0x2E +#define AMT_STATUS_CONNECTION_TOO_MANY 0x2E + +//Random key generation is in progress. +#define PT_STATUS_RNG_GENERATION_IN_PROGRESS 0x2F +#define AMT_STATUS_RNG_GENERATION_IN_PROGRESS 0x2F + +//A randomly generated key does not exist. +#define PT_STATUS_RNG_NOT_READY 0x30 +#define AMT_STATUS_RNG_NOT_READY 0x30 + +//Self-generated AMT certificate does not exist. +#define PT_STATUS_CERTIFICATE_NOT_READY 0x31 +#define AMT_STATUS_CERTIFICATE_NOT_READY 0x31 + +//This code establishes a dividing line between +//status codes which are common to host interface and +//network interface and status codes which are used by +//network interface only. +#define PT_STATUS_NETWORK_IF_ERROR_BASE 0x800 +#define AMT_STATUS_NETWORK_IF_ERROR_BASE 0x800 + +//The OEM number specified in the remote control +//command is not supported by the Intel® AMT device +#define PT_STATUS_UNSUPPORTED_OEM_NUMBER 0x801 +#define AMT_STATUS_UNSUPPORTED_OEM_NUMBER 0x801 + +//The boot option specified in the remote control command +//is not supported by the Intel® AMT device +#define PT_STATUS_UNSUPPORTED_BOOT_OPTION 0x802 +#define AMT_STATUS_UNSUPPORTED_BOOT_OPTION 0x802 + +//The command specified in the remote control command +//is not supported by the Intel® AMT device +#define PT_STATUS_INVALID_COMMAND 0x803 +#define AMT_STATUS_INVALID_COMMAND 0x803 + +//The special command specified in the remote control command +//is not supported by the Intel® AMT device +#define PT_STATUS_INVALID_SPECIAL_COMMAND 0x804 +#define AMT_STATUS_INVALID_SPECIAL_COMMAND 0x804 + +//The handle specified in the command is invalid +#define PT_STATUS_INVALID_HANDLE 0x805 +#define AMT_STATUS_INVALID_HANDLE 0x805 + +//The password specified in the User ACL is invalid +#define PT_STATUS_INVALID_PASSWORD 0x806 +#define AMT_STATUS_INVALID_PASSWORD 0x806 + +//The realm specified in the User ACL is invalid +#define PT_STATUS_INVALID_REALM 0x807 +#define AMT_STATUS_INVALID_REALM 0x807 + +//The FPACL or EACL entry is used by an active +//registration and cannot be removed or modified. +#define PT_STATUS_STORAGE_ACL_ENTRY_IN_USE 0x808 +#define AMT_STATUS_STORAGE_ACL_ENTRY_IN_USE 0x808 + +//Essential data is missing on CommitChanges command. +#define PT_STATUS_DATA_MISSING 0x809 +#define AMT_STATUS_DATA_MISSING 0x809 + +//The parameter specified is a duplicate of an existing value. +//Returned for a case where duplicate entries are added to FPACL +//(Factory Partner Allocation Control List) or EACL +//(Enterprise Access Control List) lists. +#define PT_STATUS_DUPLICATE 0x80A +#define AMT_STATUS_DUPLICATE 0x80A + +//Event Log operation failed due to the current freeze status of the log. +#define PT_STATUS_EVENTLOG_FROZEN 0x80B +#define AMT_STATUS_EVENTLOG_FROZEN 0x80B + +//The device is missing private key material. +#define PT_STATUS_PKI_MISSING_KEYS 0x80C +#define AMT_STATUS_PKI_MISSING_KEYS 0x80C + +//The device is currently generating a keypair. +//Caller may try repeating this operation at a later time. +#define PT_STATUS_PKI_GENERATING_KEYS 0x80D +#define AMT_STATUS_PKI_GENERATING_KEYS 0x80D + +//An invalid Key was entered. +#define PT_STATUS_INVALID_KEY 0x80E +#define AMT_STATUS_INVALID_KEY 0x80E + +//An invalid X.509 certificate was entered. +#define PT_STATUS_INVALID_CERT 0x80F +#define AMT_STATUS_INVALID_CERT 0x80F + +//Certificate Chain and Private Key do not match. +#define PT_STATUS_CERT_KEY_NOT_MATCH 0x810 +#define AMT_STATUS_CERT_KEY_NOT_MATCH 0x810 + +//The request cannot be satisfied because the maximum +//number of allowed Kerberos domains has been reached. +//(The domain is determined by the first 24 Bytes of the SID.) +#define PT_STATUS_MAX_KERB_DOMAIN_REACHED 0x811 +#define AMT_STATUS_MAX_KERB_DOMAIN_REACHED 0x811 + +// The requested configuration is unsupported +#define PT_STATUS_UNSUPPORTED 0x812 +#define AMT_STATUS_UNSUPPORTED 0x812 + +// A profile with the requested priority already exists +#define PT_STATUS_INVALID_PRIORITY 0x813 +#define AMT_STATUS_INVALID_PRIORITY 0x813 + +// Unable to find specified element +#define PT_STATUS_NOT_FOUND 0x814 +#define AMT_STATUS_NOT_FOUND 0x814 + +// Invalid User credentials +#define PT_STATUS_INVALID_CREDENTIALS 0x815 +#define AMT_STATUS_INVALID_CREDENTIALS 0x815 + +// Passphrase is invalid +#define PT_STATUS_INVALID_PASSPHRASE 0x816 +#define AMT_STATUS_INVALID_PASSPHRASE 0x816 + +// A certificate handle must be chosen before the +// operation can be completed. +#define PT_STATUS_NO_ASSOCIATION 0x818 +#define AMT_STATUS_NO_ASSOCIATION 0x818 + +//The application has identified an internal error +#define PTSDK_STATUS_INTERNAL_ERROR 0x1000 + +//An ISV operation was called while the library is not +//initialized +#define PTSDK_STATUS_NOT_INITIALIZED 0x1001 + +//The requested library I/F is not supported by the current library +//implementation. +#define PTSDK_STATUS_LIB_VERSION_UNSUPPORTED 0x1002 + +//One of the parameters is invalid (usually indicates a +//NULL pointer or an invalid session handle is specified) +#define PTSDK_STATUS_INVALID_PARAM 0x1003 + +//The SDK could not allocate sufficient resources to complete the operation. +#define PTSDK_STATUS_RESOURCES 0x1004 + +//The Library has identified a HW Internal error. +#define PTSDK_STATUS_HARDWARE_ACCESS_ERROR 0x1005 + +//The application that sent the request message is not registered. +//Usually indicates the registration timeout has elapsed. +//The caller should reregister with the Intel AMT enabled device. +#define PTSDK_STATUS_REQUESTOR_NOT_REGISTERED 0x1006 + +//A network error has occurred while processing the call. +#define PTSDK_STATUS_NETWORK_ERROR 0x1007 + +//Specified container can not hold the requested string +#define PTSDK_STATUS_PARAM_BUFFER_TOO_SHORT 0x1008 + +//For Windows only. +//ISVS_InitializeCOMinThread was not called by the current thread. +#define PTSDK_STATUS_COM_NOT_INITIALIZED_IN_THREAD 0x1009 + +//The URL parameter was not optional in current configuration. +#define PTSDK_STATUS_URL_REQUIRED 0x100A + +#endif diff --git a/pcucontrol/models/intelamt/Include/WSDL/AgentWatchdogLocalInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/AgentWatchdogLocalInterface.wsdl new file mode 100644 index 0000000..b87a1a8 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/AgentWatchdogLocalInterface.wsdl @@ -0,0 +1,146 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/AgentWatchdogRemoteInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/AgentWatchdogRemoteInterface.wsdl new file mode 100644 index 0000000..10e673b --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/AgentWatchdogRemoteInterface.wsdl @@ -0,0 +1,373 @@ + + + + + + + + + + + + + + + + + + + + Null terminated string of maximum of 16 characters + + + + + + + + + + + + Bit Field: + Bit 0 set = NOT_STARTED + Bit 1 set = STOPPED + Bit 2 set = RUNNING + Bit 3 set = EXPIRED + Bit 4 set = SUSPEND + All bits(0-7) set = ANY + Valid values: 1..31, 255 + + + + + + + + + + + + + + + + + + + "0 = Activate CB Policy" + + + + + "1 = Deactivate CB Policy" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/CertStore.xsd b/pcucontrol/models/intelamt/Include/WSDL/CertStore.xsd new file mode 100644 index 0000000..5fc0fe7 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/CertStore.xsd @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/CircuitBreakerInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/CircuitBreakerInterface.wsdl new file mode 100644 index 0000000..d65414a --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/CircuitBreakerInterface.wsdl @@ -0,0 +1,1029 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Null terminated string of maximum of 16 characters + + + + + + + + + + + + + Null terminated string of maximum of 16 characters + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "0 = Transmit" + + + + + "1 = Receive" + + + + + + + + + "0 = Source" + + + + + "1 = Destination" + + + + + + + + + "0 = Pass With Statistics" + + + + + "1 = Drop With Statistics" + + + + + "2 = Rate Limit" + + + + + "3 = Pass" + + + + + "4 = Drop" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "0 = Circuit Breaker API" + + + + + "1 = Agent Presence" + + + + + "3 = Environment Detection" + + + + + "4 = Heuristic Circuit Breaker" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "0 = Running" + + + + + "1 = Timed Encounter" + + + + + "2 = Permanent Encounter" + + + + + "3 = Disabled" + + + + + + + + + "0 = Slow Worm Detection " + + + + + "1 = Fast Worm Detection " + + + + + "2 = DoS Detection " + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/Common.xsd b/pcucontrol/models/intelamt/Include/WSDL/Common.xsd new file mode 100644 index 0000000..1a1c5be --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/Common.xsd @@ -0,0 +1,59 @@ + + + + + + + + + + String of maximum of 32 characters (not including null) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/EITInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/EITInterface.wsdl new file mode 100644 index 0000000..6f46b84 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/EITInterface.wsdl @@ -0,0 +1,136 @@ + + + + + + + + + + + + + + + + + + + + + + + + "0 = Region A" + + + + + "1 = Region B" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlAdminInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlAdminInterface.wsdl new file mode 100644 index 0000000..8496cc1 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlAdminInterface.wsdl @@ -0,0 +1,137 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlInterface.wsdl new file mode 100644 index 0000000..1252925 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlInterface.wsdl @@ -0,0 +1,103 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlInterface.xsd b/pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlInterface.xsd new file mode 100644 index 0000000..f6ba2e3 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/EndpointAccessControlInterface.xsd @@ -0,0 +1,135 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/EventManagerClientInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/EventManagerClientInterface.wsdl new file mode 100644 index 0000000..d02f616 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/EventManagerClientInterface.wsdl @@ -0,0 +1,87 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/EventManagerInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/EventManagerInterface.wsdl new file mode 100644 index 0000000..820b4cf --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/EventManagerInterface.wsdl @@ -0,0 +1,780 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/EventManagerInterface.xsd b/pcucontrol/models/intelamt/Include/WSDL/EventManagerInterface.xsd new file mode 100644 index 0000000..9a8e62d --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/EventManagerInterface.xsd @@ -0,0 +1,271 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "0 = Unspecified" + + + + + "1 = Monitor" + + + + + "2 = Information" + + + + + "4 = OK (return to OK condition)" + + + + + "8 = Non-critical condition" + + + + + "16 = Critical condition" + + + + + "32 = Non-recoverable condition" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/FirmwareUpdateInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/FirmwareUpdateInterface.wsdl new file mode 100644 index 0000000..9783e9b --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/FirmwareUpdateInterface.wsdl @@ -0,0 +1,149 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/GeneralInfoInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/GeneralInfoInterface.wsdl new file mode 100644 index 0000000..25a25c3 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/GeneralInfoInterface.wsdl @@ -0,0 +1,582 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "0 = ProvisioningModeCurrent" + + + + + "1 = ProvisioningModeEnterprise" + + + + + "2 = ProvisioningModeSmallBusiness" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/HardwareAssetInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/HardwareAssetInterface.wsdl new file mode 100644 index 0000000..4f620fa --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/HardwareAssetInterface.wsdl @@ -0,0 +1,271 @@ + + + + + + + + + + + + + AssetTypeBIOS = 2 + + + + + AssetTypeComputerSystem = 3 + + + + + AssetTypeBaseboard = 4 + + + + + AssetTypeProcessor = 5 + + + + + AssetTypeMemoryModule = 6 + + + + + AssetTypeFRU = 7 + + + + + AssetTypeMediaDevice = 8 + + + + + AssetTypePortableBattery = 9 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/NetworkAdministrationInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/NetworkAdministrationInterface.wsdl new file mode 100644 index 0000000..6625f05 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/NetworkAdministrationInterface.wsdl @@ -0,0 +1,784 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + DhcpModeInvalid = 0 + + + + + DhcpModeDisabled = 1 + + + + + DhcpModeEnabled = 2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/NetworkTimeInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/NetworkTimeInterface.wsdl new file mode 100644 index 0000000..01684dc --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/NetworkTimeInterface.wsdl @@ -0,0 +1,111 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/RedirectionInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/RedirectionInterface.wsdl new file mode 100644 index 0000000..a33b20c --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/RedirectionInterface.wsdl @@ -0,0 +1,171 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/RemoteControlInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/RemoteControlInterface.wsdl new file mode 100644 index 0000000..ce4b937 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/RemoteControlInterface.wsdl @@ -0,0 +1,231 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "0x10 = Reset" + + + + + "0x11 = PowerUp" + + + + + "0x12 = PowerDown" + + + + + "0x13 = PowerCycleReset" + + + + + "0x21 = SetBootOptions" + + + + + + + + + "0x00 = NOP" + + + + + "0x01 = ForcePxeBoot" + + + + + "0x02 = ForceHardDriveBoot" + + + + + "0x03 = ForceHardDriveSafeBootMode" + + + + + "0x04 = ForceDiagnosticsBoot" + + + + + "0x05 = ForceCdOrDvdBoot" + + + + + "0xC1 = IntelOemCommand" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/SecurityAdministrationInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/SecurityAdministrationInterface.wsdl new file mode 100644 index 0000000..25d7401 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/SecurityAdministrationInterface.wsdl @@ -0,0 +1,2905 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/SecurityAdministrationInterface.xsd b/pcucontrol/models/intelamt/Include/WSDL/SecurityAdministrationInterface.xsd new file mode 100644 index 0000000..c9f0358 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/SecurityAdministrationInterface.xsd @@ -0,0 +1,550 @@ + + + + + + + + + + + + InvalidRealm = 0 + + + + + Reserved = 1 + + + + + RedirectionRealm = 2 + + + + + PTAdministrationRealm = 3 + + + + + HardwareAssetRealm = 4 + + + + + RemoteControlRealm = 5 + + + + + StorageRealm = 6 + + + + + EventManagerRealm = 7 + + + + + StorageAdminRealm = 8 + + + + + AgentPresenceLocalRealm = 9 + + + + + AgentPresenceRemoteRealm = 10 + + + + + CircuitBreakerRealm = 11 + + + + + NetworkTimeRealm = 12 + + + + + GeneralInfoRealm = 13 + + + + + FirmwareUpdateRealm = 14 + + + + + EITRealm = 15 + + + + + LocalUNRealm = 16 + + + + + EndpointAccessControlRealm = 17 + + + + + EndpointAccessControlAdminRealm = 18 + + + + + EventLogReaderRealm = 19 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + RsaKeyEncodingTypeInvalid = 30 + + + + + RsaKeyEncodingTypeSshv2Mpint = 31 + + + + + + + + + + RsaCertificateEncodingTypeInvalid = 10 + + + + + RsaCertificateEncodingTypeX509 = 11 + + + + + + + + + + RngKeyEncodingTypeInvalid = 20 + + + + + RngKeyEncodingTypeBare = 21 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "0 = ProvisioningModeCurrent" + + + + + "1 = ProvisioningModeEnterprise" + + + + + "2 = ProvisioningModeSmallBusiness" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "0 = Not Ready" + + + + + "1 = PSK" + + + + + "2 = PKI" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + "1 = SHA-1-160" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/StorageAdministrationInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/StorageAdministrationInterface.wsdl new file mode 100644 index 0000000..81373e9 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/StorageAdministrationInterface.wsdl @@ -0,0 +1,591 @@ + + + + + + + + + + + + + + + + ISVS_APP_ATTR_TYPE_NONE = 0 + + + + + ISVS_APP_ATTR_TYPE_SNRP = 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/StorageInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/StorageInterface.wsdl new file mode 100644 index 0000000..13efec6 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/StorageInterface.wsdl @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/UserNotificationInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/UserNotificationInterface.wsdl new file mode 100644 index 0000000..8aa3906 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/UserNotificationInterface.wsdl @@ -0,0 +1,122 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/WirelessConfigurationInterface.wsdl b/pcucontrol/models/intelamt/Include/WSDL/WirelessConfigurationInterface.wsdl new file mode 100644 index 0000000..b952cc9 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/WirelessConfigurationInterface.wsdl @@ -0,0 +1,291 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/WirelessConfigurationInterface.xsd b/pcucontrol/models/intelamt/Include/WSDL/WirelessConfigurationInterface.xsd new file mode 100644 index 0000000..90bf9c5 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/WirelessConfigurationInterface.xsd @@ -0,0 +1,224 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 64 bit Key + + + + + + + + 128 bit Key + + + + + + + + 256 bit Key + + + + + + + + + 5 chars Passphrase + + + + + + + + 13 chars Passphrase + + + + + + + + 8-63 chars Passphrase + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/XProfile.xsd b/pcucontrol/models/intelamt/Include/WSDL/XProfile.xsd new file mode 100644 index 0000000..d961255 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/XProfile.xsd @@ -0,0 +1,118 @@ + + + + + + + + + + + + + + + + + + + NameMatch = Certificate name must match exactly, DomainSuffix = Domain name must end in specified name + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/gNameSpaces.dat b/pcucontrol/models/intelamt/Include/WSDL/gNameSpaces.dat new file mode 100644 index 0000000..08b4def --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/gNameSpaces.dat @@ -0,0 +1,27 @@ +wsdl="http://schemas.xmlsoap.org/wsdl/" +xs="http://www.w3.org/2001/XMLSchema" +soap="http://schemas.xmlsoap.org/wsdl/soap/" + +apr="http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote" +apl="http://schemas.intel.com/2004/12/management/PC/AgentWatchdogLocal" +cmn="http://schemas.intel.com/platform/client/Common/2006/01" +cstr="http://schemas.intel.com/platform/client/CertStore/2006/01" +cb="http://schemas.intel.com/2004/12/management/PC/CircuitBreaker" +fwu="http://schemas.intel.com/platform/client/FirmwareUpdate/2004/01" +wcxs="http://schemas.intel.com/platform/client/WirelessConfiguration/2006/01" +sai="http://schemas.intel.com/platform/client/SecurityAdministration/2004/01" +rci="http://schemas.intel.com/platform/client/RemoteControl/2004/01" +hwa="http://schemas.intel.com/platform/client/HardwareAsset/2004/01" +idr="http://schemas.intel.com/platform/client/Redirection/2004/01" +inf="http://schemas.intel.com/platform/client/GeneralInfo/2004/01" +tim="http://schemas.intel.com/platform/client/NetworkTime/2004/01" +net="http://schemas.intel.com/platform/client/NetworkAdministration/2004/01" +xcfg="http://schemas.intel.com/platform/client/XProfiles/2006/01" +eit="http://schemas.intel.com/platform/client/EIT/2004/01" +emi="http://schemas.intel.com/platform/client/EventManager/2004/01" +emc="http://schemas.intel.com/platform/client/EventManagerClient/2006/01" +uni="http://schemas.intel.com/platform/client/UserNotification/2006/01" +eac="http://schemas.intel.com/platform/client/EAC/2006/01" +eaca="http://schemas.intel.com/platform/client/EACAdmin/2006/01" +str="http://schemas.intel.com/platform/client/Storage/2004/01" +stra="http://schemas.intel.com/platform/client/StorageAdministration/2004/01" diff --git a/pcucontrol/models/intelamt/Include/WSDL/wsman.wsdl b/pcucontrol/models/intelamt/Include/WSDL/wsman.wsdl new file mode 100644 index 0000000..8432cc1 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/wsman.wsdl @@ -0,0 +1,474 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Simple sample to demonstrate use of SOAP Headers + + + + + http://172.30.173.30/wsman + + wsman:acme.com/2005/06/resource/example + + InstanceXXX + + + + + + + + + http://172.30.173.30/wsman + + wsman:acme.com/2005/06/resource/example + + + + + + + + http://172.30.173.30/wsman + + wsman:acme.com/2005/06/resource/eventlog + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/wsman.xsd b/pcucontrol/models/intelamt/Include/WSDL/wsman.xsd new file mode 100644 index 0000000..d1ce623 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/wsman.xsd @@ -0,0 +1,403 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/WSDL/wsmancat.xsd b/pcucontrol/models/intelamt/Include/WSDL/wsmancat.xsd new file mode 100644 index 0000000..bf40b18 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/WSDL/wsmancat.xsd @@ -0,0 +1,132 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pcucontrol/models/intelamt/Include/digcalc.h b/pcucontrol/models/intelamt/Include/digcalc.h new file mode 100644 index 0000000..18901de --- /dev/null +++ b/pcucontrol/models/intelamt/Include/digcalc.h @@ -0,0 +1,60 @@ +//------------------------------------------------------------------- +// Copyright (C) The Internet Society (1999). All Rights Reserved. +// +// This document and translations of it may be copied and furnished to +// others, and derivative works that comment on or otherwise explain it +// or assist in its implementation may be prepared, copied, published +// and distributed, in whole or in part, without restriction of any +// kind, provided that the above copyright notice and this paragraph are +// included on all such copies and derivative works. However, this +// document itself may not be modified in any way, such as by removing +// the copyright notice or references to the Internet Society or other +// Internet organizations, except as needed for the purpose of +// developing Internet standards in which case the procedures for +// copyrights defined in the Internet Standards process must be +// followed, or as required to translate it into languages other than +// English. +// +// The limited permissions granted above are perpetual and will not be +// revoked by the Internet Society or its successors or assigns. +// +// This document and the information contained herein is provided on an +// "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING +// TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +// BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION +// HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF +// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. +// +// +// Modifiyed by Intel Corporation, 2005 +//------------------------------------------------------------------------- + +#define HASHLEN 16 +typedef unsigned char HASH[HASHLEN]; +#define HASHHEXLEN 32 +typedef char HASHHEX[HASHHEXLEN+1]; + +/* calculate H(A1) as per HTTP Digest spec */ +void DigestCalcHA1( + char * pszAlg, + char * pszUserName, + char * pszRealm, + char * pszPassword, + char * pszNonce, + char * pszCNonce, + HASHHEX SessionKey + ); + +/* calculate request-digest/response-digest as per HTTP Digest spec */ +void DigestCalcResponse( + HASHHEX HA1, /* H(A1) */ + char * pszNonce, /* nonce from server */ + char * pszNonceCount, /* 8 hex digits */ + char * pszCNonce, /* client nonce */ + char * pszQop, /* qop-value: "", "auth", "auth-int" */ + char * pszMethod, /* method from the request */ + char * pszDigestUri, /* requested URL */ + HASHHEX HEntity, /* H(entity body) if qop="auth-int" */ + HASHHEX Response /* request-digest or response-digest */ + ); + diff --git a/pcucontrol/models/intelamt/Include/httpDigest.h b/pcucontrol/models/intelamt/Include/httpDigest.h new file mode 100644 index 0000000..3fe95b3 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/httpDigest.h @@ -0,0 +1,48 @@ +//---------------------------------------------------------------------------- +// +// Copyright (C) Intel Corporation, 2003 - 2005. +// +// File: httpDigest.h +// +// Contents: Sample code for a gSOAP plugin to implement HTTP Digest +// authentication. +// +// Limitations: +// - MIME, DIME and HTTP chunks (SOAP_IO_CHUNK) are not supported. +// - This implementationn will internally buffer the entire outgoing +// message before sending +// - This implementation will fail if challenge isn't received within +// SOAP_BUFLEN bytes read. +// - This implementation will fail if challenge or response are larger +// than the constants we used. +// - This implementation calculates the digest response for each call +// and doesn't save information. +// - This implementation assumes that the algorithm is MD5 and that +// qop="auth". +// +// Usage: Add the httpDigest.h and httpDigest.cpp files to your project +// +// In your source, just after calling soap_init(), register this +// plugin with soap_register_plugin( soap, http_digest ). +// Use soap.userid and soap.passwd for the username and password. +// As in gSOAP, username and password have to be provided for each call. +// +// e.g. +// struct soap soap; +// soap_init( &soap ); +// soap_register_plugin( &soap, http_digest ); +// soap.userid = "admin"; +// soap.passwd = "admin"; +// ... +// soap_done(&soap); +// +//---------------------------------------------------------------------------- + +#ifndef HTTP_DIGEST_H +#define HTTP_DIGEST_H + +#include "stdsoap2.h" + +int http_digest(struct soap *soap, struct soap_plugin *p, void *arg); + +#endif diff --git a/pcucontrol/models/intelamt/Include/iamt_api.h b/pcucontrol/models/intelamt/Include/iamt_api.h new file mode 100644 index 0000000..afd051c --- /dev/null +++ b/pcucontrol/models/intelamt/Include/iamt_api.h @@ -0,0 +1,592 @@ +/********************************************************************** +** ** +** I N T E L P R O P R I E T A R Y ** +** ** +** COPYRIGHT (c) 1993 - 2006 BY INTEL CORPORATION. ALL ** +** RIGHTS RESERVED. NO PART OF THIS PROGRAM OR PUBLICATION MAY ** +** BE REPRODUCED, TRANSMITTED, TRANSCRIBED, STORED IN A ** +** RETRIEVAL SYSTEM, OR TRANSLATED INTO ANY LANGUAGE OR COMPUTER ** +** LANGUAGE IN ANY FORM OR BY ANY MEANS, ELECTRONIC, MECHANICAL, ** +** MAGNETIC, OPTICAL, CHEMICAL, MANUAL, OR OTHERWISE, WITHOUT ** +** THE PRIOR WRITTEN PERMISSION OF : ** +** ** +** INTEL CORPORATION ** +** ** +** 2200 MISSION COLLEGE BOULEVARD ** +** ** +** SANTA CLARA, CALIFORNIA 95052-8119 ** +** ** +**********************************************************************/ + +//+-------------------------------------------------------------------- +// +// +// File: iamt_api.h +// +// Contents: Header file for the Intel® AMT storage library. +// +//--------------------------------------------------------------------- + + +#ifndef _PTHI_API_ +#define _PTHI_API_ + +#include +#ifdef _WIN32 +#include +#include +#include +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + +/* +To enable compile time checking for Intel(r) AMT2 compatible usage use the following definition: +#define ENFORCE_IAMT2_USAGE +*/ + +#define ISVS_VERSION_MAJOR 2 +#define ISVS_VERSION_MINOR 0 + + +#ifndef VOID +typedef void VOID; +#endif +typedef char CHAR; +typedef unsigned char UINT8; +typedef unsigned short UINT16; +typedef unsigned int UINT32; + +#ifndef _WIN32 +typedef char _TCHAR; +#endif + +typedef UINT8 PT_UUID[16]; + +typedef UINT32 ISVS_APPLICATION_HANDLE; + +#define ISVS_APPLICATION_NAME_FILTER 0xFFFFFFF0 +#define ISVS_VENDOR_NAME_FILTER 0xFFFFFFF1 +#define ISVS_INVALID_HANDLE 0xFFFFFFFF + + +typedef UINT32 PT_BOOLEAN; +static const PT_BOOLEAN PTHI_FALSE = 0; +static const PT_BOOLEAN PTHI_TRUE = 1; + + +// ------------------------ +// ISVS_VERSION +// ------------------------ +typedef struct _ISVS_VERSION +{ + UINT8 MajorNumber; + UINT8 MinorNumber; + +} ISVS_VERSION; + + +// ------------------------ +// PTSDK_UNICODE_STRING +// ------------------------ +// UTF16 Unicode String +// Length - The length in bytes of the string stored in Buffer. +// MaximumLength - The maximum length in bytes of Buffer. +// Buffer - Points to a buffer used to contain a string of wide characters. +// +// PTSDK_UNICODE_STRING types may not be null terminated +// +typedef struct _PTSDK_UNICODE_STRING +{ + UINT16 Length; + UINT16 MaximumLength; + UINT16 *Buffer; + +} PTSDK_UNICODE_STRING; + + + + +// ----------------- +// ISVS_GROUP +// ----------------- +typedef UINT32 ISVS_GROUP_HANDLE; + +typedef UINT32 ISVS_GROUP_PERMISSIONS; +static const ISVS_GROUP_PERMISSIONS ISVS_GROUP_PERMISSIONS_READ_ONLY = 1; +static const ISVS_GROUP_PERMISSIONS ISVS_GROUP_PERMISSIONS_READ_WRITE = 2; + +typedef struct _PTSDK_PERMISSIONS_GROUP_ATTRIBUTES +{ + PTSDK_UNICODE_STRING Name; + ISVS_GROUP_PERMISSIONS Permissions; + +} PTSDK_PERMISSIONS_GROUP_ATTRIBUTES; + + +// ----------------- +// ISVS_BLOCK +// ----------------- + +typedef UINT32 ISVS_BLOCK_HANDLE; + +typedef struct _PTSDK_BLOCK_ATTRIBUTES +{ + UINT32 BlockSize; + PT_BOOLEAN BlockHidden; + PTSDK_UNICODE_STRING BlockName; + +} PTSDK_BLOCK_ATTRIBUTES; + + +// ----------------- +// ISVS_APPLICATION +// ----------------- + +typedef struct _PTSDK_APPLICATION_ATTRIBUTES +{ + PTSDK_UNICODE_STRING VendorName; + PTSDK_UNICODE_STRING ApplicationName; + +} PTSDK_APPLICATION_ATTRIBUTES; + + +// ------------ +// PT_STATUS +// ------------ + +typedef UINT32 PT_STATUS; + +static const PT_STATUS PT_STATUS_SUCCESS = 0; +static const PT_STATUS PT_STATUS_INTERNAL_ERROR = 0x0001; +static const PT_STATUS PT_STATUS_NOT_READY = 0x0002; +static const PT_STATUS PT_STATUS_INVALID_PT_MODE = 0x0003; +static const PT_STATUS PT_STATUS_INVALID_MESSAGE_LENGTH = 0x0004; +static const PT_STATUS PT_STATUS_TABLE_FINGERPRINT_NOT_AVAILABLE = 0x0005; +static const PT_STATUS PT_STATUS_INTEGRITY_CHECK_FAILED = 0x0006; +static const PT_STATUS PT_STATUS_UNSUPPORTED_ISVS_VERSION = 0x0007; +static const PT_STATUS PT_STATUS_APPLICATION_NOT_REGISTERED = 0x0008; +static const PT_STATUS PT_STATUS_INVALID_REGISTRATION_DATA = 0x0009; +static const PT_STATUS PT_STATUS_APPLICATION_DOES_NOT_EXIST = 0x000a; +static const PT_STATUS PT_STATUS_NOT_ENOUGH_STORAGE = 0x000b; +static const PT_STATUS PT_STATUS_INVALID_NAME = 0x000c; +static const PT_STATUS PT_STATUS_BLOCK_DOES_NOT_EXIST = 0x000d; +static const PT_STATUS PT_STATUS_INVALID_BYTE_OFFSET = 0x000e; +static const PT_STATUS PT_STATUS_INVALID_BYTE_COUNT = 0x000f; +static const PT_STATUS PT_STATUS_NOT_PERMITTED = 0x0010; +static const PT_STATUS PT_STATUS_NOT_OWNER = 0x0011; +static const PT_STATUS PT_STATUS_BLOCK_LOCKED_BY_OTHER = 0x0012; +static const PT_STATUS PT_STATUS_BLOCK_NOT_LOCKED = 0x0013; +static const PT_STATUS PT_STATUS_INVALID_GROUP_PERMISSIONS = 0x0014; +static const PT_STATUS PT_STATUS_GROUP_DOES_NOT_EXIST = 0x0015; +static const PT_STATUS PT_STATUS_INVALID_MEMBER_COUNT = 0x0016; +static const PT_STATUS PT_STATUS_MAX_LIMIT_REACHED = 0x0017; +static const PT_STATUS PT_STATUS_INVALID_AUTH_TYPE = 0x0018; +static const PT_STATUS PT_STATUS_AUTHENTICATION_FAILED = 0x0019; +static const PT_STATUS PT_STATUS_INVALID_DHCP_MODE = 0x001a; +static const PT_STATUS PT_STATUS_INVALID_IP_ADDRESS = 0x001b; +static const PT_STATUS PT_STATUS_INVALID_DOMAIN_NAME = 0x001c; + +static const PT_STATUS PT_STATUS_REQUEST_UNEXPECTED = 0x001e; +static const PT_STATUS PT_STATUS_INVALID_TABLE_TYPE = 0x001f; +static const PT_STATUS PT_STATUS_INVALID_PROVISIONING_MODE = 0x0020; +static const PT_STATUS PT_STATUS_UNSUPPORTED_OBJECT = 0x0021; +static const PT_STATUS PT_STATUS_INVALID_TIME = 0x0022; +static const PT_STATUS PT_STATUS_INVALID_INDEX = 0x0023; +static const PT_STATUS PT_STATUS_INVALID_PARAMETER = 0x0024; + +static const PT_STATUS PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED = 0x0026; + +static const PT_STATUS PT_STATUS_NETWORK_IF_ERROR_BASE = 0x0800; +static const PT_STATUS PT_STATUS_SDK_DEFINED_ERROR_BASE = 0x1000; + +static const PT_STATUS PTSDK_STATUS_INTERNAL_ERROR = 0x1000; +static const PT_STATUS PTSDK_STATUS_NOT_INITIALIZED = 0x1001; +static const PT_STATUS PTSDK_STATUS_LIB_VERSION_UNSUPPORTED = 0x1002; +static const PT_STATUS PTSDK_STATUS_INVALID_PARAM = 0x1003; +static const PT_STATUS PTSDK_STATUS_RESOURCES = 0x1004; +static const PT_STATUS PTSDK_STATUS_HARDWARE_ACCESS_ERROR = 0x1005; +static const PT_STATUS PTSDK_STATUS_REQUESTOR_NOT_REGISTERED = 0x1006; +static const PT_STATUS PTSDK_STATUS_NETWORK_ERROR = 0x1007; +static const PT_STATUS PTSDK_STATUS_PARAM_BUFFER_TOO_SHORT = 0x1008; +static const PT_STATUS PTSDK_STATUS_COM_NOT_INITIALIZED_IN_THREAD = 0x1009; +static const PT_STATUS PTSDK_STATUS_URL_REQUIRED = 0x100a; + +// ------------------- +// IN/OUT definitions +// ------------------- +#ifdef IN +#undef IN +#endif +#define IN const /* input parameter (const) */ +#define OUT /* output parameter */ +#define INOUT /* input & output parameter */ +#define OPTIONAL /* optional parameter */ + + +#undef FALSE +#undef TRUE +#undef NULL + +#define FALSE 0 +#define TRUE 1 +#define NULL 0 + +typedef int BOOL; +typedef unsigned long ULONG; +typedef char * PCHAR; +typedef unsigned long * PULONG; + +typedef struct _SESSION_HANDLE *SESSION_HANDLE; +typedef struct _SESSION_AUTHENTICATION_INFO SESSION_AUTHENTICATION_INFO; + + +PT_STATUS +ISVS_Initialize ( + INOUT UINT32 *LibMajorVersion, + INOUT UINT32 *LibMinorVersion, + OUT UINT32 *LibBuildNumber + ); + + +PT_STATUS +ISVS_Uninitialize(); +#ifdef _WIN32 + +PT_STATUS +ISVS_InitializeCOMinThread(); + +PT_STATUS +ISVS_UninitializeCOMinThread(); + +#endif + + +#ifndef ENFORCE_IAMT2_USAGE +// ISVS 1.0 support +PT_STATUS +ISVS_RegisterApplication( + OUT SESSION_HANDLE *SessionHandle, + IN wchar_t *Username OPTIONAL, + IN wchar_t *Password OPTIONAL, + IN CHAR *TargetUrl, + IN PT_UUID MachineUUID OPTIONAL, + IN PTSDK_UNICODE_STRING *VendorName, + IN PTSDK_UNICODE_STRING *AppName, + IN PTSDK_UNICODE_STRING *EnterpriseName + ); +#endif + + +PT_STATUS +ISVS_RegisterApplicationEx( + OUT SESSION_HANDLE *SessionHandle, + IN wchar_t *Username OPTIONAL, + IN wchar_t *Password OPTIONAL, + IN CHAR *TargetUrl , + IN PT_UUID MachineUUID OPTIONAL, + IN PTSDK_UNICODE_STRING *VendorName, + IN PTSDK_UNICODE_STRING *AppName, + IN PTSDK_UNICODE_STRING *EnterpriseName, + IN SESSION_AUTHENTICATION_INFO *AuthInfo OPTIONAL + ); + + + +SESSION_AUTHENTICATION_INFO* +ISVS_CreateAuthInfo( + IN _TCHAR *certificateName, +#ifdef _WIN32 + IN PCCERT_CONTEXT certificate, + IN BOOL krb +#else + IN _TCHAR *certificatePass +#endif + ); + +VOID +ISVS_FreeAuthInfo( + IN SESSION_AUTHENTICATION_INFO* authInfo + ); + + +PT_STATUS +ISVS_GetRegisteredApplications( + IN SESSION_HANDLE SessionHandle, + IN UINT32 StartIndex, + OUT UINT32 *TotalRegisteredAppCount, + INOUT UINT32 *AppHandleCount, + OUT ISVS_APPLICATION_HANDLE AppHandles[] // [] + ); + + +PT_STATUS +ISVS_GetCurrentApplicationHandle ( + IN SESSION_HANDLE SessionHandle, + OUT ISVS_APPLICATION_HANDLE *AppHandle + ); + + +PT_STATUS +ISVS_GetApplicationAttributes( + IN SESSION_HANDLE SessionHandle, + IN ISVS_APPLICATION_HANDLE ApplicationBeingRequested, + INOUT PTSDK_APPLICATION_ATTRIBUTES *ApplicationAttributes + ); + + +PT_STATUS +ISVS_UnregisterApplication( + IN SESSION_HANDLE SessionHandle + ); + + +PT_STATUS +ISVS_RemoveApplication( + SESSION_HANDLE SessionHandle + ); + + +PT_STATUS +ISVS_GetBytesAvailable( + IN SESSION_HANDLE SessionHandle, + OUT UINT32 *BytesAvailable + ); + + +PT_STATUS +ISVS_AllocateBlock( + IN SESSION_HANDLE SessionHandle, + IN UINT32 BytesRequested, + IN PT_BOOLEAN BlockHidden, + IN PTSDK_UNICODE_STRING *BlockName, + OUT ISVS_BLOCK_HANDLE *BlockHandle + ); + + +PT_STATUS +ISVS_GetAllocatedBlocks( + IN SESSION_HANDLE SessionHandle, + IN ISVS_APPLICATION_HANDLE BlockOwnerApplication, + IN UINT32 StartIndex, + OUT UINT32 *TotalAllocatedBlockCount, + INOUT UINT32 *BlockHandleCount, + OUT ISVS_BLOCK_HANDLE BlockHandles[] // [] + ); + + +PT_STATUS +ISVS_GetBlockAttributes( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + INOUT PTSDK_BLOCK_ATTRIBUTES *BlockAttributes + ); + + +PT_STATUS +ISVS_DeallocateBlock( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle + ); + + +PT_STATUS +ISVS_WriteBlock( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN UINT32 ByteOffset, + IN UINT32 ByteCount, + OUT UINT32 *BytesWritten, + IN UINT8 Data[] + ); + + +PT_STATUS +ISVS_ReadBlock( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN UINT32 ByteOffset, + IN UINT32 ByteCount, + OUT UINT32 *BytesRead, + OUT UINT8 Data[] + ); + + +PT_STATUS +ISVS_LockBlock( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle + ); + + +PT_STATUS +ISVS_UnlockBlock( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle + ); + + +PT_STATUS +ISVS_SetBlockName( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN PTSDK_UNICODE_STRING *BlockName + ); + + +PT_STATUS +ISVS_SetBlockVisibility( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN PT_BOOLEAN BlockHidden + ); + + +PT_STATUS +ISVS_AddPermissionsGroup( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN ISVS_GROUP_PERMISSIONS GroupPermissions, + IN PTSDK_UNICODE_STRING *GroupName, + OUT ISVS_GROUP_HANDLE *GroupHandle + ); + + +PT_STATUS +ISVS_GetPermissionsGroups( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN UINT32 StartIndex, + OUT UINT32 *TotalGroupCount, + INOUT UINT32 *GroupHandleCount, + OUT ISVS_GROUP_HANDLE GroupHandles[] // [] + ); + + +PT_STATUS +ISVS_GetPermissionsGroupAttributes( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN ISVS_GROUP_HANDLE GroupHandle, + INOUT PTSDK_PERMISSIONS_GROUP_ATTRIBUTES *GroupAttributes + ); + + +PT_STATUS +ISVS_RemovePermissionsGroup( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN ISVS_GROUP_HANDLE GroupHandle + ); + + +PT_STATUS +ISVS_SetPermissionsGroupName( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN ISVS_GROUP_HANDLE GroupHandle, + IN PTSDK_UNICODE_STRING *GroupName + ); + + +PT_STATUS +ISVS_SetPermissionsGroupPermissions( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN ISVS_GROUP_HANDLE GroupHandle, + IN ISVS_GROUP_PERMISSIONS Permissions + ); + + +PT_STATUS +ISVS_AddPermissionsGroupMembers( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN ISVS_GROUP_HANDLE GroupHandle, + IN UINT32 MemberHandleCount, + IN ISVS_APPLICATION_HANDLE MemberHandles[] // [] + ); + + +PT_STATUS +ISVS_GetPermissionsGroupMembers( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN ISVS_GROUP_HANDLE GroupHandle, + IN UINT32 StartIndex, + OUT UINT32 *TotalMemberCount, + INOUT UINT32 *MemberHandleCount, + OUT ISVS_APPLICATION_HANDLE MemberHandles[] // [] + ); + + +PT_STATUS +ISVS_RemovePermissionsGroupMembers( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + IN ISVS_GROUP_HANDLE GroupHandle, + IN UINT32 MemberHandleCount, + IN ISVS_APPLICATION_HANDLE MemberHandles[] // [] + ); + + +PT_STATUS +ISVS_GetTimeoutValues( + IN SESSION_HANDLE SessionHandle, + OUT UINT32 *RegistrationTimeout, + OUT UINT32 *LockTimeout + ); + + +PT_STATUS +ISVS_GetHostUUID( + OUT PT_UUID Uuid + ); + +#ifndef ENFORCE_IAMT2_USAGE +// ISVS 1.0 support +PT_STATUS +ISVS_GetAPIVersion( + IN wchar_t *Username OPTIONAL, + IN wchar_t *Password OPTIONAL, + IN CHAR *TargetUrl, + OUT ISVS_VERSION *Version + ); +#endif + + +PT_STATUS +ISVS_GetAPIVersionEx( + OUT ISVS_VERSION *Version, + IN wchar_t *Username OPTIONAL, + IN wchar_t *Password OPTIONAL, + IN CHAR *TargetUrl , + IN SESSION_AUTHENTICATION_INFO *AuthInfo OPTIONAL + ); + + +PT_STATUS +ISVS_GetBlockWriteEraseLimit( + IN SESSION_HANDLE SessionHandle, + IN ISVS_BLOCK_HANDLE BlockHandle, + OUT UINT32 *WriteEraseLimit + ); + + + +VOID +ISVS_GetLastNetworkError( + IN SESSION_HANDLE SessionHandle OPTIONAL, + OUT VOID *NetworkError + ); + + +#ifdef __cplusplus +} +#endif + +#endif // _PTHI_API_ + diff --git a/pcucontrol/models/intelamt/Include/soapH.h b/pcucontrol/models/intelamt/Include/soapH.h new file mode 100644 index 0000000..a92cab8 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/soapH.h @@ -0,0 +1,16266 @@ +/* soapH.h + Generated by gSOAP 2.7.8c from ../../Samples/gSoapGeneratedCode/AmtWsdlInterface.h + Copyright (C) 2000-2006, Robert van Engelen, Genivia Inc. All Rights Reserved. + This part of the software is released under one of the following licenses: + GPL, the gSOAP public license, or Genivia's license for commercial use. +*/ + +#ifndef soapH_H +#define soapH_H +#include "soapStub.h" +SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap*); +#ifndef WITH_NOIDREF +SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap*); +SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap*); +SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap*, const void*, int); +SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap*, const void*, const char*, int, int); +SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap*, int*); +#endif + +SOAP_FMAC3 void * SOAP_FMAC4 soap_instantiate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_fdelete(struct soap_clist*); +SOAP_FMAC3 void* SOAP_FMAC4 soap_class_id_enter(struct soap*, const char*, void*, int, size_t, const char*, const char*); + +SOAP_FMAC3 void* SOAP_FMAC4 soap_container_id_forward(struct soap*, const char*, void*, size_t, int, int, size_t, unsigned int); + +SOAP_FMAC3 void SOAP_FMAC4 soap_container_insert(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_byte +#define SOAP_TYPE_byte (2) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap*, char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap*, const char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap*, const char*, int, const char *, const char*); +SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap*, char *, const char*, const char*); +SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap*, const char*, char *, const char*); + +#ifndef SOAP_TYPE_short +#define SOAP_TYPE_short (621) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_short(struct soap*, short *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_short(struct soap*, const short *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_short(struct soap*, const char*, int, const short *, const char*); +SOAP_FMAC3 short * SOAP_FMAC4 soap_get_short(struct soap*, short *, const char*, const char*); +SOAP_FMAC3 short * SOAP_FMAC4 soap_in_short(struct soap*, const char*, short *, const char*); + +#ifndef SOAP_TYPE_int +#define SOAP_TYPE_int (1) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap*, int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap*, const int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap*, const char*, int, const int *, const char*); +SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap*, int *, const char*, const char*); +SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap*, const char*, int *, const char*); + +#ifndef SOAP_TYPE_wcxs__ProfilePriorityType +#define SOAP_TYPE_wcxs__ProfilePriorityType (654) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__ProfilePriorityType(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__ProfilePriorityType(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfilePriorityType(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_wcxs__ProfilePriorityType(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_wcxs__ProfilePriorityType(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_rci__SystemCapabilitiesSupportedType +#define SOAP_TYPE_rci__SystemCapabilitiesSupportedType (644) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SystemCapabilitiesSupportedType(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SystemCapabilitiesSupportedType(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SystemCapabilitiesSupportedType(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_rci__SystemCapabilitiesSupportedType(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_rci__SystemCapabilitiesSupportedType(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_apr__WatchdogState +#define SOAP_TYPE_apr__WatchdogState (625) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_apr__WatchdogState(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_apr__WatchdogState(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__WatchdogState(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_apr__WatchdogState(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_apr__WatchdogState(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE +#define SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE (620) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR +#define SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR (619) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE (618) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS (617) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY (616) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE (615) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_emi__AlertSubscriptionPolicyIDType +#define SOAP_TYPE_emi__AlertSubscriptionPolicyIDType (591) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__AlertSubscriptionPolicyIDType(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__AlertSubscriptionPolicyIDType(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionPolicyIDType(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_emi__AlertSubscriptionPolicyIDType(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_emi__AlertSubscriptionPolicyIDType(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_net__LinkPolicyType +#define SOAP_TYPE_net__LinkPolicyType (583) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__LinkPolicyType(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__LinkPolicyType(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__LinkPolicyType(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_net__LinkPolicyType(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_net__LinkPolicyType(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_unsignedByte +#define SOAP_TYPE_unsignedByte (11) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedByte(struct soap*, unsigned char *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedByte(struct soap*, const unsigned char *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedByte(struct soap*, const char*, int, const unsigned char *, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_unsignedByte(struct soap*, unsigned char *, const char*, const char*); +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_unsignedByte(struct soap*, const char*, unsigned char *, const char*); + +#ifndef SOAP_TYPE_rci__OemParametersType +#define SOAP_TYPE_rci__OemParametersType (652) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__OemParametersType(struct soap*, unsigned short *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__OemParametersType(struct soap*, const unsigned short *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__OemParametersType(struct soap*, const char*, int, const unsigned short *, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_rci__OemParametersType(struct soap*, unsigned short *, const char*, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_rci__OemParametersType(struct soap*, const char*, unsigned short *, const char*); + +#ifndef SOAP_TYPE_rci__SpecialCommandParameterType +#define SOAP_TYPE_rci__SpecialCommandParameterType (651) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SpecialCommandParameterType(struct soap*, unsigned short *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SpecialCommandParameterType(struct soap*, const unsigned short *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SpecialCommandParameterType(struct soap*, const char*, int, const unsigned short *, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_rci__SpecialCommandParameterType(struct soap*, unsigned short *, const char*, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_rci__SpecialCommandParameterType(struct soap*, const char*, unsigned short *, const char*); + +#ifndef SOAP_TYPE_rci__BootOptionsType +#define SOAP_TYPE_rci__BootOptionsType (650) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__BootOptionsType(struct soap*, unsigned short *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__BootOptionsType(struct soap*, const unsigned short *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__BootOptionsType(struct soap*, const char*, int, const unsigned short *, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_rci__BootOptionsType(struct soap*, unsigned short *, const char*, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_rci__BootOptionsType(struct soap*, const char*, unsigned short *, const char*); + +#ifndef SOAP_TYPE_rci__SpecialCommandsSupportedType +#define SOAP_TYPE_rci__SpecialCommandsSupportedType (645) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SpecialCommandsSupportedType(struct soap*, unsigned short *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SpecialCommandsSupportedType(struct soap*, const unsigned short *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SpecialCommandsSupportedType(struct soap*, const char*, int, const unsigned short *, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_rci__SpecialCommandsSupportedType(struct soap*, unsigned short *, const char*, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_rci__SpecialCommandsSupportedType(struct soap*, const char*, unsigned short *, const char*); + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL +#define SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL (623) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap*, unsigned short *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap*, const unsigned short *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap*, const char*, int, const unsigned short *, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap*, unsigned short *, const char*, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap*, const char*, unsigned short *, const char*); + +#ifndef SOAP_TYPE_unsignedShort +#define SOAP_TYPE_unsignedShort (622) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedShort(struct soap*, unsigned short *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedShort(struct soap*, const unsigned short *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedShort(struct soap*, const char*, int, const unsigned short *, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_unsignedShort(struct soap*, unsigned short *, const char*, const char*); +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_unsignedShort(struct soap*, const char*, unsigned short *, const char*); + +#ifndef SOAP_TYPE_rci__OemDefinedCapabilitiesType +#define SOAP_TYPE_rci__OemDefinedCapabilitiesType (647) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__OemDefinedCapabilitiesType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__OemDefinedCapabilitiesType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__OemDefinedCapabilitiesType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_rci__OemDefinedCapabilitiesType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_rci__OemDefinedCapabilitiesType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_rci__SystemFirmwareCapabilitiesType +#define SOAP_TYPE_rci__SystemFirmwareCapabilitiesType (646) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SystemFirmwareCapabilitiesType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SystemFirmwareCapabilitiesType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SystemFirmwareCapabilitiesType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_rci__SystemFirmwareCapabilitiesType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_rci__SystemFirmwareCapabilitiesType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_rci__PT_USCORESTATUS +#define SOAP_TYPE_rci__PT_USCORESTATUS (643) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_rci__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_rci__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_rci__SystemPowerStateType +#define SOAP_TYPE_rci__SystemPowerStateType (642) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SystemPowerStateType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SystemPowerStateType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SystemPowerStateType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_rci__SystemPowerStateType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_rci__SystemPowerStateType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_inf__IPv4AddressType +#define SOAP_TYPE_inf__IPv4AddressType (637) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__IPv4AddressType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__IPv4AddressType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__IPv4AddressType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_inf__IPv4AddressType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_inf__IPv4AddressType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_inf__TimeType +#define SOAP_TYPE_inf__TimeType (636) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__TimeType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__TimeType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__TimeType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_inf__TimeType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_inf__TimeType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_inf__PT_USCORESTATUS +#define SOAP_TYPE_inf__PT_USCORESTATUS (635) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_inf__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_inf__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_str__PT_USCORESTATUS +#define SOAP_TYPE_str__PT_USCORESTATUS (634) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_str__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_str__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_str__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_str__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_str__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_tim__TimeType +#define SOAP_TYPE_tim__TimeType (633) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_tim__TimeType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_tim__TimeType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_tim__TimeType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_tim__TimeType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_tim__TimeType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_tim__PT_USCORESTATUS +#define SOAP_TYPE_tim__PT_USCORESTATUS (632) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_tim__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_tim__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_tim__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_tim__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_tim__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_idr__IPv4AddressType +#define SOAP_TYPE_idr__IPv4AddressType (631) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_idr__IPv4AddressType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_idr__IPv4AddressType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__IPv4AddressType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_idr__IPv4AddressType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_idr__IPv4AddressType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_idr__TimeType +#define SOAP_TYPE_idr__TimeType (630) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_idr__TimeType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_idr__TimeType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__TimeType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_idr__TimeType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_idr__TimeType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_idr__PT_USCORESTATUS +#define SOAP_TYPE_idr__PT_USCORESTATUS (629) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_idr__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_idr__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_idr__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_idr__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_apl__PT_USCORESTATUS +#define SOAP_TYPE_apl__PT_USCORESTATUS (628) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_apl__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_apl__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apl__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_apl__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_apl__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_apr__PT_USCORESTATUS +#define SOAP_TYPE_apr__PT_USCORESTATUS (624) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_apr__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_apr__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_apr__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_apr__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS +#define SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS (614) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_hwa__PT_USCORESTATUS +#define SOAP_TYPE_hwa__PT_USCORESTATUS (612) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_hwa__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_hwa__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_cb__TimeType +#define SOAP_TYPE_cb__TimeType (601) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__TimeType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__TimeType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__TimeType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cb__TimeType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cb__TimeType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_cb__PT_USCORESTATUS +#define SOAP_TYPE_cb__PT_USCORESTATUS (600) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cb__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cb__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_emi__SensorHandleType +#define SOAP_TYPE_emi__SensorHandleType (597) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__SensorHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__SensorHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__SensorHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__SensorHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__SensorHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_emi__IPv4AddressType +#define SOAP_TYPE_emi__IPv4AddressType (596) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__IPv4AddressType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__IPv4AddressType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__IPv4AddressType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__IPv4AddressType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__IPv4AddressType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_emi__PT_USCORESTATUS +#define SOAP_TYPE_emi__PT_USCORESTATUS (595) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_emi__EventFilterHandleType +#define SOAP_TYPE_emi__EventFilterHandleType (593) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__EventFilterHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__EventFilterHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventFilterHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__EventFilterHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__EventFilterHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_emi__AlertSubscriptionHandleType +#define SOAP_TYPE_emi__AlertSubscriptionHandleType (592) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__AlertSubscriptionHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__AlertSubscriptionHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__AlertSubscriptionHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__AlertSubscriptionHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_emi__TimeType +#define SOAP_TYPE_emi__TimeType (590) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__TimeType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__TimeType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__TimeType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__TimeType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__TimeType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_stra__StorageAllocEntryHandleType +#define SOAP_TYPE_stra__StorageAllocEntryHandleType (589) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__StorageAllocEntryHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__StorageAllocEntryHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageAllocEntryHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_stra__StorageAllocEntryHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_stra__StorageAllocEntryHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_stra__StorageEaclEntryHandleType +#define SOAP_TYPE_stra__StorageEaclEntryHandleType (588) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__StorageEaclEntryHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__StorageEaclEntryHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageEaclEntryHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_stra__StorageEaclEntryHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_stra__StorageEaclEntryHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_stra__StorageApplicationHandleType +#define SOAP_TYPE_stra__StorageApplicationHandleType (586) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__StorageApplicationHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__StorageApplicationHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageApplicationHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_stra__StorageApplicationHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_stra__StorageApplicationHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_stra__PT_USCORESTATUS +#define SOAP_TYPE_stra__PT_USCORESTATUS (585) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_stra__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_stra__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_net__InterfaceHandleType +#define SOAP_TYPE_net__InterfaceHandleType (584) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__InterfaceHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__InterfaceHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__InterfaceHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_net__InterfaceHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_net__InterfaceHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_net__IPv4AddressType +#define SOAP_TYPE_net__IPv4AddressType (579) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__IPv4AddressType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__IPv4AddressType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__IPv4AddressType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_net__IPv4AddressType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_net__IPv4AddressType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_net__PT_USCORESTATUS +#define SOAP_TYPE_net__PT_USCORESTATUS (578) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_net__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_net__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_sai__CertificateHandleType +#define SOAP_TYPE_sai__CertificateHandleType (568) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__CertificateHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__CertificateHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CertificateHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_sai__CertificateHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_sai__CertificateHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_sai__IPv4AddressType +#define SOAP_TYPE_sai__IPv4AddressType (556) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__IPv4AddressType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__IPv4AddressType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__IPv4AddressType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_sai__IPv4AddressType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_sai__IPv4AddressType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_sai__UserAclEntryHandleType +#define SOAP_TYPE_sai__UserAclEntryHandleType (553) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__UserAclEntryHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__UserAclEntryHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclEntryHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_sai__UserAclEntryHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_sai__UserAclEntryHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_sai__PT_USCORESTATUS +#define SOAP_TYPE_sai__PT_USCORESTATUS (551) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_sai__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_sai__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_cstr__KeyPairHandleType +#define SOAP_TYPE_cstr__KeyPairHandleType (550) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cstr__KeyPairHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cstr__KeyPairHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cstr__KeyPairHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cstr__KeyPairHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cstr__KeyPairHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_cmn__InterfaceHandleType +#define SOAP_TYPE_cmn__InterfaceHandleType (548) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__InterfaceHandleType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__InterfaceHandleType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__InterfaceHandleType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cmn__InterfaceHandleType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cmn__InterfaceHandleType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_cmn__IPv4AddressType +#define SOAP_TYPE_cmn__IPv4AddressType (545) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__IPv4AddressType(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__IPv4AddressType(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__IPv4AddressType(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cmn__IPv4AddressType(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cmn__IPv4AddressType(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_cmn__PT_USCORESTATUS +#define SOAP_TYPE_cmn__PT_USCORESTATUS (543) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__PT_USCORESTATUS(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__PT_USCORESTATUS(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__PT_USCORESTATUS(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cmn__PT_USCORESTATUS(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cmn__PT_USCORESTATUS(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_unsignedInt +#define SOAP_TYPE_unsignedInt (10) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedInt(struct soap*, unsigned int *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedInt(struct soap*, const unsigned int *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedInt(struct soap*, const char*, int, const unsigned int *, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_unsignedInt(struct soap*, unsigned int *, const char*, const char*); +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_unsignedInt(struct soap*, const char*, unsigned int *, const char*); + +#ifndef SOAP_TYPE_bool +#define SOAP_TYPE_bool (679) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_bool(struct soap*, bool *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_bool(struct soap*, const bool *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_bool(struct soap*, const char*, int, const bool *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_bool2s(struct soap*, bool); +SOAP_FMAC3 bool * SOAP_FMAC4 soap_get_bool(struct soap*, bool *, const char*, const char*); +SOAP_FMAC3 bool * SOAP_FMAC4 soap_in_bool(struct soap*, const char*, bool *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2bool(struct soap*, const char*, bool *); + +#ifndef SOAP_TYPE_wcxs__FeatureType +#define SOAP_TYPE_wcxs__FeatureType (662) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__FeatureType(struct soap*, enum wcxs__FeatureType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__FeatureType(struct soap*, const enum wcxs__FeatureType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__FeatureType(struct soap*, const char*, int, const enum wcxs__FeatureType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_wcxs__FeatureType2s(struct soap*, enum wcxs__FeatureType); +SOAP_FMAC3 enum wcxs__FeatureType * SOAP_FMAC4 soap_get_wcxs__FeatureType(struct soap*, enum wcxs__FeatureType *, const char*, const char*); +SOAP_FMAC3 enum wcxs__FeatureType * SOAP_FMAC4 soap_in_wcxs__FeatureType(struct soap*, const char*, enum wcxs__FeatureType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2wcxs__FeatureType(struct soap*, const char*, enum wcxs__FeatureType *); + +#ifndef SOAP_TYPE_wcxs__KeyIndexType +#define SOAP_TYPE_wcxs__KeyIndexType (655) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__KeyIndexType(struct soap*, enum wcxs__KeyIndexType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__KeyIndexType(struct soap*, const enum wcxs__KeyIndexType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__KeyIndexType(struct soap*, const char*, int, const enum wcxs__KeyIndexType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_wcxs__KeyIndexType2s(struct soap*, enum wcxs__KeyIndexType); +SOAP_FMAC3 enum wcxs__KeyIndexType * SOAP_FMAC4 soap_get_wcxs__KeyIndexType(struct soap*, enum wcxs__KeyIndexType *, const char*, const char*); +SOAP_FMAC3 enum wcxs__KeyIndexType * SOAP_FMAC4 soap_in_wcxs__KeyIndexType(struct soap*, const char*, enum wcxs__KeyIndexType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2wcxs__KeyIndexType(struct soap*, const char*, enum wcxs__KeyIndexType *); + +#ifndef SOAP_TYPE_rci__SpecialCommandType +#define SOAP_TYPE_rci__SpecialCommandType (649) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SpecialCommandType(struct soap*, enum rci__SpecialCommandType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SpecialCommandType(struct soap*, const enum rci__SpecialCommandType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SpecialCommandType(struct soap*, const char*, int, const enum rci__SpecialCommandType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_rci__SpecialCommandType2s(struct soap*, enum rci__SpecialCommandType); +SOAP_FMAC3 enum rci__SpecialCommandType * SOAP_FMAC4 soap_get_rci__SpecialCommandType(struct soap*, enum rci__SpecialCommandType *, const char*, const char*); +SOAP_FMAC3 enum rci__SpecialCommandType * SOAP_FMAC4 soap_in_rci__SpecialCommandType(struct soap*, const char*, enum rci__SpecialCommandType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2rci__SpecialCommandType(struct soap*, const char*, enum rci__SpecialCommandType *); + +#ifndef SOAP_TYPE_rci__RemoteControlCommandType +#define SOAP_TYPE_rci__RemoteControlCommandType (648) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__RemoteControlCommandType(struct soap*, enum rci__RemoteControlCommandType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__RemoteControlCommandType(struct soap*, const enum rci__RemoteControlCommandType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__RemoteControlCommandType(struct soap*, const char*, int, const enum rci__RemoteControlCommandType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_rci__RemoteControlCommandType2s(struct soap*, enum rci__RemoteControlCommandType); +SOAP_FMAC3 enum rci__RemoteControlCommandType * SOAP_FMAC4 soap_get_rci__RemoteControlCommandType(struct soap*, enum rci__RemoteControlCommandType *, const char*, const char*); +SOAP_FMAC3 enum rci__RemoteControlCommandType * SOAP_FMAC4 soap_in_rci__RemoteControlCommandType(struct soap*, const char*, enum rci__RemoteControlCommandType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2rci__RemoteControlCommandType(struct soap*, const char*, enum rci__RemoteControlCommandType *); + +#ifndef SOAP_TYPE_inf__EnabledInterfacesType +#define SOAP_TYPE_inf__EnabledInterfacesType (641) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__EnabledInterfacesType(struct soap*, enum inf__EnabledInterfacesType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__EnabledInterfacesType(struct soap*, const enum inf__EnabledInterfacesType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__EnabledInterfacesType(struct soap*, const char*, int, const enum inf__EnabledInterfacesType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_inf__EnabledInterfacesType2s(struct soap*, enum inf__EnabledInterfacesType); +SOAP_FMAC3 enum inf__EnabledInterfacesType * SOAP_FMAC4 soap_get_inf__EnabledInterfacesType(struct soap*, enum inf__EnabledInterfacesType *, const char*, const char*); +SOAP_FMAC3 enum inf__EnabledInterfacesType * SOAP_FMAC4 soap_in_inf__EnabledInterfacesType(struct soap*, const char*, enum inf__EnabledInterfacesType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2inf__EnabledInterfacesType(struct soap*, const char*, enum inf__EnabledInterfacesType *); + +#ifndef SOAP_TYPE_inf__PasswordModelType +#define SOAP_TYPE_inf__PasswordModelType (640) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__PasswordModelType(struct soap*, enum inf__PasswordModelType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__PasswordModelType(struct soap*, const enum inf__PasswordModelType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__PasswordModelType(struct soap*, const char*, int, const enum inf__PasswordModelType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_inf__PasswordModelType2s(struct soap*, enum inf__PasswordModelType); +SOAP_FMAC3 enum inf__PasswordModelType * SOAP_FMAC4 soap_get_inf__PasswordModelType(struct soap*, enum inf__PasswordModelType *, const char*, const char*); +SOAP_FMAC3 enum inf__PasswordModelType * SOAP_FMAC4 soap_in_inf__PasswordModelType(struct soap*, const char*, enum inf__PasswordModelType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2inf__PasswordModelType(struct soap*, const char*, enum inf__PasswordModelType *); + +#ifndef SOAP_TYPE_inf__ProvisioningStateType +#define SOAP_TYPE_inf__ProvisioningStateType (639) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__ProvisioningStateType(struct soap*, enum inf__ProvisioningStateType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__ProvisioningStateType(struct soap*, const enum inf__ProvisioningStateType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__ProvisioningStateType(struct soap*, const char*, int, const enum inf__ProvisioningStateType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_inf__ProvisioningStateType2s(struct soap*, enum inf__ProvisioningStateType); +SOAP_FMAC3 enum inf__ProvisioningStateType * SOAP_FMAC4 soap_get_inf__ProvisioningStateType(struct soap*, enum inf__ProvisioningStateType *, const char*, const char*); +SOAP_FMAC3 enum inf__ProvisioningStateType * SOAP_FMAC4 soap_in_inf__ProvisioningStateType(struct soap*, const char*, enum inf__ProvisioningStateType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2inf__ProvisioningStateType(struct soap*, const char*, enum inf__ProvisioningStateType *); + +#ifndef SOAP_TYPE_inf__ProvisioningModeType +#define SOAP_TYPE_inf__ProvisioningModeType (638) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__ProvisioningModeType(struct soap*, enum inf__ProvisioningModeType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__ProvisioningModeType(struct soap*, const enum inf__ProvisioningModeType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__ProvisioningModeType(struct soap*, const char*, int, const enum inf__ProvisioningModeType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_inf__ProvisioningModeType2s(struct soap*, enum inf__ProvisioningModeType); +SOAP_FMAC3 enum inf__ProvisioningModeType * SOAP_FMAC4 soap_get_inf__ProvisioningModeType(struct soap*, enum inf__ProvisioningModeType *, const char*, const char*); +SOAP_FMAC3 enum inf__ProvisioningModeType * SOAP_FMAC4 soap_in_inf__ProvisioningModeType(struct soap*, const char*, enum inf__ProvisioningModeType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2inf__ProvisioningModeType(struct soap*, const char*, enum inf__ProvisioningModeType *); + +#ifndef SOAP_TYPE_apr__CbActionType +#define SOAP_TYPE_apr__CbActionType (626) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_apr__CbActionType(struct soap*, enum apr__CbActionType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_apr__CbActionType(struct soap*, const enum apr__CbActionType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__CbActionType(struct soap*, const char*, int, const enum apr__CbActionType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_apr__CbActionType2s(struct soap*, enum apr__CbActionType); +SOAP_FMAC3 enum apr__CbActionType * SOAP_FMAC4 soap_get_apr__CbActionType(struct soap*, enum apr__CbActionType *, const char*, const char*); +SOAP_FMAC3 enum apr__CbActionType * SOAP_FMAC4 soap_in_apr__CbActionType(struct soap*, const char*, enum apr__CbActionType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2apr__CbActionType(struct soap*, const char*, enum apr__CbActionType *); + +#ifndef SOAP_TYPE_hwa__AssetTypeType +#define SOAP_TYPE_hwa__AssetTypeType (613) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__AssetTypeType(struct soap*, enum hwa__AssetTypeType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__AssetTypeType(struct soap*, const enum hwa__AssetTypeType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__AssetTypeType(struct soap*, const char*, int, const enum hwa__AssetTypeType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_hwa__AssetTypeType2s(struct soap*, enum hwa__AssetTypeType); +SOAP_FMAC3 enum hwa__AssetTypeType * SOAP_FMAC4 soap_get_hwa__AssetTypeType(struct soap*, enum hwa__AssetTypeType *, const char*, const char*); +SOAP_FMAC3 enum hwa__AssetTypeType * SOAP_FMAC4 soap_in_hwa__AssetTypeType(struct soap*, const char*, enum hwa__AssetTypeType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2hwa__AssetTypeType(struct soap*, const char*, enum hwa__AssetTypeType *); + +#ifndef SOAP_TYPE_cb__HcbTriggerReasonType +#define SOAP_TYPE_cb__HcbTriggerReasonType (609) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__HcbTriggerReasonType(struct soap*, enum cb__HcbTriggerReasonType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__HcbTriggerReasonType(struct soap*, const enum cb__HcbTriggerReasonType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__HcbTriggerReasonType(struct soap*, const char*, int, const enum cb__HcbTriggerReasonType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__HcbTriggerReasonType2s(struct soap*, enum cb__HcbTriggerReasonType); +SOAP_FMAC3 enum cb__HcbTriggerReasonType * SOAP_FMAC4 soap_get_cb__HcbTriggerReasonType(struct soap*, enum cb__HcbTriggerReasonType *, const char*, const char*); +SOAP_FMAC3 enum cb__HcbTriggerReasonType * SOAP_FMAC4 soap_in_cb__HcbTriggerReasonType(struct soap*, const char*, enum cb__HcbTriggerReasonType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__HcbTriggerReasonType(struct soap*, const char*, enum cb__HcbTriggerReasonType *); + +#ifndef SOAP_TYPE_cb__HcbStateType +#define SOAP_TYPE_cb__HcbStateType (608) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__HcbStateType(struct soap*, enum cb__HcbStateType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__HcbStateType(struct soap*, const enum cb__HcbStateType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__HcbStateType(struct soap*, const char*, int, const enum cb__HcbStateType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__HcbStateType2s(struct soap*, enum cb__HcbStateType); +SOAP_FMAC3 enum cb__HcbStateType * SOAP_FMAC4 soap_get_cb__HcbStateType(struct soap*, enum cb__HcbStateType *, const char*, const char*); +SOAP_FMAC3 enum cb__HcbStateType * SOAP_FMAC4 soap_in_cb__HcbStateType(struct soap*, const char*, enum cb__HcbStateType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__HcbStateType(struct soap*, const char*, enum cb__HcbStateType *); + +#ifndef SOAP_TYPE_cb__CircuitBreakerApplicationType +#define SOAP_TYPE_cb__CircuitBreakerApplicationType (607) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__CircuitBreakerApplicationType(struct soap*, enum cb__CircuitBreakerApplicationType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__CircuitBreakerApplicationType(struct soap*, const enum cb__CircuitBreakerApplicationType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerApplicationType(struct soap*, const char*, int, const enum cb__CircuitBreakerApplicationType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__CircuitBreakerApplicationType2s(struct soap*, enum cb__CircuitBreakerApplicationType); +SOAP_FMAC3 enum cb__CircuitBreakerApplicationType * SOAP_FMAC4 soap_get_cb__CircuitBreakerApplicationType(struct soap*, enum cb__CircuitBreakerApplicationType *, const char*, const char*); +SOAP_FMAC3 enum cb__CircuitBreakerApplicationType * SOAP_FMAC4 soap_in_cb__CircuitBreakerApplicationType(struct soap*, const char*, enum cb__CircuitBreakerApplicationType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__CircuitBreakerApplicationType(struct soap*, const char*, enum cb__CircuitBreakerApplicationType *); + +#ifndef SOAP_TYPE_cb__CircuitBreakerProfileType +#define SOAP_TYPE_cb__CircuitBreakerProfileType (606) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__CircuitBreakerProfileType(struct soap*, enum cb__CircuitBreakerProfileType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__CircuitBreakerProfileType(struct soap*, const enum cb__CircuitBreakerProfileType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerProfileType(struct soap*, const char*, int, const enum cb__CircuitBreakerProfileType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__CircuitBreakerProfileType2s(struct soap*, enum cb__CircuitBreakerProfileType); +SOAP_FMAC3 enum cb__CircuitBreakerProfileType * SOAP_FMAC4 soap_get_cb__CircuitBreakerProfileType(struct soap*, enum cb__CircuitBreakerProfileType *, const char*, const char*); +SOAP_FMAC3 enum cb__CircuitBreakerProfileType * SOAP_FMAC4 soap_in_cb__CircuitBreakerProfileType(struct soap*, const char*, enum cb__CircuitBreakerProfileType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__CircuitBreakerProfileType(struct soap*, const char*, enum cb__CircuitBreakerProfileType *); + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType +#define SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType (605) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap*, enum cb__CircuitBreakerFilterIPAddressDirectionType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap*, const enum cb__CircuitBreakerFilterIPAddressDirectionType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap*, const char*, int, const enum cb__CircuitBreakerFilterIPAddressDirectionType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__CircuitBreakerFilterIPAddressDirectionType2s(struct soap*, enum cb__CircuitBreakerFilterIPAddressDirectionType); +SOAP_FMAC3 enum cb__CircuitBreakerFilterIPAddressDirectionType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap*, enum cb__CircuitBreakerFilterIPAddressDirectionType *, const char*, const char*); +SOAP_FMAC3 enum cb__CircuitBreakerFilterIPAddressDirectionType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap*, const char*, enum cb__CircuitBreakerFilterIPAddressDirectionType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__CircuitBreakerFilterIPAddressDirectionType(struct soap*, const char*, enum cb__CircuitBreakerFilterIPAddressDirectionType *); + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterDirectionType +#define SOAP_TYPE_cb__CircuitBreakerFilterDirectionType (604) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__CircuitBreakerFilterDirectionType(struct soap*, enum cb__CircuitBreakerFilterDirectionType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__CircuitBreakerFilterDirectionType(struct soap*, const enum cb__CircuitBreakerFilterDirectionType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterDirectionType(struct soap*, const char*, int, const enum cb__CircuitBreakerFilterDirectionType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__CircuitBreakerFilterDirectionType2s(struct soap*, enum cb__CircuitBreakerFilterDirectionType); +SOAP_FMAC3 enum cb__CircuitBreakerFilterDirectionType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterDirectionType(struct soap*, enum cb__CircuitBreakerFilterDirectionType *, const char*, const char*); +SOAP_FMAC3 enum cb__CircuitBreakerFilterDirectionType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterDirectionType(struct soap*, const char*, enum cb__CircuitBreakerFilterDirectionType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__CircuitBreakerFilterDirectionType(struct soap*, const char*, enum cb__CircuitBreakerFilterDirectionType *); + +#ifndef SOAP_TYPE_emi__AlertAuthOptionsType +#define SOAP_TYPE_emi__AlertAuthOptionsType (598) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__AlertAuthOptionsType(struct soap*, enum emi__AlertAuthOptionsType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__AlertAuthOptionsType(struct soap*, const enum emi__AlertAuthOptionsType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertAuthOptionsType(struct soap*, const char*, int, const enum emi__AlertAuthOptionsType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_emi__AlertAuthOptionsType2s(struct soap*, enum emi__AlertAuthOptionsType); +SOAP_FMAC3 enum emi__AlertAuthOptionsType * SOAP_FMAC4 soap_get_emi__AlertAuthOptionsType(struct soap*, enum emi__AlertAuthOptionsType *, const char*, const char*); +SOAP_FMAC3 enum emi__AlertAuthOptionsType * SOAP_FMAC4 soap_in_emi__AlertAuthOptionsType(struct soap*, const char*, enum emi__AlertAuthOptionsType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2emi__AlertAuthOptionsType(struct soap*, const char*, enum emi__AlertAuthOptionsType *); + +#ifndef SOAP_TYPE_emi__EventSeverityType +#define SOAP_TYPE_emi__EventSeverityType (594) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__EventSeverityType(struct soap*, enum emi__EventSeverityType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__EventSeverityType(struct soap*, const enum emi__EventSeverityType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventSeverityType(struct soap*, const char*, int, const enum emi__EventSeverityType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_emi__EventSeverityType2s(struct soap*, enum emi__EventSeverityType); +SOAP_FMAC3 enum emi__EventSeverityType * SOAP_FMAC4 soap_get_emi__EventSeverityType(struct soap*, enum emi__EventSeverityType *, const char*, const char*); +SOAP_FMAC3 enum emi__EventSeverityType * SOAP_FMAC4 soap_in_emi__EventSeverityType(struct soap*, const char*, enum emi__EventSeverityType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2emi__EventSeverityType(struct soap*, const char*, enum emi__EventSeverityType *); + +#ifndef SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE +#define SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE (587) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap*, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap*, const enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap*, const char*, int, const enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE2s(struct soap*, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE); +SOAP_FMAC3 enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE * SOAP_FMAC4 soap_get_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap*, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *, const char*, const char*); +SOAP_FMAC3 enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE * SOAP_FMAC4 soap_in_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap*, const char*, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap*, const char*, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *); + +#ifndef SOAP_TYPE_net__InterfaceModeType +#define SOAP_TYPE_net__InterfaceModeType (582) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__InterfaceModeType(struct soap*, enum net__InterfaceModeType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__InterfaceModeType(struct soap*, const enum net__InterfaceModeType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__InterfaceModeType(struct soap*, const char*, int, const enum net__InterfaceModeType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_net__InterfaceModeType2s(struct soap*, enum net__InterfaceModeType); +SOAP_FMAC3 enum net__InterfaceModeType * SOAP_FMAC4 soap_get_net__InterfaceModeType(struct soap*, enum net__InterfaceModeType *, const char*, const char*); +SOAP_FMAC3 enum net__InterfaceModeType * SOAP_FMAC4 soap_in_net__InterfaceModeType(struct soap*, const char*, enum net__InterfaceModeType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2net__InterfaceModeType(struct soap*, const char*, enum net__InterfaceModeType *); + +#ifndef SOAP_TYPE_net__DhcpModeType +#define SOAP_TYPE_net__DhcpModeType (580) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__DhcpModeType(struct soap*, enum net__DhcpModeType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__DhcpModeType(struct soap*, const enum net__DhcpModeType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__DhcpModeType(struct soap*, const char*, int, const enum net__DhcpModeType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_net__DhcpModeType2s(struct soap*, enum net__DhcpModeType); +SOAP_FMAC3 enum net__DhcpModeType * SOAP_FMAC4 soap_get_net__DhcpModeType(struct soap*, enum net__DhcpModeType *, const char*, const char*); +SOAP_FMAC3 enum net__DhcpModeType * SOAP_FMAC4 soap_in_net__DhcpModeType(struct soap*, const char*, enum net__DhcpModeType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2net__DhcpModeType(struct soap*, const char*, enum net__DhcpModeType *); + +#ifndef SOAP_TYPE_xcfg__CertNameOptionsType +#define SOAP_TYPE_xcfg__CertNameOptionsType (577) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_xcfg__CertNameOptionsType(struct soap*, enum xcfg__CertNameOptionsType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_xcfg__CertNameOptionsType(struct soap*, const enum xcfg__CertNameOptionsType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__CertNameOptionsType(struct soap*, const char*, int, const enum xcfg__CertNameOptionsType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_xcfg__CertNameOptionsType2s(struct soap*, enum xcfg__CertNameOptionsType); +SOAP_FMAC3 enum xcfg__CertNameOptionsType * SOAP_FMAC4 soap_get_xcfg__CertNameOptionsType(struct soap*, enum xcfg__CertNameOptionsType *, const char*, const char*); +SOAP_FMAC3 enum xcfg__CertNameOptionsType * SOAP_FMAC4 soap_in_xcfg__CertNameOptionsType(struct soap*, const char*, enum xcfg__CertNameOptionsType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2xcfg__CertNameOptionsType(struct soap*, const char*, enum xcfg__CertNameOptionsType *); + +#ifndef SOAP_TYPE_sai__HTTPAuthOptionType +#define SOAP_TYPE_sai__HTTPAuthOptionType (574) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__HTTPAuthOptionType(struct soap*, enum sai__HTTPAuthOptionType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__HTTPAuthOptionType(struct soap*, const enum sai__HTTPAuthOptionType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__HTTPAuthOptionType(struct soap*, const char*, int, const enum sai__HTTPAuthOptionType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__HTTPAuthOptionType2s(struct soap*, enum sai__HTTPAuthOptionType); +SOAP_FMAC3 enum sai__HTTPAuthOptionType * SOAP_FMAC4 soap_get_sai__HTTPAuthOptionType(struct soap*, enum sai__HTTPAuthOptionType *, const char*, const char*); +SOAP_FMAC3 enum sai__HTTPAuthOptionType * SOAP_FMAC4 soap_in_sai__HTTPAuthOptionType(struct soap*, const char*, enum sai__HTTPAuthOptionType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__HTTPAuthOptionType(struct soap*, const char*, enum sai__HTTPAuthOptionType *); + +#ifndef SOAP_TYPE_sai__HashTypeType +#define SOAP_TYPE_sai__HashTypeType (573) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__HashTypeType(struct soap*, enum sai__HashTypeType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__HashTypeType(struct soap*, const enum sai__HashTypeType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__HashTypeType(struct soap*, const char*, int, const enum sai__HashTypeType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__HashTypeType2s(struct soap*, enum sai__HashTypeType); +SOAP_FMAC3 enum sai__HashTypeType * SOAP_FMAC4 soap_get_sai__HashTypeType(struct soap*, enum sai__HashTypeType *, const char*, const char*); +SOAP_FMAC3 enum sai__HashTypeType * SOAP_FMAC4 soap_in_sai__HashTypeType(struct soap*, const char*, enum sai__HashTypeType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__HashTypeType(struct soap*, const char*, enum sai__HashTypeType *); + +#ifndef SOAP_TYPE_sai__ProvisioningTLSModeType +#define SOAP_TYPE_sai__ProvisioningTLSModeType (569) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__ProvisioningTLSModeType(struct soap*, enum sai__ProvisioningTLSModeType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__ProvisioningTLSModeType(struct soap*, const enum sai__ProvisioningTLSModeType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__ProvisioningTLSModeType(struct soap*, const char*, int, const enum sai__ProvisioningTLSModeType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__ProvisioningTLSModeType2s(struct soap*, enum sai__ProvisioningTLSModeType); +SOAP_FMAC3 enum sai__ProvisioningTLSModeType * SOAP_FMAC4 soap_get_sai__ProvisioningTLSModeType(struct soap*, enum sai__ProvisioningTLSModeType *, const char*, const char*); +SOAP_FMAC3 enum sai__ProvisioningTLSModeType * SOAP_FMAC4 soap_in_sai__ProvisioningTLSModeType(struct soap*, const char*, enum sai__ProvisioningTLSModeType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__ProvisioningTLSModeType(struct soap*, const char*, enum sai__ProvisioningTLSModeType *); + +#ifndef SOAP_TYPE_sai__TlsAthenticationType +#define SOAP_TYPE_sai__TlsAthenticationType (567) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__TlsAthenticationType(struct soap*, enum sai__TlsAthenticationType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__TlsAthenticationType(struct soap*, const enum sai__TlsAthenticationType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__TlsAthenticationType(struct soap*, const char*, int, const enum sai__TlsAthenticationType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__TlsAthenticationType2s(struct soap*, enum sai__TlsAthenticationType); +SOAP_FMAC3 enum sai__TlsAthenticationType * SOAP_FMAC4 soap_get_sai__TlsAthenticationType(struct soap*, enum sai__TlsAthenticationType *, const char*, const char*); +SOAP_FMAC3 enum sai__TlsAthenticationType * SOAP_FMAC4 soap_in_sai__TlsAthenticationType(struct soap*, const char*, enum sai__TlsAthenticationType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__TlsAthenticationType(struct soap*, const char*, enum sai__TlsAthenticationType *); + +#ifndef SOAP_TYPE_sai__InterfaceType +#define SOAP_TYPE_sai__InterfaceType (566) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__InterfaceType(struct soap*, enum sai__InterfaceType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__InterfaceType(struct soap*, const enum sai__InterfaceType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__InterfaceType(struct soap*, const char*, int, const enum sai__InterfaceType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__InterfaceType2s(struct soap*, enum sai__InterfaceType); +SOAP_FMAC3 enum sai__InterfaceType * SOAP_FMAC4 soap_get_sai__InterfaceType(struct soap*, enum sai__InterfaceType *, const char*, const char*); +SOAP_FMAC3 enum sai__InterfaceType * SOAP_FMAC4 soap_in_sai__InterfaceType(struct soap*, const char*, enum sai__InterfaceType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__InterfaceType(struct soap*, const char*, enum sai__InterfaceType *); + +#ifndef SOAP_TYPE_sai__EnabledInterfacesType +#define SOAP_TYPE_sai__EnabledInterfacesType (565) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__EnabledInterfacesType(struct soap*, enum sai__EnabledInterfacesType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__EnabledInterfacesType(struct soap*, const enum sai__EnabledInterfacesType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__EnabledInterfacesType(struct soap*, const char*, int, const enum sai__EnabledInterfacesType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__EnabledInterfacesType2s(struct soap*, enum sai__EnabledInterfacesType); +SOAP_FMAC3 enum sai__EnabledInterfacesType * SOAP_FMAC4 soap_get_sai__EnabledInterfacesType(struct soap*, enum sai__EnabledInterfacesType *, const char*, const char*); +SOAP_FMAC3 enum sai__EnabledInterfacesType * SOAP_FMAC4 soap_in_sai__EnabledInterfacesType(struct soap*, const char*, enum sai__EnabledInterfacesType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__EnabledInterfacesType(struct soap*, const char*, enum sai__EnabledInterfacesType *); + +#ifndef SOAP_TYPE_sai__PowerStateType +#define SOAP_TYPE_sai__PowerStateType (564) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__PowerStateType(struct soap*, enum sai__PowerStateType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__PowerStateType(struct soap*, const enum sai__PowerStateType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__PowerStateType(struct soap*, const char*, int, const enum sai__PowerStateType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__PowerStateType2s(struct soap*, enum sai__PowerStateType); +SOAP_FMAC3 enum sai__PowerStateType * SOAP_FMAC4 soap_get_sai__PowerStateType(struct soap*, enum sai__PowerStateType *, const char*, const char*); +SOAP_FMAC3 enum sai__PowerStateType * SOAP_FMAC4 soap_in_sai__PowerStateType(struct soap*, const char*, enum sai__PowerStateType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__PowerStateType(struct soap*, const char*, enum sai__PowerStateType *); + +#ifndef SOAP_TYPE_sai__KerberosEncryptionType +#define SOAP_TYPE_sai__KerberosEncryptionType (563) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__KerberosEncryptionType(struct soap*, enum sai__KerberosEncryptionType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__KerberosEncryptionType(struct soap*, const enum sai__KerberosEncryptionType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__KerberosEncryptionType(struct soap*, const char*, int, const enum sai__KerberosEncryptionType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__KerberosEncryptionType2s(struct soap*, enum sai__KerberosEncryptionType); +SOAP_FMAC3 enum sai__KerberosEncryptionType * SOAP_FMAC4 soap_get_sai__KerberosEncryptionType(struct soap*, enum sai__KerberosEncryptionType *, const char*, const char*); +SOAP_FMAC3 enum sai__KerberosEncryptionType * SOAP_FMAC4 soap_in_sai__KerberosEncryptionType(struct soap*, const char*, enum sai__KerberosEncryptionType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__KerberosEncryptionType(struct soap*, const char*, enum sai__KerberosEncryptionType *); + +#ifndef SOAP_TYPE_sai__KerberosSpnProtocolType +#define SOAP_TYPE_sai__KerberosSpnProtocolType (562) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__KerberosSpnProtocolType(struct soap*, enum sai__KerberosSpnProtocolType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__KerberosSpnProtocolType(struct soap*, const enum sai__KerberosSpnProtocolType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__KerberosSpnProtocolType(struct soap*, const char*, int, const enum sai__KerberosSpnProtocolType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__KerberosSpnProtocolType2s(struct soap*, enum sai__KerberosSpnProtocolType); +SOAP_FMAC3 enum sai__KerberosSpnProtocolType * SOAP_FMAC4 soap_get_sai__KerberosSpnProtocolType(struct soap*, enum sai__KerberosSpnProtocolType *, const char*, const char*); +SOAP_FMAC3 enum sai__KerberosSpnProtocolType * SOAP_FMAC4 soap_in_sai__KerberosSpnProtocolType(struct soap*, const char*, enum sai__KerberosSpnProtocolType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__KerberosSpnProtocolType(struct soap*, const char*, enum sai__KerberosSpnProtocolType *); + +#ifndef SOAP_TYPE_sai__AccessPermissionType +#define SOAP_TYPE_sai__AccessPermissionType (561) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__AccessPermissionType(struct soap*, enum sai__AccessPermissionType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__AccessPermissionType(struct soap*, const enum sai__AccessPermissionType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AccessPermissionType(struct soap*, const char*, int, const enum sai__AccessPermissionType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__AccessPermissionType2s(struct soap*, enum sai__AccessPermissionType); +SOAP_FMAC3 enum sai__AccessPermissionType * SOAP_FMAC4 soap_get_sai__AccessPermissionType(struct soap*, enum sai__AccessPermissionType *, const char*, const char*); +SOAP_FMAC3 enum sai__AccessPermissionType * SOAP_FMAC4 soap_in_sai__AccessPermissionType(struct soap*, const char*, enum sai__AccessPermissionType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__AccessPermissionType(struct soap*, const char*, enum sai__AccessPermissionType *); + +#ifndef SOAP_TYPE_sai__ProvisioningModeType +#define SOAP_TYPE_sai__ProvisioningModeType (560) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__ProvisioningModeType(struct soap*, enum sai__ProvisioningModeType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__ProvisioningModeType(struct soap*, const enum sai__ProvisioningModeType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__ProvisioningModeType(struct soap*, const char*, int, const enum sai__ProvisioningModeType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__ProvisioningModeType2s(struct soap*, enum sai__ProvisioningModeType); +SOAP_FMAC3 enum sai__ProvisioningModeType * SOAP_FMAC4 soap_get_sai__ProvisioningModeType(struct soap*, enum sai__ProvisioningModeType *, const char*, const char*); +SOAP_FMAC3 enum sai__ProvisioningModeType * SOAP_FMAC4 soap_in_sai__ProvisioningModeType(struct soap*, const char*, enum sai__ProvisioningModeType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__ProvisioningModeType(struct soap*, const char*, enum sai__ProvisioningModeType *); + +#ifndef SOAP_TYPE_sai__RngKeyEncodingType +#define SOAP_TYPE_sai__RngKeyEncodingType (559) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__RngKeyEncodingType(struct soap*, enum sai__RngKeyEncodingType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__RngKeyEncodingType(struct soap*, const enum sai__RngKeyEncodingType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RngKeyEncodingType(struct soap*, const char*, int, const enum sai__RngKeyEncodingType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__RngKeyEncodingType2s(struct soap*, enum sai__RngKeyEncodingType); +SOAP_FMAC3 enum sai__RngKeyEncodingType * SOAP_FMAC4 soap_get_sai__RngKeyEncodingType(struct soap*, enum sai__RngKeyEncodingType *, const char*, const char*); +SOAP_FMAC3 enum sai__RngKeyEncodingType * SOAP_FMAC4 soap_in_sai__RngKeyEncodingType(struct soap*, const char*, enum sai__RngKeyEncodingType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__RngKeyEncodingType(struct soap*, const char*, enum sai__RngKeyEncodingType *); + +#ifndef SOAP_TYPE_sai__RsaCertificateEncodingType +#define SOAP_TYPE_sai__RsaCertificateEncodingType (558) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__RsaCertificateEncodingType(struct soap*, enum sai__RsaCertificateEncodingType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__RsaCertificateEncodingType(struct soap*, const enum sai__RsaCertificateEncodingType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RsaCertificateEncodingType(struct soap*, const char*, int, const enum sai__RsaCertificateEncodingType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__RsaCertificateEncodingType2s(struct soap*, enum sai__RsaCertificateEncodingType); +SOAP_FMAC3 enum sai__RsaCertificateEncodingType * SOAP_FMAC4 soap_get_sai__RsaCertificateEncodingType(struct soap*, enum sai__RsaCertificateEncodingType *, const char*, const char*); +SOAP_FMAC3 enum sai__RsaCertificateEncodingType * SOAP_FMAC4 soap_in_sai__RsaCertificateEncodingType(struct soap*, const char*, enum sai__RsaCertificateEncodingType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__RsaCertificateEncodingType(struct soap*, const char*, enum sai__RsaCertificateEncodingType *); + +#ifndef SOAP_TYPE_sai__RsaKeyEncodingType +#define SOAP_TYPE_sai__RsaKeyEncodingType (557) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__RsaKeyEncodingType(struct soap*, enum sai__RsaKeyEncodingType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__RsaKeyEncodingType(struct soap*, const enum sai__RsaKeyEncodingType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RsaKeyEncodingType(struct soap*, const char*, int, const enum sai__RsaKeyEncodingType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__RsaKeyEncodingType2s(struct soap*, enum sai__RsaKeyEncodingType); +SOAP_FMAC3 enum sai__RsaKeyEncodingType * SOAP_FMAC4 soap_get_sai__RsaKeyEncodingType(struct soap*, enum sai__RsaKeyEncodingType *, const char*, const char*); +SOAP_FMAC3 enum sai__RsaKeyEncodingType * SOAP_FMAC4 soap_in_sai__RsaKeyEncodingType(struct soap*, const char*, enum sai__RsaKeyEncodingType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__RsaKeyEncodingType(struct soap*, const char*, enum sai__RsaKeyEncodingType *); + +#ifndef SOAP_TYPE_sai__UserAclRealmType +#define SOAP_TYPE_sai__UserAclRealmType (552) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__UserAclRealmType(struct soap*, enum sai__UserAclRealmType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__UserAclRealmType(struct soap*, const enum sai__UserAclRealmType *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclRealmType(struct soap*, const char*, int, const enum sai__UserAclRealmType *, const char*); + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__UserAclRealmType2s(struct soap*, enum sai__UserAclRealmType); +SOAP_FMAC3 enum sai__UserAclRealmType * SOAP_FMAC4 soap_get_sai__UserAclRealmType(struct soap*, enum sai__UserAclRealmType *, const char*, const char*); +SOAP_FMAC3 enum sai__UserAclRealmType * SOAP_FMAC4 soap_in_sai__UserAclRealmType(struct soap*, const char*, enum sai__UserAclRealmType *, const char*); + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__UserAclRealmType(struct soap*, const char*, enum sai__UserAclRealmType *); + +#ifndef SOAP_TYPE_wcxs__PassPhrase63Type +#define SOAP_TYPE_wcxs__PassPhrase63Type (661) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__PassPhrase63Type(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__PassPhrase63Type(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__PassPhrase63Type(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__PassPhrase63Type(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_wcxs__PassPhrase63Type(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_wcxs__PassPhrase63Type(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_wcxs__PassPhrase63Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__PassPhrase63Type(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_wcxs__PassPhrase63Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__PassPhrase63Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__PassPhraseWEP128Type +#define SOAP_TYPE_wcxs__PassPhraseWEP128Type (660) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__PassPhraseWEP128Type(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__PassPhraseWEP128Type(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__PassPhraseWEP128Type(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__PassPhraseWEP128Type(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_wcxs__PassPhraseWEP128Type(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_wcxs__PassPhraseWEP128Type(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_wcxs__PassPhraseWEP128Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__PassPhraseWEP128Type(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_wcxs__PassPhraseWEP128Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__PassPhraseWEP128Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__PassPhrase5Type +#define SOAP_TYPE_wcxs__PassPhrase5Type (659) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__PassPhrase5Type(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__PassPhrase5Type(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__PassPhrase5Type(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__PassPhrase5Type(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_wcxs__PassPhrase5Type(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_wcxs__PassPhrase5Type(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_wcxs__PassPhrase5Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__PassPhrase5Type(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_wcxs__PassPhrase5Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__PassPhrase5Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__RawKey256Type +#define SOAP_TYPE_wcxs__RawKey256Type (658) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__RawKey256Type(struct soap*, xsd__base64Binary const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__RawKey256Type(struct soap*, xsd__base64Binary *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__RawKey256Type(struct soap*, const xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__RawKey256Type(struct soap*, const char*, int, const xsd__base64Binary *, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_wcxs__RawKey256Type(struct soap*, xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_wcxs__RawKey256Type(struct soap*, const char*, xsd__base64Binary *, const char*); +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_wcxs__RawKey256Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__RawKey256Type(struct soap*, xsd__base64Binary*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_wcxs__RawKey256Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__RawKey256Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__RawKey128Type +#define SOAP_TYPE_wcxs__RawKey128Type (657) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__RawKey128Type(struct soap*, xsd__base64Binary const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__RawKey128Type(struct soap*, xsd__base64Binary *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__RawKey128Type(struct soap*, const xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__RawKey128Type(struct soap*, const char*, int, const xsd__base64Binary *, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_wcxs__RawKey128Type(struct soap*, xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_wcxs__RawKey128Type(struct soap*, const char*, xsd__base64Binary *, const char*); +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_wcxs__RawKey128Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__RawKey128Type(struct soap*, xsd__base64Binary*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_wcxs__RawKey128Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__RawKey128Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__RawKey64Type +#define SOAP_TYPE_wcxs__RawKey64Type (656) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__RawKey64Type(struct soap*, xsd__base64Binary const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__RawKey64Type(struct soap*, xsd__base64Binary *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__RawKey64Type(struct soap*, const xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__RawKey64Type(struct soap*, const char*, int, const xsd__base64Binary *, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_wcxs__RawKey64Type(struct soap*, xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_wcxs__RawKey64Type(struct soap*, const char*, xsd__base64Binary *, const char*); +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_wcxs__RawKey64Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__RawKey64Type(struct soap*, xsd__base64Binary*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_wcxs__RawKey64Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__RawKey64Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__ProfileNameType +#define SOAP_TYPE_wcxs__ProfileNameType (653) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__ProfileNameType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__ProfileNameType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__ProfileNameType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileNameType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_wcxs__ProfileNameType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_wcxs__ProfileNameType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_wcxs__ProfileNameType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileNameType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_wcxs__ProfileNameType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileNameType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__AgentDescription +#define SOAP_TYPE__apr__AgentDescription (627) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__apr__AgentDescription(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default__apr__AgentDescription(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put__apr__AgentDescription(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__AgentDescription(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__apr__AgentDescription(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in__apr__AgentDescription(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__apr__AgentDescription(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__AgentDescription(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__apr__AgentDescription(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__AgentDescription(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__PolicyName +#define SOAP_TYPE__cb__PolicyName (611) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__PolicyName(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default__cb__PolicyName(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put__cb__PolicyName(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__PolicyName(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__cb__PolicyName(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in__cb__PolicyName(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__cb__PolicyName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__PolicyName(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__cb__PolicyName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__PolicyName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__FilterName +#define SOAP_TYPE__cb__FilterName (610) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__FilterName(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default__cb__FilterName(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put__cb__FilterName(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__FilterName(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__cb__FilterName(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in__cb__FilterName(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__cb__FilterName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__FilterName(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__cb__FilterName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__FilterName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__IPv6AddressStringType +#define SOAP_TYPE_cb__IPv6AddressStringType (603) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cb__IPv6AddressStringType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__IPv6AddressStringType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__IPv6AddressStringType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__IPv6AddressStringType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cb__IPv6AddressStringType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_cb__IPv6AddressStringType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cb__IPv6AddressStringType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__IPv6AddressStringType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cb__IPv6AddressStringType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__IPv6AddressStringType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__IPv4AddressStringType +#define SOAP_TYPE_cb__IPv4AddressStringType (602) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cb__IPv4AddressStringType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__IPv4AddressStringType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__IPv4AddressStringType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__IPv4AddressStringType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cb__IPv4AddressStringType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_cb__IPv4AddressStringType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cb__IPv4AddressStringType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__IPv4AddressStringType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cb__IPv4AddressStringType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__IPv4AddressStringType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__CommunityStringType +#define SOAP_TYPE_emi__CommunityStringType (599) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_emi__CommunityStringType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__CommunityStringType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__CommunityStringType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__CommunityStringType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_emi__CommunityStringType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_emi__CommunityStringType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_emi__CommunityStringType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__CommunityStringType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_emi__CommunityStringType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__CommunityStringType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_net__MACAddressType +#define SOAP_TYPE_net__MACAddressType (581) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_net__MACAddressType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__MACAddressType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__MACAddressType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__MACAddressType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_net__MACAddressType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_net__MACAddressType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_net__MACAddressType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__MACAddressType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_net__MACAddressType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__MACAddressType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__KerberosRealmName +#define SOAP_TYPE__sai__KerberosRealmName (576) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__sai__KerberosRealmName(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default__sai__KerberosRealmName(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put__sai__KerberosRealmName(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__KerberosRealmName(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__sai__KerberosRealmName(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in__sai__KerberosRealmName(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__sai__KerberosRealmName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__KerberosRealmName(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__sai__KerberosRealmName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__KerberosRealmName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SpnString +#define SOAP_TYPE__sai__SpnString (575) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__sai__SpnString(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default__sai__SpnString(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put__sai__SpnString(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SpnString(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__sai__SpnString(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in__sai__SpnString(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__sai__SpnString(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SpnString(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__sai__SpnString(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SpnString(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__FriendlyNameType +#define SOAP_TYPE_sai__FriendlyNameType (572) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__FriendlyNameType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__FriendlyNameType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__FriendlyNameType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__FriendlyNameType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_sai__FriendlyNameType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_sai__FriendlyNameType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_sai__FriendlyNameType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__FriendlyNameType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_sai__FriendlyNameType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__FriendlyNameType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__ProvisioningOTPType +#define SOAP_TYPE_sai__ProvisioningOTPType (571) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__ProvisioningOTPType(struct soap*, xsd__base64Binary const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__ProvisioningOTPType(struct soap*, xsd__base64Binary *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__ProvisioningOTPType(struct soap*, const xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__ProvisioningOTPType(struct soap*, const char*, int, const xsd__base64Binary *, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_sai__ProvisioningOTPType(struct soap*, xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_sai__ProvisioningOTPType(struct soap*, const char*, xsd__base64Binary *, const char*); +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_sai__ProvisioningOTPType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__ProvisioningOTPType(struct soap*, xsd__base64Binary*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_sai__ProvisioningOTPType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__ProvisioningOTPType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__MEBxPasswordType +#define SOAP_TYPE_sai__MEBxPasswordType (570) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__MEBxPasswordType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__MEBxPasswordType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__MEBxPasswordType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__MEBxPasswordType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_sai__MEBxPasswordType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_sai__MEBxPasswordType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_sai__MEBxPasswordType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__MEBxPasswordType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_sai__MEBxPasswordType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__MEBxPasswordType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__AclPasswordStringType +#define SOAP_TYPE_sai__AclPasswordStringType (555) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__AclPasswordStringType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__AclPasswordStringType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__AclPasswordStringType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AclPasswordStringType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_sai__AclPasswordStringType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_sai__AclPasswordStringType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_sai__AclPasswordStringType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AclPasswordStringType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_sai__AclPasswordStringType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AclPasswordStringType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__AclStringType +#define SOAP_TYPE_sai__AclStringType (554) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__AclStringType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__AclStringType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__AclStringType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AclStringType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_sai__AclStringType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_sai__AclStringType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_sai__AclStringType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AclStringType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_sai__AclStringType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AclStringType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cmn__GuidBuf +#define SOAP_TYPE_cmn__GuidBuf (549) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cmn__GuidBuf(struct soap*, xsd__base64Binary const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__GuidBuf(struct soap*, xsd__base64Binary *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__GuidBuf(struct soap*, const xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__GuidBuf(struct soap*, const char*, int, const xsd__base64Binary *, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_cmn__GuidBuf(struct soap*, xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_cmn__GuidBuf(struct soap*, const char*, xsd__base64Binary *, const char*); +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_cmn__GuidBuf(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__GuidBuf(struct soap*, xsd__base64Binary*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_cmn__GuidBuf(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__GuidBuf(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cmn__IPv6AddressStringType +#define SOAP_TYPE_cmn__IPv6AddressStringType (547) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cmn__IPv6AddressStringType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__IPv6AddressStringType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__IPv6AddressStringType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__IPv6AddressStringType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cmn__IPv6AddressStringType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_cmn__IPv6AddressStringType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cmn__IPv6AddressStringType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__IPv6AddressStringType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cmn__IPv6AddressStringType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__IPv6AddressStringType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cmn__IPv4AddressStringType +#define SOAP_TYPE_cmn__IPv4AddressStringType (546) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cmn__IPv4AddressStringType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__IPv4AddressStringType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__IPv4AddressStringType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__IPv4AddressStringType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cmn__IPv4AddressStringType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_cmn__IPv4AddressStringType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cmn__IPv4AddressStringType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__IPv4AddressStringType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cmn__IPv4AddressStringType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__IPv4AddressStringType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cmn__HostNameType +#define SOAP_TYPE_cmn__HostNameType (544) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cmn__HostNameType(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__HostNameType(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__HostNameType(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__HostNameType(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cmn__HostNameType(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_cmn__HostNameType(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cmn__HostNameType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__HostNameType(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cmn__HostNameType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__HostNameType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__GetWirelessSettingsResponse +#define SOAP_TYPE__wcxs__GetWirelessSettingsResponse (542) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessSettingsResponse(struct soap*, const char*, int, const _wcxs__GetWirelessSettingsResponse *, const char*); +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse * SOAP_FMAC4 soap_get__wcxs__GetWirelessSettingsResponse(struct soap*, _wcxs__GetWirelessSettingsResponse *, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse * SOAP_FMAC4 soap_in__wcxs__GetWirelessSettingsResponse(struct soap*, const char*, _wcxs__GetWirelessSettingsResponse *, const char*); +SOAP_FMAC5 _wcxs__GetWirelessSettingsResponse * SOAP_FMAC6 soap_new__wcxs__GetWirelessSettingsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessSettingsResponse(struct soap*, _wcxs__GetWirelessSettingsResponse*); +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessSettingsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessSettingsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__GetWirelessSettingsRequest +#define SOAP_TYPE__wcxs__GetWirelessSettingsRequest (541) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessSettingsRequest(struct soap*, const char*, int, const _wcxs__GetWirelessSettingsRequest *, const char*); +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest * SOAP_FMAC4 soap_get__wcxs__GetWirelessSettingsRequest(struct soap*, _wcxs__GetWirelessSettingsRequest *, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest * SOAP_FMAC4 soap_in__wcxs__GetWirelessSettingsRequest(struct soap*, const char*, _wcxs__GetWirelessSettingsRequest *, const char*); +SOAP_FMAC5 _wcxs__GetWirelessSettingsRequest * SOAP_FMAC6 soap_new__wcxs__GetWirelessSettingsRequest(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessSettingsRequest(struct soap*, _wcxs__GetWirelessSettingsRequest*); +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessSettingsRequest(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessSettingsRequest(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse +#define SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse (540) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessCapabilitiesResponse(struct soap*, const char*, int, const _wcxs__GetWirelessCapabilitiesResponse *, const char*); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse * SOAP_FMAC4 soap_get__wcxs__GetWirelessCapabilitiesResponse(struct soap*, _wcxs__GetWirelessCapabilitiesResponse *, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse * SOAP_FMAC4 soap_in__wcxs__GetWirelessCapabilitiesResponse(struct soap*, const char*, _wcxs__GetWirelessCapabilitiesResponse *, const char*); +SOAP_FMAC5 _wcxs__GetWirelessCapabilitiesResponse * SOAP_FMAC6 soap_new__wcxs__GetWirelessCapabilitiesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessCapabilitiesResponse(struct soap*, _wcxs__GetWirelessCapabilitiesResponse*); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessCapabilitiesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessCapabilitiesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest +#define SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest (539) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessCapabilitiesRequest(struct soap*, const char*, int, const _wcxs__GetWirelessCapabilitiesRequest *, const char*); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest * SOAP_FMAC4 soap_get__wcxs__GetWirelessCapabilitiesRequest(struct soap*, _wcxs__GetWirelessCapabilitiesRequest *, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest * SOAP_FMAC4 soap_in__wcxs__GetWirelessCapabilitiesRequest(struct soap*, const char*, _wcxs__GetWirelessCapabilitiesRequest *, const char*); +SOAP_FMAC5 _wcxs__GetWirelessCapabilitiesRequest * SOAP_FMAC6 soap_new__wcxs__GetWirelessCapabilitiesRequest(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessCapabilitiesRequest(struct soap*, _wcxs__GetWirelessCapabilitiesRequest*); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessCapabilitiesRequest(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessCapabilitiesRequest(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse +#define SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse (538) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__EnumerateWirelessProfilesResponse(struct soap*, const char*, int, const _wcxs__EnumerateWirelessProfilesResponse *, const char*); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse * SOAP_FMAC4 soap_get__wcxs__EnumerateWirelessProfilesResponse(struct soap*, _wcxs__EnumerateWirelessProfilesResponse *, const char*, const char*); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse * SOAP_FMAC4 soap_in__wcxs__EnumerateWirelessProfilesResponse(struct soap*, const char*, _wcxs__EnumerateWirelessProfilesResponse *, const char*); +SOAP_FMAC5 _wcxs__EnumerateWirelessProfilesResponse * SOAP_FMAC6 soap_new__wcxs__EnumerateWirelessProfilesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__EnumerateWirelessProfilesResponse(struct soap*, _wcxs__EnumerateWirelessProfilesResponse*); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse * SOAP_FMAC4 soap_instantiate__wcxs__EnumerateWirelessProfilesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__EnumerateWirelessProfilesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest +#define SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest (537) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__EnumerateWirelessProfilesRequest(struct soap*, const char*, int, const _wcxs__EnumerateWirelessProfilesRequest *, const char*); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest * SOAP_FMAC4 soap_get__wcxs__EnumerateWirelessProfilesRequest(struct soap*, _wcxs__EnumerateWirelessProfilesRequest *, const char*, const char*); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest * SOAP_FMAC4 soap_in__wcxs__EnumerateWirelessProfilesRequest(struct soap*, const char*, _wcxs__EnumerateWirelessProfilesRequest *, const char*); +SOAP_FMAC5 _wcxs__EnumerateWirelessProfilesRequest * SOAP_FMAC6 soap_new__wcxs__EnumerateWirelessProfilesRequest(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__EnumerateWirelessProfilesRequest(struct soap*, _wcxs__EnumerateWirelessProfilesRequest*); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest * SOAP_FMAC4 soap_instantiate__wcxs__EnumerateWirelessProfilesRequest(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__EnumerateWirelessProfilesRequest(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__UpdateWirelessProfileResponse +#define SOAP_TYPE__wcxs__UpdateWirelessProfileResponse (536) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__UpdateWirelessProfileResponse(struct soap*, const char*, int, const _wcxs__UpdateWirelessProfileResponse *, const char*); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse * SOAP_FMAC4 soap_get__wcxs__UpdateWirelessProfileResponse(struct soap*, _wcxs__UpdateWirelessProfileResponse *, const char*, const char*); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse * SOAP_FMAC4 soap_in__wcxs__UpdateWirelessProfileResponse(struct soap*, const char*, _wcxs__UpdateWirelessProfileResponse *, const char*); +SOAP_FMAC5 _wcxs__UpdateWirelessProfileResponse * SOAP_FMAC6 soap_new__wcxs__UpdateWirelessProfileResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__UpdateWirelessProfileResponse(struct soap*, _wcxs__UpdateWirelessProfileResponse*); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse * SOAP_FMAC4 soap_instantiate__wcxs__UpdateWirelessProfileResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__UpdateWirelessProfileResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__UpdateWirelessProfileRequest +#define SOAP_TYPE__wcxs__UpdateWirelessProfileRequest (535) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__UpdateWirelessProfileRequest(struct soap*, const char*, int, const _wcxs__UpdateWirelessProfileRequest *, const char*); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest * SOAP_FMAC4 soap_get__wcxs__UpdateWirelessProfileRequest(struct soap*, _wcxs__UpdateWirelessProfileRequest *, const char*, const char*); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest * SOAP_FMAC4 soap_in__wcxs__UpdateWirelessProfileRequest(struct soap*, const char*, _wcxs__UpdateWirelessProfileRequest *, const char*); +SOAP_FMAC5 _wcxs__UpdateWirelessProfileRequest * SOAP_FMAC6 soap_new__wcxs__UpdateWirelessProfileRequest(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__UpdateWirelessProfileRequest(struct soap*, _wcxs__UpdateWirelessProfileRequest*); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest * SOAP_FMAC4 soap_instantiate__wcxs__UpdateWirelessProfileRequest(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__UpdateWirelessProfileRequest(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__RemoveWirelessProfileResponse +#define SOAP_TYPE__wcxs__RemoveWirelessProfileResponse (534) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__RemoveWirelessProfileResponse(struct soap*, const char*, int, const _wcxs__RemoveWirelessProfileResponse *, const char*); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse * SOAP_FMAC4 soap_get__wcxs__RemoveWirelessProfileResponse(struct soap*, _wcxs__RemoveWirelessProfileResponse *, const char*, const char*); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse * SOAP_FMAC4 soap_in__wcxs__RemoveWirelessProfileResponse(struct soap*, const char*, _wcxs__RemoveWirelessProfileResponse *, const char*); +SOAP_FMAC5 _wcxs__RemoveWirelessProfileResponse * SOAP_FMAC6 soap_new__wcxs__RemoveWirelessProfileResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__RemoveWirelessProfileResponse(struct soap*, _wcxs__RemoveWirelessProfileResponse*); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse * SOAP_FMAC4 soap_instantiate__wcxs__RemoveWirelessProfileResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__RemoveWirelessProfileResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__RemoveWirelessProfileRequest +#define SOAP_TYPE__wcxs__RemoveWirelessProfileRequest (533) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__RemoveWirelessProfileRequest(struct soap*, const char*, int, const _wcxs__RemoveWirelessProfileRequest *, const char*); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest * SOAP_FMAC4 soap_get__wcxs__RemoveWirelessProfileRequest(struct soap*, _wcxs__RemoveWirelessProfileRequest *, const char*, const char*); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest * SOAP_FMAC4 soap_in__wcxs__RemoveWirelessProfileRequest(struct soap*, const char*, _wcxs__RemoveWirelessProfileRequest *, const char*); +SOAP_FMAC5 _wcxs__RemoveWirelessProfileRequest * SOAP_FMAC6 soap_new__wcxs__RemoveWirelessProfileRequest(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__RemoveWirelessProfileRequest(struct soap*, _wcxs__RemoveWirelessProfileRequest*); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest * SOAP_FMAC4 soap_instantiate__wcxs__RemoveWirelessProfileRequest(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__RemoveWirelessProfileRequest(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__GetWirelessProfileResponse +#define SOAP_TYPE__wcxs__GetWirelessProfileResponse (532) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessProfileResponse(struct soap*, const char*, int, const _wcxs__GetWirelessProfileResponse *, const char*); +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse * SOAP_FMAC4 soap_get__wcxs__GetWirelessProfileResponse(struct soap*, _wcxs__GetWirelessProfileResponse *, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse * SOAP_FMAC4 soap_in__wcxs__GetWirelessProfileResponse(struct soap*, const char*, _wcxs__GetWirelessProfileResponse *, const char*); +SOAP_FMAC5 _wcxs__GetWirelessProfileResponse * SOAP_FMAC6 soap_new__wcxs__GetWirelessProfileResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessProfileResponse(struct soap*, _wcxs__GetWirelessProfileResponse*); +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessProfileResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessProfileResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__GetWirelessProfileRequest +#define SOAP_TYPE__wcxs__GetWirelessProfileRequest (531) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessProfileRequest(struct soap*, const char*, int, const _wcxs__GetWirelessProfileRequest *, const char*); +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest * SOAP_FMAC4 soap_get__wcxs__GetWirelessProfileRequest(struct soap*, _wcxs__GetWirelessProfileRequest *, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest * SOAP_FMAC4 soap_in__wcxs__GetWirelessProfileRequest(struct soap*, const char*, _wcxs__GetWirelessProfileRequest *, const char*); +SOAP_FMAC5 _wcxs__GetWirelessProfileRequest * SOAP_FMAC6 soap_new__wcxs__GetWirelessProfileRequest(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessProfileRequest(struct soap*, _wcxs__GetWirelessProfileRequest*); +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessProfileRequest(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessProfileRequest(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__AddWirelessProfileResponse +#define SOAP_TYPE__wcxs__AddWirelessProfileResponse (530) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__AddWirelessProfileResponse(struct soap*, const char*, int, const _wcxs__AddWirelessProfileResponse *, const char*); +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse * SOAP_FMAC4 soap_get__wcxs__AddWirelessProfileResponse(struct soap*, _wcxs__AddWirelessProfileResponse *, const char*, const char*); +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse * SOAP_FMAC4 soap_in__wcxs__AddWirelessProfileResponse(struct soap*, const char*, _wcxs__AddWirelessProfileResponse *, const char*); +SOAP_FMAC5 _wcxs__AddWirelessProfileResponse * SOAP_FMAC6 soap_new__wcxs__AddWirelessProfileResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__AddWirelessProfileResponse(struct soap*, _wcxs__AddWirelessProfileResponse*); +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse * SOAP_FMAC4 soap_instantiate__wcxs__AddWirelessProfileResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__AddWirelessProfileResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__AddWirelessProfileRequest +#define SOAP_TYPE__wcxs__AddWirelessProfileRequest (529) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__AddWirelessProfileRequest(struct soap*, const char*, int, const _wcxs__AddWirelessProfileRequest *, const char*); +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest * SOAP_FMAC4 soap_get__wcxs__AddWirelessProfileRequest(struct soap*, _wcxs__AddWirelessProfileRequest *, const char*, const char*); +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest * SOAP_FMAC4 soap_in__wcxs__AddWirelessProfileRequest(struct soap*, const char*, _wcxs__AddWirelessProfileRequest *, const char*); +SOAP_FMAC5 _wcxs__AddWirelessProfileRequest * SOAP_FMAC6 soap_new__wcxs__AddWirelessProfileRequest(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__AddWirelessProfileRequest(struct soap*, _wcxs__AddWirelessProfileRequest*); +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest * SOAP_FMAC4 soap_instantiate__wcxs__AddWirelessProfileRequest(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__AddWirelessProfileRequest(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__WirelessSettingsType +#define SOAP_TYPE_wcxs__WirelessSettingsType (528) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__WirelessSettingsType(struct soap*, const char*, int, const wcxs__WirelessSettingsType *, const char*); +SOAP_FMAC3 wcxs__WirelessSettingsType * SOAP_FMAC4 soap_get_wcxs__WirelessSettingsType(struct soap*, wcxs__WirelessSettingsType *, const char*, const char*); +SOAP_FMAC3 wcxs__WirelessSettingsType * SOAP_FMAC4 soap_in_wcxs__WirelessSettingsType(struct soap*, const char*, wcxs__WirelessSettingsType *, const char*); +SOAP_FMAC5 wcxs__WirelessSettingsType * SOAP_FMAC6 soap_new_wcxs__WirelessSettingsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__WirelessSettingsType(struct soap*, wcxs__WirelessSettingsType*); +SOAP_FMAC3 wcxs__WirelessSettingsType * SOAP_FMAC4 soap_instantiate_wcxs__WirelessSettingsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__WirelessSettingsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__WirelessCapabilitiesType +#define SOAP_TYPE_wcxs__WirelessCapabilitiesType (527) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__WirelessCapabilitiesType(struct soap*, const char*, int, const wcxs__WirelessCapabilitiesType *, const char*); +SOAP_FMAC3 wcxs__WirelessCapabilitiesType * SOAP_FMAC4 soap_get_wcxs__WirelessCapabilitiesType(struct soap*, wcxs__WirelessCapabilitiesType *, const char*, const char*); +SOAP_FMAC3 wcxs__WirelessCapabilitiesType * SOAP_FMAC4 soap_in_wcxs__WirelessCapabilitiesType(struct soap*, const char*, wcxs__WirelessCapabilitiesType *, const char*); +SOAP_FMAC5 wcxs__WirelessCapabilitiesType * SOAP_FMAC6 soap_new_wcxs__WirelessCapabilitiesType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__WirelessCapabilitiesType(struct soap*, wcxs__WirelessCapabilitiesType*); +SOAP_FMAC3 wcxs__WirelessCapabilitiesType * SOAP_FMAC4 soap_instantiate_wcxs__WirelessCapabilitiesType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__WirelessCapabilitiesType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__ProfileType +#define SOAP_TYPE_wcxs__ProfileType (526) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileType(struct soap*, const char*, int, const wcxs__ProfileType *, const char*); +SOAP_FMAC3 wcxs__ProfileType * SOAP_FMAC4 soap_get_wcxs__ProfileType(struct soap*, wcxs__ProfileType *, const char*, const char*); +SOAP_FMAC3 wcxs__ProfileType * SOAP_FMAC4 soap_in_wcxs__ProfileType(struct soap*, const char*, wcxs__ProfileType *, const char*); +SOAP_FMAC5 wcxs__ProfileType * SOAP_FMAC6 soap_new_wcxs__ProfileType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileType(struct soap*, wcxs__ProfileType*); +SOAP_FMAC3 wcxs__ProfileType * SOAP_FMAC4 soap_instantiate_wcxs__ProfileType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__ProfileSecuritySettingsType +#define SOAP_TYPE_wcxs__ProfileSecuritySettingsType (525) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileSecuritySettingsType(struct soap*, const char*, int, const wcxs__ProfileSecuritySettingsType *, const char*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType * SOAP_FMAC4 soap_get_wcxs__ProfileSecuritySettingsType(struct soap*, wcxs__ProfileSecuritySettingsType *, const char*, const char*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType * SOAP_FMAC4 soap_in_wcxs__ProfileSecuritySettingsType(struct soap*, const char*, wcxs__ProfileSecuritySettingsType *, const char*); +SOAP_FMAC5 wcxs__ProfileSecuritySettingsType * SOAP_FMAC6 soap_new_wcxs__ProfileSecuritySettingsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileSecuritySettingsType(struct soap*, wcxs__ProfileSecuritySettingsType*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType * SOAP_FMAC4 soap_instantiate_wcxs__ProfileSecuritySettingsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileSecuritySettingsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType +#define SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType (524) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileSecuritySettingRSNType(struct soap*, const char*, int, const wcxs__ProfileSecuritySettingRSNType *, const char*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType * SOAP_FMAC4 soap_get_wcxs__ProfileSecuritySettingRSNType(struct soap*, wcxs__ProfileSecuritySettingRSNType *, const char*, const char*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType * SOAP_FMAC4 soap_in_wcxs__ProfileSecuritySettingRSNType(struct soap*, const char*, wcxs__ProfileSecuritySettingRSNType *, const char*); +SOAP_FMAC5 wcxs__ProfileSecuritySettingRSNType * SOAP_FMAC6 soap_new_wcxs__ProfileSecuritySettingRSNType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileSecuritySettingRSNType(struct soap*, wcxs__ProfileSecuritySettingRSNType*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType * SOAP_FMAC4 soap_instantiate_wcxs__ProfileSecuritySettingRSNType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileSecuritySettingRSNType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType +#define SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType (523) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileSecuritySettingWPAType(struct soap*, const char*, int, const wcxs__ProfileSecuritySettingWPAType *, const char*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType * SOAP_FMAC4 soap_get_wcxs__ProfileSecuritySettingWPAType(struct soap*, wcxs__ProfileSecuritySettingWPAType *, const char*, const char*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType * SOAP_FMAC4 soap_in_wcxs__ProfileSecuritySettingWPAType(struct soap*, const char*, wcxs__ProfileSecuritySettingWPAType *, const char*); +SOAP_FMAC5 wcxs__ProfileSecuritySettingWPAType * SOAP_FMAC6 soap_new_wcxs__ProfileSecuritySettingWPAType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileSecuritySettingWPAType(struct soap*, wcxs__ProfileSecuritySettingWPAType*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType * SOAP_FMAC4 soap_instantiate_wcxs__ProfileSecuritySettingWPAType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileSecuritySettingWPAType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__DataEncryptionCCMPType +#define SOAP_TYPE_wcxs__DataEncryptionCCMPType (522) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__DataEncryptionCCMPType(struct soap*, const char*, int, const wcxs__DataEncryptionCCMPType *, const char*); +SOAP_FMAC3 wcxs__DataEncryptionCCMPType * SOAP_FMAC4 soap_get_wcxs__DataEncryptionCCMPType(struct soap*, wcxs__DataEncryptionCCMPType *, const char*, const char*); +SOAP_FMAC3 wcxs__DataEncryptionCCMPType * SOAP_FMAC4 soap_in_wcxs__DataEncryptionCCMPType(struct soap*, const char*, wcxs__DataEncryptionCCMPType *, const char*); +SOAP_FMAC5 wcxs__DataEncryptionCCMPType * SOAP_FMAC6 soap_new_wcxs__DataEncryptionCCMPType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__DataEncryptionCCMPType(struct soap*, wcxs__DataEncryptionCCMPType*); +SOAP_FMAC3 wcxs__DataEncryptionCCMPType * SOAP_FMAC4 soap_instantiate_wcxs__DataEncryptionCCMPType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__DataEncryptionCCMPType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__DataEncryptionTKIPType +#define SOAP_TYPE_wcxs__DataEncryptionTKIPType (521) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__DataEncryptionTKIPType(struct soap*, const char*, int, const wcxs__DataEncryptionTKIPType *, const char*); +SOAP_FMAC3 wcxs__DataEncryptionTKIPType * SOAP_FMAC4 soap_get_wcxs__DataEncryptionTKIPType(struct soap*, wcxs__DataEncryptionTKIPType *, const char*, const char*); +SOAP_FMAC3 wcxs__DataEncryptionTKIPType * SOAP_FMAC4 soap_in_wcxs__DataEncryptionTKIPType(struct soap*, const char*, wcxs__DataEncryptionTKIPType *, const char*); +SOAP_FMAC5 wcxs__DataEncryptionTKIPType * SOAP_FMAC6 soap_new_wcxs__DataEncryptionTKIPType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__DataEncryptionTKIPType(struct soap*, wcxs__DataEncryptionTKIPType*); +SOAP_FMAC3 wcxs__DataEncryptionTKIPType * SOAP_FMAC4 soap_instantiate_wcxs__DataEncryptionTKIPType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__DataEncryptionTKIPType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__DataEncryptionWEPType +#define SOAP_TYPE_wcxs__DataEncryptionWEPType (520) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__DataEncryptionWEPType(struct soap*, const char*, int, const wcxs__DataEncryptionWEPType *, const char*); +SOAP_FMAC3 wcxs__DataEncryptionWEPType * SOAP_FMAC4 soap_get_wcxs__DataEncryptionWEPType(struct soap*, wcxs__DataEncryptionWEPType *, const char*, const char*); +SOAP_FMAC3 wcxs__DataEncryptionWEPType * SOAP_FMAC4 soap_in_wcxs__DataEncryptionWEPType(struct soap*, const char*, wcxs__DataEncryptionWEPType *, const char*); +SOAP_FMAC5 wcxs__DataEncryptionWEPType * SOAP_FMAC6 soap_new_wcxs__DataEncryptionWEPType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__DataEncryptionWEPType(struct soap*, wcxs__DataEncryptionWEPType*); +SOAP_FMAC3 wcxs__DataEncryptionWEPType * SOAP_FMAC4 soap_instantiate_wcxs__DataEncryptionWEPType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__DataEncryptionWEPType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__DataEncryptionWEPXType +#define SOAP_TYPE_wcxs__DataEncryptionWEPXType (519) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__DataEncryptionWEPXType(struct soap*, const char*, int, const wcxs__DataEncryptionWEPXType *, const char*); +SOAP_FMAC3 wcxs__DataEncryptionWEPXType * SOAP_FMAC4 soap_get_wcxs__DataEncryptionWEPXType(struct soap*, wcxs__DataEncryptionWEPXType *, const char*, const char*); +SOAP_FMAC3 wcxs__DataEncryptionWEPXType * SOAP_FMAC4 soap_in_wcxs__DataEncryptionWEPXType(struct soap*, const char*, wcxs__DataEncryptionWEPXType *, const char*); +SOAP_FMAC5 wcxs__DataEncryptionWEPXType * SOAP_FMAC6 soap_new_wcxs__DataEncryptionWEPXType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__DataEncryptionWEPXType(struct soap*, wcxs__DataEncryptionWEPXType*); +SOAP_FMAC3 wcxs__DataEncryptionWEPXType * SOAP_FMAC4 soap_instantiate_wcxs__DataEncryptionWEPXType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__DataEncryptionWEPXType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__WEP128Type +#define SOAP_TYPE_wcxs__WEP128Type (518) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__WEP128Type(struct soap*, const char*, int, const wcxs__WEP128Type *, const char*); +SOAP_FMAC3 wcxs__WEP128Type * SOAP_FMAC4 soap_get_wcxs__WEP128Type(struct soap*, wcxs__WEP128Type *, const char*, const char*); +SOAP_FMAC3 wcxs__WEP128Type * SOAP_FMAC4 soap_in_wcxs__WEP128Type(struct soap*, const char*, wcxs__WEP128Type *, const char*); +SOAP_FMAC5 wcxs__WEP128Type * SOAP_FMAC6 soap_new_wcxs__WEP128Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__WEP128Type(struct soap*, wcxs__WEP128Type*); +SOAP_FMAC3 wcxs__WEP128Type * SOAP_FMAC4 soap_instantiate_wcxs__WEP128Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__WEP128Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_wcxs__WEP64Type +#define SOAP_TYPE_wcxs__WEP64Type (517) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__WEP64Type(struct soap*, const char*, int, const wcxs__WEP64Type *, const char*); +SOAP_FMAC3 wcxs__WEP64Type * SOAP_FMAC4 soap_get_wcxs__WEP64Type(struct soap*, wcxs__WEP64Type *, const char*, const char*); +SOAP_FMAC3 wcxs__WEP64Type * SOAP_FMAC4 soap_in_wcxs__WEP64Type(struct soap*, const char*, wcxs__WEP64Type *, const char*); +SOAP_FMAC5 wcxs__WEP64Type * SOAP_FMAC6 soap_new_wcxs__WEP64Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__WEP64Type(struct soap*, wcxs__WEP64Type*); +SOAP_FMAC3 wcxs__WEP64Type * SOAP_FMAC4 soap_instantiate_wcxs__WEP64Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__WEP64Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__rci__GetSystemPowerStateResponse +#define SOAP_TYPE__rci__GetSystemPowerStateResponse (516) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__GetSystemPowerStateResponse(struct soap*, const char*, int, const _rci__GetSystemPowerStateResponse *, const char*); +SOAP_FMAC3 _rci__GetSystemPowerStateResponse * SOAP_FMAC4 soap_get__rci__GetSystemPowerStateResponse(struct soap*, _rci__GetSystemPowerStateResponse *, const char*, const char*); +SOAP_FMAC3 _rci__GetSystemPowerStateResponse * SOAP_FMAC4 soap_in__rci__GetSystemPowerStateResponse(struct soap*, const char*, _rci__GetSystemPowerStateResponse *, const char*); +SOAP_FMAC5 _rci__GetSystemPowerStateResponse * SOAP_FMAC6 soap_new__rci__GetSystemPowerStateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__GetSystemPowerStateResponse(struct soap*, _rci__GetSystemPowerStateResponse*); +SOAP_FMAC3 _rci__GetSystemPowerStateResponse * SOAP_FMAC4 soap_instantiate__rci__GetSystemPowerStateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__GetSystemPowerStateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__rci__GetSystemPowerState +#define SOAP_TYPE__rci__GetSystemPowerState (515) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__GetSystemPowerState(struct soap*, const char*, int, const _rci__GetSystemPowerState *, const char*); +SOAP_FMAC3 _rci__GetSystemPowerState * SOAP_FMAC4 soap_get__rci__GetSystemPowerState(struct soap*, _rci__GetSystemPowerState *, const char*, const char*); +SOAP_FMAC3 _rci__GetSystemPowerState * SOAP_FMAC4 soap_in__rci__GetSystemPowerState(struct soap*, const char*, _rci__GetSystemPowerState *, const char*); +SOAP_FMAC5 _rci__GetSystemPowerState * SOAP_FMAC6 soap_new__rci__GetSystemPowerState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__GetSystemPowerState(struct soap*, _rci__GetSystemPowerState*); +SOAP_FMAC3 _rci__GetSystemPowerState * SOAP_FMAC4 soap_instantiate__rci__GetSystemPowerState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__GetSystemPowerState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__rci__RemoteControlResponse +#define SOAP_TYPE__rci__RemoteControlResponse (514) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__RemoteControlResponse(struct soap*, const char*, int, const _rci__RemoteControlResponse *, const char*); +SOAP_FMAC3 _rci__RemoteControlResponse * SOAP_FMAC4 soap_get__rci__RemoteControlResponse(struct soap*, _rci__RemoteControlResponse *, const char*, const char*); +SOAP_FMAC3 _rci__RemoteControlResponse * SOAP_FMAC4 soap_in__rci__RemoteControlResponse(struct soap*, const char*, _rci__RemoteControlResponse *, const char*); +SOAP_FMAC5 _rci__RemoteControlResponse * SOAP_FMAC6 soap_new__rci__RemoteControlResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__RemoteControlResponse(struct soap*, _rci__RemoteControlResponse*); +SOAP_FMAC3 _rci__RemoteControlResponse * SOAP_FMAC4 soap_instantiate__rci__RemoteControlResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__RemoteControlResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__rci__RemoteControl +#define SOAP_TYPE__rci__RemoteControl (513) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__RemoteControl(struct soap*, const char*, int, const _rci__RemoteControl *, const char*); +SOAP_FMAC3 _rci__RemoteControl * SOAP_FMAC4 soap_get__rci__RemoteControl(struct soap*, _rci__RemoteControl *, const char*, const char*); +SOAP_FMAC3 _rci__RemoteControl * SOAP_FMAC4 soap_in__rci__RemoteControl(struct soap*, const char*, _rci__RemoteControl *, const char*); +SOAP_FMAC5 _rci__RemoteControl * SOAP_FMAC6 soap_new__rci__RemoteControl(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__RemoteControl(struct soap*, _rci__RemoteControl*); +SOAP_FMAC3 _rci__RemoteControl * SOAP_FMAC4 soap_instantiate__rci__RemoteControl(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__RemoteControl(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse +#define SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse (512) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__GetRemoteControlCapabilitiesResponse(struct soap*, const char*, int, const _rci__GetRemoteControlCapabilitiesResponse *, const char*); +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse * SOAP_FMAC4 soap_get__rci__GetRemoteControlCapabilitiesResponse(struct soap*, _rci__GetRemoteControlCapabilitiesResponse *, const char*, const char*); +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse * SOAP_FMAC4 soap_in__rci__GetRemoteControlCapabilitiesResponse(struct soap*, const char*, _rci__GetRemoteControlCapabilitiesResponse *, const char*); +SOAP_FMAC5 _rci__GetRemoteControlCapabilitiesResponse * SOAP_FMAC6 soap_new__rci__GetRemoteControlCapabilitiesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__GetRemoteControlCapabilitiesResponse(struct soap*, _rci__GetRemoteControlCapabilitiesResponse*); +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__rci__GetRemoteControlCapabilitiesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__GetRemoteControlCapabilitiesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__rci__GetRemoteControlCapabilities +#define SOAP_TYPE__rci__GetRemoteControlCapabilities (511) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__GetRemoteControlCapabilities(struct soap*, const char*, int, const _rci__GetRemoteControlCapabilities *, const char*); +SOAP_FMAC3 _rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_get__rci__GetRemoteControlCapabilities(struct soap*, _rci__GetRemoteControlCapabilities *, const char*, const char*); +SOAP_FMAC3 _rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_in__rci__GetRemoteControlCapabilities(struct soap*, const char*, _rci__GetRemoteControlCapabilities *, const char*); +SOAP_FMAC5 _rci__GetRemoteControlCapabilities * SOAP_FMAC6 soap_new__rci__GetRemoteControlCapabilities(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__GetRemoteControlCapabilities(struct soap*, _rci__GetRemoteControlCapabilities*); +SOAP_FMAC3 _rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_instantiate__rci__GetRemoteControlCapabilities(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__GetRemoteControlCapabilities(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetIderSessionLogResponse +#define SOAP_TYPE__inf__GetIderSessionLogResponse (510) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetIderSessionLogResponse(struct soap*, const char*, int, const _inf__GetIderSessionLogResponse *, const char*); +SOAP_FMAC3 _inf__GetIderSessionLogResponse * SOAP_FMAC4 soap_get__inf__GetIderSessionLogResponse(struct soap*, _inf__GetIderSessionLogResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetIderSessionLogResponse * SOAP_FMAC4 soap_in__inf__GetIderSessionLogResponse(struct soap*, const char*, _inf__GetIderSessionLogResponse *, const char*); +SOAP_FMAC5 _inf__GetIderSessionLogResponse * SOAP_FMAC6 soap_new__inf__GetIderSessionLogResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetIderSessionLogResponse(struct soap*, _inf__GetIderSessionLogResponse*); +SOAP_FMAC3 _inf__GetIderSessionLogResponse * SOAP_FMAC4 soap_instantiate__inf__GetIderSessionLogResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetIderSessionLogResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetIderSessionLog +#define SOAP_TYPE__inf__GetIderSessionLog (509) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetIderSessionLog(struct soap*, const char*, int, const _inf__GetIderSessionLog *, const char*); +SOAP_FMAC3 _inf__GetIderSessionLog * SOAP_FMAC4 soap_get__inf__GetIderSessionLog(struct soap*, _inf__GetIderSessionLog *, const char*, const char*); +SOAP_FMAC3 _inf__GetIderSessionLog * SOAP_FMAC4 soap_in__inf__GetIderSessionLog(struct soap*, const char*, _inf__GetIderSessionLog *, const char*); +SOAP_FMAC5 _inf__GetIderSessionLog * SOAP_FMAC6 soap_new__inf__GetIderSessionLog(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetIderSessionLog(struct soap*, _inf__GetIderSessionLog*); +SOAP_FMAC3 _inf__GetIderSessionLog * SOAP_FMAC4 soap_instantiate__inf__GetIderSessionLog(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetIderSessionLog(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetSecurityParametersResponse +#define SOAP_TYPE__inf__GetSecurityParametersResponse (508) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetSecurityParametersResponse(struct soap*, const char*, int, const _inf__GetSecurityParametersResponse *, const char*); +SOAP_FMAC3 _inf__GetSecurityParametersResponse * SOAP_FMAC4 soap_get__inf__GetSecurityParametersResponse(struct soap*, _inf__GetSecurityParametersResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetSecurityParametersResponse * SOAP_FMAC4 soap_in__inf__GetSecurityParametersResponse(struct soap*, const char*, _inf__GetSecurityParametersResponse *, const char*); +SOAP_FMAC5 _inf__GetSecurityParametersResponse * SOAP_FMAC6 soap_new__inf__GetSecurityParametersResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetSecurityParametersResponse(struct soap*, _inf__GetSecurityParametersResponse*); +SOAP_FMAC3 _inf__GetSecurityParametersResponse * SOAP_FMAC4 soap_instantiate__inf__GetSecurityParametersResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetSecurityParametersResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetSecurityParameters +#define SOAP_TYPE__inf__GetSecurityParameters (507) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetSecurityParameters(struct soap*, const char*, int, const _inf__GetSecurityParameters *, const char*); +SOAP_FMAC3 _inf__GetSecurityParameters * SOAP_FMAC4 soap_get__inf__GetSecurityParameters(struct soap*, _inf__GetSecurityParameters *, const char*, const char*); +SOAP_FMAC3 _inf__GetSecurityParameters * SOAP_FMAC4 soap_in__inf__GetSecurityParameters(struct soap*, const char*, _inf__GetSecurityParameters *, const char*); +SOAP_FMAC5 _inf__GetSecurityParameters * SOAP_FMAC6 soap_new__inf__GetSecurityParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetSecurityParameters(struct soap*, _inf__GetSecurityParameters*); +SOAP_FMAC3 _inf__GetSecurityParameters * SOAP_FMAC4 soap_instantiate__inf__GetSecurityParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetSecurityParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetNetworkStateResponse +#define SOAP_TYPE__inf__GetNetworkStateResponse (506) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetNetworkStateResponse(struct soap*, const char*, int, const _inf__GetNetworkStateResponse *, const char*); +SOAP_FMAC3 _inf__GetNetworkStateResponse * SOAP_FMAC4 soap_get__inf__GetNetworkStateResponse(struct soap*, _inf__GetNetworkStateResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetNetworkStateResponse * SOAP_FMAC4 soap_in__inf__GetNetworkStateResponse(struct soap*, const char*, _inf__GetNetworkStateResponse *, const char*); +SOAP_FMAC5 _inf__GetNetworkStateResponse * SOAP_FMAC6 soap_new__inf__GetNetworkStateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetNetworkStateResponse(struct soap*, _inf__GetNetworkStateResponse*); +SOAP_FMAC3 _inf__GetNetworkStateResponse * SOAP_FMAC4 soap_instantiate__inf__GetNetworkStateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetNetworkStateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetNetworkState +#define SOAP_TYPE__inf__GetNetworkState (505) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetNetworkState(struct soap*, const char*, int, const _inf__GetNetworkState *, const char*); +SOAP_FMAC3 _inf__GetNetworkState * SOAP_FMAC4 soap_get__inf__GetNetworkState(struct soap*, _inf__GetNetworkState *, const char*, const char*); +SOAP_FMAC3 _inf__GetNetworkState * SOAP_FMAC4 soap_in__inf__GetNetworkState(struct soap*, const char*, _inf__GetNetworkState *, const char*); +SOAP_FMAC5 _inf__GetNetworkState * SOAP_FMAC6 soap_new__inf__GetNetworkState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetNetworkState(struct soap*, _inf__GetNetworkState*); +SOAP_FMAC3 _inf__GetNetworkState * SOAP_FMAC4 soap_instantiate__inf__GetNetworkState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetNetworkState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetEnabledInterfacesResponse +#define SOAP_TYPE__inf__GetEnabledInterfacesResponse (504) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetEnabledInterfacesResponse(struct soap*, const char*, int, const _inf__GetEnabledInterfacesResponse *, const char*); +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_get__inf__GetEnabledInterfacesResponse(struct soap*, _inf__GetEnabledInterfacesResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_in__inf__GetEnabledInterfacesResponse(struct soap*, const char*, _inf__GetEnabledInterfacesResponse *, const char*); +SOAP_FMAC5 _inf__GetEnabledInterfacesResponse * SOAP_FMAC6 soap_new__inf__GetEnabledInterfacesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetEnabledInterfacesResponse(struct soap*, _inf__GetEnabledInterfacesResponse*); +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_instantiate__inf__GetEnabledInterfacesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetEnabledInterfacesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetEnabledInterfaces +#define SOAP_TYPE__inf__GetEnabledInterfaces (503) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetEnabledInterfaces(struct soap*, const char*, int, const _inf__GetEnabledInterfaces *, const char*); +SOAP_FMAC3 _inf__GetEnabledInterfaces * SOAP_FMAC4 soap_get__inf__GetEnabledInterfaces(struct soap*, _inf__GetEnabledInterfaces *, const char*, const char*); +SOAP_FMAC3 _inf__GetEnabledInterfaces * SOAP_FMAC4 soap_in__inf__GetEnabledInterfaces(struct soap*, const char*, _inf__GetEnabledInterfaces *, const char*); +SOAP_FMAC5 _inf__GetEnabledInterfaces * SOAP_FMAC6 soap_new__inf__GetEnabledInterfaces(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetEnabledInterfaces(struct soap*, _inf__GetEnabledInterfaces*); +SOAP_FMAC3 _inf__GetEnabledInterfaces * SOAP_FMAC4 soap_instantiate__inf__GetEnabledInterfaces(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetEnabledInterfaces(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetPasswordModelResponse +#define SOAP_TYPE__inf__GetPasswordModelResponse (502) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetPasswordModelResponse(struct soap*, const char*, int, const _inf__GetPasswordModelResponse *, const char*); +SOAP_FMAC3 _inf__GetPasswordModelResponse * SOAP_FMAC4 soap_get__inf__GetPasswordModelResponse(struct soap*, _inf__GetPasswordModelResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetPasswordModelResponse * SOAP_FMAC4 soap_in__inf__GetPasswordModelResponse(struct soap*, const char*, _inf__GetPasswordModelResponse *, const char*); +SOAP_FMAC5 _inf__GetPasswordModelResponse * SOAP_FMAC6 soap_new__inf__GetPasswordModelResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetPasswordModelResponse(struct soap*, _inf__GetPasswordModelResponse*); +SOAP_FMAC3 _inf__GetPasswordModelResponse * SOAP_FMAC4 soap_instantiate__inf__GetPasswordModelResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetPasswordModelResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetPasswordModel +#define SOAP_TYPE__inf__GetPasswordModel (501) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetPasswordModel(struct soap*, const char*, int, const _inf__GetPasswordModel *, const char*); +SOAP_FMAC3 _inf__GetPasswordModel * SOAP_FMAC4 soap_get__inf__GetPasswordModel(struct soap*, _inf__GetPasswordModel *, const char*, const char*); +SOAP_FMAC3 _inf__GetPasswordModel * SOAP_FMAC4 soap_in__inf__GetPasswordModel(struct soap*, const char*, _inf__GetPasswordModel *, const char*); +SOAP_FMAC5 _inf__GetPasswordModel * SOAP_FMAC6 soap_new__inf__GetPasswordModel(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetPasswordModel(struct soap*, _inf__GetPasswordModel*); +SOAP_FMAC3 _inf__GetPasswordModel * SOAP_FMAC4 soap_instantiate__inf__GetPasswordModel(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetPasswordModel(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse +#define SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse (500) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetAdminNetAclEntryStatusResponse(struct soap*, const char*, int, const _inf__GetAdminNetAclEntryStatusResponse *, const char*); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse * SOAP_FMAC4 soap_get__inf__GetAdminNetAclEntryStatusResponse(struct soap*, _inf__GetAdminNetAclEntryStatusResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse * SOAP_FMAC4 soap_in__inf__GetAdminNetAclEntryStatusResponse(struct soap*, const char*, _inf__GetAdminNetAclEntryStatusResponse *, const char*); +SOAP_FMAC5 _inf__GetAdminNetAclEntryStatusResponse * SOAP_FMAC6 soap_new__inf__GetAdminNetAclEntryStatusResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetAdminNetAclEntryStatusResponse(struct soap*, _inf__GetAdminNetAclEntryStatusResponse*); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse * SOAP_FMAC4 soap_instantiate__inf__GetAdminNetAclEntryStatusResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetAdminNetAclEntryStatusResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetAdminNetAclEntryStatus +#define SOAP_TYPE__inf__GetAdminNetAclEntryStatus (499) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetAdminNetAclEntryStatus(struct soap*, const char*, int, const _inf__GetAdminNetAclEntryStatus *, const char*); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_get__inf__GetAdminNetAclEntryStatus(struct soap*, _inf__GetAdminNetAclEntryStatus *, const char*, const char*); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_in__inf__GetAdminNetAclEntryStatus(struct soap*, const char*, _inf__GetAdminNetAclEntryStatus *, const char*); +SOAP_FMAC5 _inf__GetAdminNetAclEntryStatus * SOAP_FMAC6 soap_new__inf__GetAdminNetAclEntryStatus(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetAdminNetAclEntryStatus(struct soap*, _inf__GetAdminNetAclEntryStatus*); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_instantiate__inf__GetAdminNetAclEntryStatus(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetAdminNetAclEntryStatus(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetAdminAclEntryStatusResponse +#define SOAP_TYPE__inf__GetAdminAclEntryStatusResponse (498) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetAdminAclEntryStatusResponse(struct soap*, const char*, int, const _inf__GetAdminAclEntryStatusResponse *, const char*); +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse * SOAP_FMAC4 soap_get__inf__GetAdminAclEntryStatusResponse(struct soap*, _inf__GetAdminAclEntryStatusResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse * SOAP_FMAC4 soap_in__inf__GetAdminAclEntryStatusResponse(struct soap*, const char*, _inf__GetAdminAclEntryStatusResponse *, const char*); +SOAP_FMAC5 _inf__GetAdminAclEntryStatusResponse * SOAP_FMAC6 soap_new__inf__GetAdminAclEntryStatusResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetAdminAclEntryStatusResponse(struct soap*, _inf__GetAdminAclEntryStatusResponse*); +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse * SOAP_FMAC4 soap_instantiate__inf__GetAdminAclEntryStatusResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetAdminAclEntryStatusResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetAdminAclEntryStatus +#define SOAP_TYPE__inf__GetAdminAclEntryStatus (497) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetAdminAclEntryStatus(struct soap*, const char*, int, const _inf__GetAdminAclEntryStatus *, const char*); +SOAP_FMAC3 _inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_get__inf__GetAdminAclEntryStatus(struct soap*, _inf__GetAdminAclEntryStatus *, const char*, const char*); +SOAP_FMAC3 _inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_in__inf__GetAdminAclEntryStatus(struct soap*, const char*, _inf__GetAdminAclEntryStatus *, const char*); +SOAP_FMAC5 _inf__GetAdminAclEntryStatus * SOAP_FMAC6 soap_new__inf__GetAdminAclEntryStatus(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetAdminAclEntryStatus(struct soap*, _inf__GetAdminAclEntryStatus*); +SOAP_FMAC3 _inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_instantiate__inf__GetAdminAclEntryStatus(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetAdminAclEntryStatus(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetConfigServerInfoResponse +#define SOAP_TYPE__inf__GetConfigServerInfoResponse (496) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetConfigServerInfoResponse(struct soap*, const char*, int, const _inf__GetConfigServerInfoResponse *, const char*); +SOAP_FMAC3 _inf__GetConfigServerInfoResponse * SOAP_FMAC4 soap_get__inf__GetConfigServerInfoResponse(struct soap*, _inf__GetConfigServerInfoResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetConfigServerInfoResponse * SOAP_FMAC4 soap_in__inf__GetConfigServerInfoResponse(struct soap*, const char*, _inf__GetConfigServerInfoResponse *, const char*); +SOAP_FMAC5 _inf__GetConfigServerInfoResponse * SOAP_FMAC6 soap_new__inf__GetConfigServerInfoResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetConfigServerInfoResponse(struct soap*, _inf__GetConfigServerInfoResponse*); +SOAP_FMAC3 _inf__GetConfigServerInfoResponse * SOAP_FMAC4 soap_instantiate__inf__GetConfigServerInfoResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetConfigServerInfoResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetConfigServerInfo +#define SOAP_TYPE__inf__GetConfigServerInfo (495) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetConfigServerInfo(struct soap*, const char*, int, const _inf__GetConfigServerInfo *, const char*); +SOAP_FMAC3 _inf__GetConfigServerInfo * SOAP_FMAC4 soap_get__inf__GetConfigServerInfo(struct soap*, _inf__GetConfigServerInfo *, const char*, const char*); +SOAP_FMAC3 _inf__GetConfigServerInfo * SOAP_FMAC4 soap_in__inf__GetConfigServerInfo(struct soap*, const char*, _inf__GetConfigServerInfo *, const char*); +SOAP_FMAC5 _inf__GetConfigServerInfo * SOAP_FMAC6 soap_new__inf__GetConfigServerInfo(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetConfigServerInfo(struct soap*, _inf__GetConfigServerInfo*); +SOAP_FMAC3 _inf__GetConfigServerInfo * SOAP_FMAC4 soap_instantiate__inf__GetConfigServerInfo(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetConfigServerInfo(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetHostNameResponse +#define SOAP_TYPE__inf__GetHostNameResponse (494) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetHostNameResponse(struct soap*, const char*, int, const _inf__GetHostNameResponse *, const char*); +SOAP_FMAC3 _inf__GetHostNameResponse * SOAP_FMAC4 soap_get__inf__GetHostNameResponse(struct soap*, _inf__GetHostNameResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetHostNameResponse * SOAP_FMAC4 soap_in__inf__GetHostNameResponse(struct soap*, const char*, _inf__GetHostNameResponse *, const char*); +SOAP_FMAC5 _inf__GetHostNameResponse * SOAP_FMAC6 soap_new__inf__GetHostNameResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetHostNameResponse(struct soap*, _inf__GetHostNameResponse*); +SOAP_FMAC3 _inf__GetHostNameResponse * SOAP_FMAC4 soap_instantiate__inf__GetHostNameResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetHostNameResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetHostName +#define SOAP_TYPE__inf__GetHostName (493) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetHostName(struct soap*, const char*, int, const _inf__GetHostName *, const char*); +SOAP_FMAC3 _inf__GetHostName * SOAP_FMAC4 soap_get__inf__GetHostName(struct soap*, _inf__GetHostName *, const char*, const char*); +SOAP_FMAC3 _inf__GetHostName * SOAP_FMAC4 soap_in__inf__GetHostName(struct soap*, const char*, _inf__GetHostName *, const char*); +SOAP_FMAC5 _inf__GetHostName * SOAP_FMAC6 soap_new__inf__GetHostName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetHostName(struct soap*, _inf__GetHostName*); +SOAP_FMAC3 _inf__GetHostName * SOAP_FMAC4 soap_instantiate__inf__GetHostName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetHostName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetVlanParametersResponse +#define SOAP_TYPE__inf__GetVlanParametersResponse (492) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetVlanParametersResponse(struct soap*, const char*, int, const _inf__GetVlanParametersResponse *, const char*); +SOAP_FMAC3 _inf__GetVlanParametersResponse * SOAP_FMAC4 soap_get__inf__GetVlanParametersResponse(struct soap*, _inf__GetVlanParametersResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetVlanParametersResponse * SOAP_FMAC4 soap_in__inf__GetVlanParametersResponse(struct soap*, const char*, _inf__GetVlanParametersResponse *, const char*); +SOAP_FMAC5 _inf__GetVlanParametersResponse * SOAP_FMAC6 soap_new__inf__GetVlanParametersResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetVlanParametersResponse(struct soap*, _inf__GetVlanParametersResponse*); +SOAP_FMAC3 _inf__GetVlanParametersResponse * SOAP_FMAC4 soap_instantiate__inf__GetVlanParametersResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetVlanParametersResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetVlanParameters +#define SOAP_TYPE__inf__GetVlanParameters (491) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetVlanParameters(struct soap*, const char*, int, const _inf__GetVlanParameters *, const char*); +SOAP_FMAC3 _inf__GetVlanParameters * SOAP_FMAC4 soap_get__inf__GetVlanParameters(struct soap*, _inf__GetVlanParameters *, const char*, const char*); +SOAP_FMAC3 _inf__GetVlanParameters * SOAP_FMAC4 soap_in__inf__GetVlanParameters(struct soap*, const char*, _inf__GetVlanParameters *, const char*); +SOAP_FMAC5 _inf__GetVlanParameters * SOAP_FMAC6 soap_new__inf__GetVlanParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetVlanParameters(struct soap*, _inf__GetVlanParameters*); +SOAP_FMAC3 _inf__GetVlanParameters * SOAP_FMAC4 soap_instantiate__inf__GetVlanParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetVlanParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetProvisioningStateResponse +#define SOAP_TYPE__inf__GetProvisioningStateResponse (490) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetProvisioningStateResponse(struct soap*, const char*, int, const _inf__GetProvisioningStateResponse *, const char*); +SOAP_FMAC3 _inf__GetProvisioningStateResponse * SOAP_FMAC4 soap_get__inf__GetProvisioningStateResponse(struct soap*, _inf__GetProvisioningStateResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetProvisioningStateResponse * SOAP_FMAC4 soap_in__inf__GetProvisioningStateResponse(struct soap*, const char*, _inf__GetProvisioningStateResponse *, const char*); +SOAP_FMAC5 _inf__GetProvisioningStateResponse * SOAP_FMAC6 soap_new__inf__GetProvisioningStateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetProvisioningStateResponse(struct soap*, _inf__GetProvisioningStateResponse*); +SOAP_FMAC3 _inf__GetProvisioningStateResponse * SOAP_FMAC4 soap_instantiate__inf__GetProvisioningStateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetProvisioningStateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetProvisioningState +#define SOAP_TYPE__inf__GetProvisioningState (489) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetProvisioningState(struct soap*, const char*, int, const _inf__GetProvisioningState *, const char*); +SOAP_FMAC3 _inf__GetProvisioningState * SOAP_FMAC4 soap_get__inf__GetProvisioningState(struct soap*, _inf__GetProvisioningState *, const char*, const char*); +SOAP_FMAC3 _inf__GetProvisioningState * SOAP_FMAC4 soap_in__inf__GetProvisioningState(struct soap*, const char*, _inf__GetProvisioningState *, const char*); +SOAP_FMAC5 _inf__GetProvisioningState * SOAP_FMAC6 soap_new__inf__GetProvisioningState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetProvisioningState(struct soap*, _inf__GetProvisioningState*); +SOAP_FMAC3 _inf__GetProvisioningState * SOAP_FMAC4 soap_instantiate__inf__GetProvisioningState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetProvisioningState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetProvisioningModeResponse +#define SOAP_TYPE__inf__GetProvisioningModeResponse (488) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetProvisioningModeResponse(struct soap*, const char*, int, const _inf__GetProvisioningModeResponse *, const char*); +SOAP_FMAC3 _inf__GetProvisioningModeResponse * SOAP_FMAC4 soap_get__inf__GetProvisioningModeResponse(struct soap*, _inf__GetProvisioningModeResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetProvisioningModeResponse * SOAP_FMAC4 soap_in__inf__GetProvisioningModeResponse(struct soap*, const char*, _inf__GetProvisioningModeResponse *, const char*); +SOAP_FMAC5 _inf__GetProvisioningModeResponse * SOAP_FMAC6 soap_new__inf__GetProvisioningModeResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetProvisioningModeResponse(struct soap*, _inf__GetProvisioningModeResponse*); +SOAP_FMAC3 _inf__GetProvisioningModeResponse * SOAP_FMAC4 soap_instantiate__inf__GetProvisioningModeResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetProvisioningModeResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetProvisioningMode +#define SOAP_TYPE__inf__GetProvisioningMode (487) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetProvisioningMode(struct soap*, const char*, int, const _inf__GetProvisioningMode *, const char*); +SOAP_FMAC3 _inf__GetProvisioningMode * SOAP_FMAC4 soap_get__inf__GetProvisioningMode(struct soap*, _inf__GetProvisioningMode *, const char*, const char*); +SOAP_FMAC3 _inf__GetProvisioningMode * SOAP_FMAC4 soap_in__inf__GetProvisioningMode(struct soap*, const char*, _inf__GetProvisioningMode *, const char*); +SOAP_FMAC5 _inf__GetProvisioningMode * SOAP_FMAC6 soap_new__inf__GetProvisioningMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetProvisioningMode(struct soap*, _inf__GetProvisioningMode*); +SOAP_FMAC3 _inf__GetProvisioningMode * SOAP_FMAC4 soap_instantiate__inf__GetProvisioningMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetProvisioningMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetCodeVersionsResponse +#define SOAP_TYPE__inf__GetCodeVersionsResponse (486) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetCodeVersionsResponse(struct soap*, const char*, int, const _inf__GetCodeVersionsResponse *, const char*); +SOAP_FMAC3 _inf__GetCodeVersionsResponse * SOAP_FMAC4 soap_get__inf__GetCodeVersionsResponse(struct soap*, _inf__GetCodeVersionsResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetCodeVersionsResponse * SOAP_FMAC4 soap_in__inf__GetCodeVersionsResponse(struct soap*, const char*, _inf__GetCodeVersionsResponse *, const char*); +SOAP_FMAC5 _inf__GetCodeVersionsResponse * SOAP_FMAC6 soap_new__inf__GetCodeVersionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetCodeVersionsResponse(struct soap*, _inf__GetCodeVersionsResponse*); +SOAP_FMAC3 _inf__GetCodeVersionsResponse * SOAP_FMAC4 soap_instantiate__inf__GetCodeVersionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetCodeVersionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetCodeVersions +#define SOAP_TYPE__inf__GetCodeVersions (485) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetCodeVersions(struct soap*, const char*, int, const _inf__GetCodeVersions *, const char*); +SOAP_FMAC3 _inf__GetCodeVersions * SOAP_FMAC4 soap_get__inf__GetCodeVersions(struct soap*, _inf__GetCodeVersions *, const char*, const char*); +SOAP_FMAC3 _inf__GetCodeVersions * SOAP_FMAC4 soap_in__inf__GetCodeVersions(struct soap*, const char*, _inf__GetCodeVersions *, const char*); +SOAP_FMAC5 _inf__GetCodeVersions * SOAP_FMAC6 soap_new__inf__GetCodeVersions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetCodeVersions(struct soap*, _inf__GetCodeVersions*); +SOAP_FMAC3 _inf__GetCodeVersions * SOAP_FMAC4 soap_instantiate__inf__GetCodeVersions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetCodeVersions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetCoreVersionResponse +#define SOAP_TYPE__inf__GetCoreVersionResponse (484) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetCoreVersionResponse(struct soap*, const char*, int, const _inf__GetCoreVersionResponse *, const char*); +SOAP_FMAC3 _inf__GetCoreVersionResponse * SOAP_FMAC4 soap_get__inf__GetCoreVersionResponse(struct soap*, _inf__GetCoreVersionResponse *, const char*, const char*); +SOAP_FMAC3 _inf__GetCoreVersionResponse * SOAP_FMAC4 soap_in__inf__GetCoreVersionResponse(struct soap*, const char*, _inf__GetCoreVersionResponse *, const char*); +SOAP_FMAC5 _inf__GetCoreVersionResponse * SOAP_FMAC6 soap_new__inf__GetCoreVersionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetCoreVersionResponse(struct soap*, _inf__GetCoreVersionResponse*); +SOAP_FMAC3 _inf__GetCoreVersionResponse * SOAP_FMAC4 soap_instantiate__inf__GetCoreVersionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetCoreVersionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__inf__GetCoreVersion +#define SOAP_TYPE__inf__GetCoreVersion (483) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetCoreVersion(struct soap*, const char*, int, const _inf__GetCoreVersion *, const char*); +SOAP_FMAC3 _inf__GetCoreVersion * SOAP_FMAC4 soap_get__inf__GetCoreVersion(struct soap*, _inf__GetCoreVersion *, const char*, const char*); +SOAP_FMAC3 _inf__GetCoreVersion * SOAP_FMAC4 soap_in__inf__GetCoreVersion(struct soap*, const char*, _inf__GetCoreVersion *, const char*); +SOAP_FMAC5 _inf__GetCoreVersion * SOAP_FMAC6 soap_new__inf__GetCoreVersion(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetCoreVersion(struct soap*, _inf__GetCoreVersion*); +SOAP_FMAC3 _inf__GetCoreVersion * SOAP_FMAC4 soap_instantiate__inf__GetCoreVersion(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetCoreVersion(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_inf__FirmwareVersionType +#define SOAP_TYPE_inf__FirmwareVersionType (482) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__FirmwareVersionType(struct soap*, const char*, int, const inf__FirmwareVersionType *, const char*); +SOAP_FMAC3 inf__FirmwareVersionType * SOAP_FMAC4 soap_get_inf__FirmwareVersionType(struct soap*, inf__FirmwareVersionType *, const char*, const char*); +SOAP_FMAC3 inf__FirmwareVersionType * SOAP_FMAC4 soap_in_inf__FirmwareVersionType(struct soap*, const char*, inf__FirmwareVersionType *, const char*); +SOAP_FMAC5 inf__FirmwareVersionType * SOAP_FMAC6 soap_new_inf__FirmwareVersionType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_inf__FirmwareVersionType(struct soap*, inf__FirmwareVersionType*); +SOAP_FMAC3 inf__FirmwareVersionType * SOAP_FMAC4 soap_instantiate_inf__FirmwareVersionType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_inf__FirmwareVersionType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_inf__IderSessionLogEntryType +#define SOAP_TYPE_inf__IderSessionLogEntryType (481) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__IderSessionLogEntryType(struct soap*, const char*, int, const inf__IderSessionLogEntryType *, const char*); +SOAP_FMAC3 inf__IderSessionLogEntryType * SOAP_FMAC4 soap_get_inf__IderSessionLogEntryType(struct soap*, inf__IderSessionLogEntryType *, const char*, const char*); +SOAP_FMAC3 inf__IderSessionLogEntryType * SOAP_FMAC4 soap_in_inf__IderSessionLogEntryType(struct soap*, const char*, inf__IderSessionLogEntryType *, const char*); +SOAP_FMAC5 inf__IderSessionLogEntryType * SOAP_FMAC6 soap_new_inf__IderSessionLogEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_inf__IderSessionLogEntryType(struct soap*, inf__IderSessionLogEntryType*); +SOAP_FMAC3 inf__IderSessionLogEntryType * SOAP_FMAC4 soap_instantiate_inf__IderSessionLogEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_inf__IderSessionLogEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__str__ExecuteStorageOperationResponse +#define SOAP_TYPE__str__ExecuteStorageOperationResponse (480) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__str__ExecuteStorageOperationResponse(struct soap*, const char*, int, const _str__ExecuteStorageOperationResponse *, const char*); +SOAP_FMAC3 _str__ExecuteStorageOperationResponse * SOAP_FMAC4 soap_get__str__ExecuteStorageOperationResponse(struct soap*, _str__ExecuteStorageOperationResponse *, const char*, const char*); +SOAP_FMAC3 _str__ExecuteStorageOperationResponse * SOAP_FMAC4 soap_in__str__ExecuteStorageOperationResponse(struct soap*, const char*, _str__ExecuteStorageOperationResponse *, const char*); +SOAP_FMAC5 _str__ExecuteStorageOperationResponse * SOAP_FMAC6 soap_new__str__ExecuteStorageOperationResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__str__ExecuteStorageOperationResponse(struct soap*, _str__ExecuteStorageOperationResponse*); +SOAP_FMAC3 _str__ExecuteStorageOperationResponse * SOAP_FMAC4 soap_instantiate__str__ExecuteStorageOperationResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__str__ExecuteStorageOperationResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__str__ExecuteStorageOperation +#define SOAP_TYPE__str__ExecuteStorageOperation (479) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__str__ExecuteStorageOperation(struct soap*, const char*, int, const _str__ExecuteStorageOperation *, const char*); +SOAP_FMAC3 _str__ExecuteStorageOperation * SOAP_FMAC4 soap_get__str__ExecuteStorageOperation(struct soap*, _str__ExecuteStorageOperation *, const char*, const char*); +SOAP_FMAC3 _str__ExecuteStorageOperation * SOAP_FMAC4 soap_in__str__ExecuteStorageOperation(struct soap*, const char*, _str__ExecuteStorageOperation *, const char*); +SOAP_FMAC5 _str__ExecuteStorageOperation * SOAP_FMAC6 soap_new__str__ExecuteStorageOperation(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__str__ExecuteStorageOperation(struct soap*, _str__ExecuteStorageOperation*); +SOAP_FMAC3 _str__ExecuteStorageOperation * SOAP_FMAC4 soap_instantiate__str__ExecuteStorageOperation(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__str__ExecuteStorageOperation(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse +#define SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse (478) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__tim__SetHighAccuracyTimeSynchResponse(struct soap*, const char*, int, const _tim__SetHighAccuracyTimeSynchResponse *, const char*); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse * SOAP_FMAC4 soap_get__tim__SetHighAccuracyTimeSynchResponse(struct soap*, _tim__SetHighAccuracyTimeSynchResponse *, const char*, const char*); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse * SOAP_FMAC4 soap_in__tim__SetHighAccuracyTimeSynchResponse(struct soap*, const char*, _tim__SetHighAccuracyTimeSynchResponse *, const char*); +SOAP_FMAC5 _tim__SetHighAccuracyTimeSynchResponse * SOAP_FMAC6 soap_new__tim__SetHighAccuracyTimeSynchResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__tim__SetHighAccuracyTimeSynchResponse(struct soap*, _tim__SetHighAccuracyTimeSynchResponse*); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse * SOAP_FMAC4 soap_instantiate__tim__SetHighAccuracyTimeSynchResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__tim__SetHighAccuracyTimeSynchResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__tim__SetHighAccuracyTimeSynch +#define SOAP_TYPE__tim__SetHighAccuracyTimeSynch (477) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__tim__SetHighAccuracyTimeSynch(struct soap*, const char*, int, const _tim__SetHighAccuracyTimeSynch *, const char*); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_get__tim__SetHighAccuracyTimeSynch(struct soap*, _tim__SetHighAccuracyTimeSynch *, const char*, const char*); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_in__tim__SetHighAccuracyTimeSynch(struct soap*, const char*, _tim__SetHighAccuracyTimeSynch *, const char*); +SOAP_FMAC5 _tim__SetHighAccuracyTimeSynch * SOAP_FMAC6 soap_new__tim__SetHighAccuracyTimeSynch(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__tim__SetHighAccuracyTimeSynch(struct soap*, _tim__SetHighAccuracyTimeSynch*); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_instantiate__tim__SetHighAccuracyTimeSynch(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__tim__SetHighAccuracyTimeSynch(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse +#define SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse (476) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__tim__GetLowAccuracyTimeSynchResponse(struct soap*, const char*, int, const _tim__GetLowAccuracyTimeSynchResponse *, const char*); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse * SOAP_FMAC4 soap_get__tim__GetLowAccuracyTimeSynchResponse(struct soap*, _tim__GetLowAccuracyTimeSynchResponse *, const char*, const char*); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse * SOAP_FMAC4 soap_in__tim__GetLowAccuracyTimeSynchResponse(struct soap*, const char*, _tim__GetLowAccuracyTimeSynchResponse *, const char*); +SOAP_FMAC5 _tim__GetLowAccuracyTimeSynchResponse * SOAP_FMAC6 soap_new__tim__GetLowAccuracyTimeSynchResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__tim__GetLowAccuracyTimeSynchResponse(struct soap*, _tim__GetLowAccuracyTimeSynchResponse*); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse * SOAP_FMAC4 soap_instantiate__tim__GetLowAccuracyTimeSynchResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__tim__GetLowAccuracyTimeSynchResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__tim__GetLowAccuracyTimeSynch +#define SOAP_TYPE__tim__GetLowAccuracyTimeSynch (475) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__tim__GetLowAccuracyTimeSynch(struct soap*, const char*, int, const _tim__GetLowAccuracyTimeSynch *, const char*); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_get__tim__GetLowAccuracyTimeSynch(struct soap*, _tim__GetLowAccuracyTimeSynch *, const char*, const char*); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_in__tim__GetLowAccuracyTimeSynch(struct soap*, const char*, _tim__GetLowAccuracyTimeSynch *, const char*); +SOAP_FMAC5 _tim__GetLowAccuracyTimeSynch * SOAP_FMAC6 soap_new__tim__GetLowAccuracyTimeSynch(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__tim__GetLowAccuracyTimeSynch(struct soap*, _tim__GetLowAccuracyTimeSynch*); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_instantiate__tim__GetLowAccuracyTimeSynch(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__tim__GetLowAccuracyTimeSynch(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__idr__GetIderSessionLogResponse +#define SOAP_TYPE__idr__GetIderSessionLogResponse (474) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__GetIderSessionLogResponse(struct soap*, const char*, int, const _idr__GetIderSessionLogResponse *, const char*); +SOAP_FMAC3 _idr__GetIderSessionLogResponse * SOAP_FMAC4 soap_get__idr__GetIderSessionLogResponse(struct soap*, _idr__GetIderSessionLogResponse *, const char*, const char*); +SOAP_FMAC3 _idr__GetIderSessionLogResponse * SOAP_FMAC4 soap_in__idr__GetIderSessionLogResponse(struct soap*, const char*, _idr__GetIderSessionLogResponse *, const char*); +SOAP_FMAC5 _idr__GetIderSessionLogResponse * SOAP_FMAC6 soap_new__idr__GetIderSessionLogResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__GetIderSessionLogResponse(struct soap*, _idr__GetIderSessionLogResponse*); +SOAP_FMAC3 _idr__GetIderSessionLogResponse * SOAP_FMAC4 soap_instantiate__idr__GetIderSessionLogResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__GetIderSessionLogResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__idr__GetIderSessionLog +#define SOAP_TYPE__idr__GetIderSessionLog (473) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__GetIderSessionLog(struct soap*, const char*, int, const _idr__GetIderSessionLog *, const char*); +SOAP_FMAC3 _idr__GetIderSessionLog * SOAP_FMAC4 soap_get__idr__GetIderSessionLog(struct soap*, _idr__GetIderSessionLog *, const char*, const char*); +SOAP_FMAC3 _idr__GetIderSessionLog * SOAP_FMAC4 soap_in__idr__GetIderSessionLog(struct soap*, const char*, _idr__GetIderSessionLog *, const char*); +SOAP_FMAC5 _idr__GetIderSessionLog * SOAP_FMAC6 soap_new__idr__GetIderSessionLog(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__GetIderSessionLog(struct soap*, _idr__GetIderSessionLog*); +SOAP_FMAC3 _idr__GetIderSessionLog * SOAP_FMAC4 soap_instantiate__idr__GetIderSessionLog(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__GetIderSessionLog(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__idr__GetRedirectionListenerStateResponse +#define SOAP_TYPE__idr__GetRedirectionListenerStateResponse (472) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__GetRedirectionListenerStateResponse(struct soap*, const char*, int, const _idr__GetRedirectionListenerStateResponse *, const char*); +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse * SOAP_FMAC4 soap_get__idr__GetRedirectionListenerStateResponse(struct soap*, _idr__GetRedirectionListenerStateResponse *, const char*, const char*); +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse * SOAP_FMAC4 soap_in__idr__GetRedirectionListenerStateResponse(struct soap*, const char*, _idr__GetRedirectionListenerStateResponse *, const char*); +SOAP_FMAC5 _idr__GetRedirectionListenerStateResponse * SOAP_FMAC6 soap_new__idr__GetRedirectionListenerStateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__GetRedirectionListenerStateResponse(struct soap*, _idr__GetRedirectionListenerStateResponse*); +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse * SOAP_FMAC4 soap_instantiate__idr__GetRedirectionListenerStateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__GetRedirectionListenerStateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__idr__GetRedirectionListenerState +#define SOAP_TYPE__idr__GetRedirectionListenerState (471) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__GetRedirectionListenerState(struct soap*, const char*, int, const _idr__GetRedirectionListenerState *, const char*); +SOAP_FMAC3 _idr__GetRedirectionListenerState * SOAP_FMAC4 soap_get__idr__GetRedirectionListenerState(struct soap*, _idr__GetRedirectionListenerState *, const char*, const char*); +SOAP_FMAC3 _idr__GetRedirectionListenerState * SOAP_FMAC4 soap_in__idr__GetRedirectionListenerState(struct soap*, const char*, _idr__GetRedirectionListenerState *, const char*); +SOAP_FMAC5 _idr__GetRedirectionListenerState * SOAP_FMAC6 soap_new__idr__GetRedirectionListenerState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__GetRedirectionListenerState(struct soap*, _idr__GetRedirectionListenerState*); +SOAP_FMAC3 _idr__GetRedirectionListenerState * SOAP_FMAC4 soap_instantiate__idr__GetRedirectionListenerState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__GetRedirectionListenerState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__idr__SetRedirectionListenerStateResponse +#define SOAP_TYPE__idr__SetRedirectionListenerStateResponse (470) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__SetRedirectionListenerStateResponse(struct soap*, const char*, int, const _idr__SetRedirectionListenerStateResponse *, const char*); +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse * SOAP_FMAC4 soap_get__idr__SetRedirectionListenerStateResponse(struct soap*, _idr__SetRedirectionListenerStateResponse *, const char*, const char*); +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse * SOAP_FMAC4 soap_in__idr__SetRedirectionListenerStateResponse(struct soap*, const char*, _idr__SetRedirectionListenerStateResponse *, const char*); +SOAP_FMAC5 _idr__SetRedirectionListenerStateResponse * SOAP_FMAC6 soap_new__idr__SetRedirectionListenerStateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__SetRedirectionListenerStateResponse(struct soap*, _idr__SetRedirectionListenerStateResponse*); +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse * SOAP_FMAC4 soap_instantiate__idr__SetRedirectionListenerStateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__SetRedirectionListenerStateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__idr__SetRedirectionListenerState +#define SOAP_TYPE__idr__SetRedirectionListenerState (469) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__SetRedirectionListenerState(struct soap*, const char*, int, const _idr__SetRedirectionListenerState *, const char*); +SOAP_FMAC3 _idr__SetRedirectionListenerState * SOAP_FMAC4 soap_get__idr__SetRedirectionListenerState(struct soap*, _idr__SetRedirectionListenerState *, const char*, const char*); +SOAP_FMAC3 _idr__SetRedirectionListenerState * SOAP_FMAC4 soap_in__idr__SetRedirectionListenerState(struct soap*, const char*, _idr__SetRedirectionListenerState *, const char*); +SOAP_FMAC5 _idr__SetRedirectionListenerState * SOAP_FMAC6 soap_new__idr__SetRedirectionListenerState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__SetRedirectionListenerState(struct soap*, _idr__SetRedirectionListenerState*); +SOAP_FMAC3 _idr__SetRedirectionListenerState * SOAP_FMAC4 soap_instantiate__idr__SetRedirectionListenerState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__SetRedirectionListenerState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_idr__FirmwareVersionType +#define SOAP_TYPE_idr__FirmwareVersionType (468) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__FirmwareVersionType(struct soap*, const char*, int, const idr__FirmwareVersionType *, const char*); +SOAP_FMAC3 idr__FirmwareVersionType * SOAP_FMAC4 soap_get_idr__FirmwareVersionType(struct soap*, idr__FirmwareVersionType *, const char*, const char*); +SOAP_FMAC3 idr__FirmwareVersionType * SOAP_FMAC4 soap_in_idr__FirmwareVersionType(struct soap*, const char*, idr__FirmwareVersionType *, const char*); +SOAP_FMAC5 idr__FirmwareVersionType * SOAP_FMAC6 soap_new_idr__FirmwareVersionType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_idr__FirmwareVersionType(struct soap*, idr__FirmwareVersionType*); +SOAP_FMAC3 idr__FirmwareVersionType * SOAP_FMAC4 soap_instantiate_idr__FirmwareVersionType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_idr__FirmwareVersionType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_idr__IderSessionLogEntryType +#define SOAP_TYPE_idr__IderSessionLogEntryType (467) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__IderSessionLogEntryType(struct soap*, const char*, int, const idr__IderSessionLogEntryType *, const char*); +SOAP_FMAC3 idr__IderSessionLogEntryType * SOAP_FMAC4 soap_get_idr__IderSessionLogEntryType(struct soap*, idr__IderSessionLogEntryType *, const char*, const char*); +SOAP_FMAC3 idr__IderSessionLogEntryType * SOAP_FMAC4 soap_in_idr__IderSessionLogEntryType(struct soap*, const char*, idr__IderSessionLogEntryType *, const char*); +SOAP_FMAC5 idr__IderSessionLogEntryType * SOAP_FMAC6 soap_new_idr__IderSessionLogEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_idr__IderSessionLogEntryType(struct soap*, idr__IderSessionLogEntryType*); +SOAP_FMAC3 idr__IderSessionLogEntryType * SOAP_FMAC4 soap_instantiate_idr__IderSessionLogEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_idr__IderSessionLogEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apl__AgentWatchdogShutdownResponse +#define SOAP_TYPE__apl__AgentWatchdogShutdownResponse (466) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogShutdownResponse(struct soap*, const char*, int, const _apl__AgentWatchdogShutdownResponse *, const char*); +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse * SOAP_FMAC4 soap_get__apl__AgentWatchdogShutdownResponse(struct soap*, _apl__AgentWatchdogShutdownResponse *, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse * SOAP_FMAC4 soap_in__apl__AgentWatchdogShutdownResponse(struct soap*, const char*, _apl__AgentWatchdogShutdownResponse *, const char*); +SOAP_FMAC5 _apl__AgentWatchdogShutdownResponse * SOAP_FMAC6 soap_new__apl__AgentWatchdogShutdownResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogShutdownResponse(struct soap*, _apl__AgentWatchdogShutdownResponse*); +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogShutdownResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogShutdownResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apl__AgentWatchdogShutdown +#define SOAP_TYPE__apl__AgentWatchdogShutdown (465) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogShutdown(struct soap*, const char*, int, const _apl__AgentWatchdogShutdown *, const char*); +SOAP_FMAC3 _apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_get__apl__AgentWatchdogShutdown(struct soap*, _apl__AgentWatchdogShutdown *, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_in__apl__AgentWatchdogShutdown(struct soap*, const char*, _apl__AgentWatchdogShutdown *, const char*); +SOAP_FMAC5 _apl__AgentWatchdogShutdown * SOAP_FMAC6 soap_new__apl__AgentWatchdogShutdown(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogShutdown(struct soap*, _apl__AgentWatchdogShutdown*); +SOAP_FMAC3 _apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogShutdown(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogShutdown(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse +#define SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse (464) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogHeartbeatResponse(struct soap*, const char*, int, const _apl__AgentWatchdogHeartbeatResponse *, const char*); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse * SOAP_FMAC4 soap_get__apl__AgentWatchdogHeartbeatResponse(struct soap*, _apl__AgentWatchdogHeartbeatResponse *, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse * SOAP_FMAC4 soap_in__apl__AgentWatchdogHeartbeatResponse(struct soap*, const char*, _apl__AgentWatchdogHeartbeatResponse *, const char*); +SOAP_FMAC5 _apl__AgentWatchdogHeartbeatResponse * SOAP_FMAC6 soap_new__apl__AgentWatchdogHeartbeatResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogHeartbeatResponse(struct soap*, _apl__AgentWatchdogHeartbeatResponse*); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogHeartbeatResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogHeartbeatResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apl__AgentWatchdogHeartbeat +#define SOAP_TYPE__apl__AgentWatchdogHeartbeat (463) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogHeartbeat(struct soap*, const char*, int, const _apl__AgentWatchdogHeartbeat *, const char*); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_get__apl__AgentWatchdogHeartbeat(struct soap*, _apl__AgentWatchdogHeartbeat *, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_in__apl__AgentWatchdogHeartbeat(struct soap*, const char*, _apl__AgentWatchdogHeartbeat *, const char*); +SOAP_FMAC5 _apl__AgentWatchdogHeartbeat * SOAP_FMAC6 soap_new__apl__AgentWatchdogHeartbeat(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogHeartbeat(struct soap*, _apl__AgentWatchdogHeartbeat*); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogHeartbeat(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogHeartbeat(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apl__AgentWatchdogRegisterResponse +#define SOAP_TYPE__apl__AgentWatchdogRegisterResponse (462) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogRegisterResponse(struct soap*, const char*, int, const _apl__AgentWatchdogRegisterResponse *, const char*); +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse * SOAP_FMAC4 soap_get__apl__AgentWatchdogRegisterResponse(struct soap*, _apl__AgentWatchdogRegisterResponse *, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse * SOAP_FMAC4 soap_in__apl__AgentWatchdogRegisterResponse(struct soap*, const char*, _apl__AgentWatchdogRegisterResponse *, const char*); +SOAP_FMAC5 _apl__AgentWatchdogRegisterResponse * SOAP_FMAC6 soap_new__apl__AgentWatchdogRegisterResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogRegisterResponse(struct soap*, _apl__AgentWatchdogRegisterResponse*); +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogRegisterResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogRegisterResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apl__AgentWatchdogRegister +#define SOAP_TYPE__apl__AgentWatchdogRegister (461) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogRegister(struct soap*, const char*, int, const _apl__AgentWatchdogRegister *, const char*); +SOAP_FMAC3 _apl__AgentWatchdogRegister * SOAP_FMAC4 soap_get__apl__AgentWatchdogRegister(struct soap*, _apl__AgentWatchdogRegister *, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogRegister * SOAP_FMAC4 soap_in__apl__AgentWatchdogRegister(struct soap*, const char*, _apl__AgentWatchdogRegister *, const char*); +SOAP_FMAC5 _apl__AgentWatchdogRegister * SOAP_FMAC6 soap_new__apl__AgentWatchdogRegister(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogRegister(struct soap*, _apl__AgentWatchdogRegister*); +SOAP_FMAC3 _apl__AgentWatchdogRegister * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogRegister(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogRegister(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_apl__GUID +#define SOAP_TYPE_apl__GUID (460) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apl__GUID(struct soap*, const char*, int, const apl__GUID *, const char*); +SOAP_FMAC3 apl__GUID * SOAP_FMAC4 soap_get_apl__GUID(struct soap*, apl__GUID *, const char*, const char*); +SOAP_FMAC3 apl__GUID * SOAP_FMAC4 soap_in_apl__GUID(struct soap*, const char*, apl__GUID *, const char*); +SOAP_FMAC5 apl__GUID * SOAP_FMAC6 soap_new_apl__GUID(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apl__GUID(struct soap*, apl__GUID*); +SOAP_FMAC3 apl__GUID * SOAP_FMAC4 soap_instantiate_apl__GUID(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apl__GUID(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse +#define SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse (459) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, const char*, int, const _apr__ConsoleWatchdogQueryCapabilitiesResponse *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, _apr__ConsoleWatchdogQueryCapabilitiesResponse *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, const char*, _apr__ConsoleWatchdogQueryCapabilitiesResponse *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogQueryCapabilitiesResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, _apr__ConsoleWatchdogQueryCapabilitiesResponse*); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities +#define SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities (458) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogQueryCapabilities(struct soap*, const char*, int, const _apr__ConsoleWatchdogQueryCapabilities *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogQueryCapabilities(struct soap*, _apr__ConsoleWatchdogQueryCapabilities *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogQueryCapabilities(struct soap*, const char*, _apr__ConsoleWatchdogQueryCapabilities *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogQueryCapabilities(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogQueryCapabilities(struct soap*, _apr__ConsoleWatchdogQueryCapabilities*); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogQueryCapabilities(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogQueryCapabilities(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse +#define SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse (457) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, const char*, int, const _apr__ConsoleWatchdogGetCbPolicyResponse *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogGetCbPolicyResponse *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, const char*, _apr__ConsoleWatchdogGetCbPolicyResponse *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogGetCbPolicyResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogGetCbPolicyResponse*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy +#define SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy (456) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogGetCbPolicy(struct soap*, const char*, int, const _apr__ConsoleWatchdogGetCbPolicy *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogGetCbPolicy(struct soap*, _apr__ConsoleWatchdogGetCbPolicy *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogGetCbPolicy(struct soap*, const char*, _apr__ConsoleWatchdogGetCbPolicy *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogGetCbPolicy(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogGetCbPolicy(struct soap*, _apr__ConsoleWatchdogGetCbPolicy*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogGetCbPolicy(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogGetCbPolicy(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse +#define SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse (455) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, const char*, int, const _apr__ConsoleWatchdogSetCbPolicyResponse *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogSetCbPolicyResponse *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, const char*, _apr__ConsoleWatchdogSetCbPolicyResponse *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogSetCbPolicyResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogSetCbPolicyResponse*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy +#define SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy (454) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogSetCbPolicy(struct soap*, const char*, int, const _apr__ConsoleWatchdogSetCbPolicy *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogSetCbPolicy(struct soap*, _apr__ConsoleWatchdogSetCbPolicy *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogSetCbPolicy(struct soap*, const char*, _apr__ConsoleWatchdogSetCbPolicy *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogSetCbPolicy(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogSetCbPolicy(struct soap*, _apr__ConsoleWatchdogSetCbPolicy*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogSetCbPolicy(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogSetCbPolicy(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse +#define SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse (453) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogGetActionsResponse(struct soap*, const char*, int, const _apr__ConsoleWatchdogGetActionsResponse *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogGetActionsResponse(struct soap*, _apr__ConsoleWatchdogGetActionsResponse *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogGetActionsResponse(struct soap*, const char*, _apr__ConsoleWatchdogGetActionsResponse *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogGetActionsResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogGetActionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogGetActionsResponse(struct soap*, _apr__ConsoleWatchdogGetActionsResponse*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogGetActionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogGetActionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogGetActions +#define SOAP_TYPE__apr__ConsoleWatchdogGetActions (452) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogGetActions(struct soap*, const char*, int, const _apr__ConsoleWatchdogGetActions *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogGetActions(struct soap*, _apr__ConsoleWatchdogGetActions *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogGetActions(struct soap*, const char*, _apr__ConsoleWatchdogGetActions *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogGetActions * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogGetActions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogGetActions(struct soap*, _apr__ConsoleWatchdogGetActions*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogGetActions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogGetActions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse +#define SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse (451) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogSetActionsResponse(struct soap*, const char*, int, const _apr__ConsoleWatchdogSetActionsResponse *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogSetActionsResponse(struct soap*, _apr__ConsoleWatchdogSetActionsResponse *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogSetActionsResponse(struct soap*, const char*, _apr__ConsoleWatchdogSetActionsResponse *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogSetActionsResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogSetActionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogSetActionsResponse(struct soap*, _apr__ConsoleWatchdogSetActionsResponse*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogSetActionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogSetActionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogSetActions +#define SOAP_TYPE__apr__ConsoleWatchdogSetActions (450) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogSetActions(struct soap*, const char*, int, const _apr__ConsoleWatchdogSetActions *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogSetActions(struct soap*, _apr__ConsoleWatchdogSetActions *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogSetActions(struct soap*, const char*, _apr__ConsoleWatchdogSetActions *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogSetActions * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogSetActions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogSetActions(struct soap*, _apr__ConsoleWatchdogSetActions*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogSetActions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogSetActions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse +#define SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse (449) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogEnumerateResponse(struct soap*, const char*, int, const _apr__ConsoleWatchdogEnumerateResponse *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogEnumerateResponse(struct soap*, _apr__ConsoleWatchdogEnumerateResponse *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogEnumerateResponse(struct soap*, const char*, _apr__ConsoleWatchdogEnumerateResponse *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogEnumerateResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogEnumerateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogEnumerateResponse(struct soap*, _apr__ConsoleWatchdogEnumerateResponse*); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogEnumerateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogEnumerateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogEnumerate +#define SOAP_TYPE__apr__ConsoleWatchdogEnumerate (448) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogEnumerate(struct soap*, const char*, int, const _apr__ConsoleWatchdogEnumerate *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogEnumerate(struct soap*, _apr__ConsoleWatchdogEnumerate *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogEnumerate(struct soap*, const char*, _apr__ConsoleWatchdogEnumerate *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogEnumerate * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogEnumerate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogEnumerate(struct soap*, _apr__ConsoleWatchdogEnumerate*); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogEnumerate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogEnumerate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse +#define SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse (447) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogDeleteResponse(struct soap*, const char*, int, const _apr__ConsoleWatchdogDeleteResponse *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogDeleteResponse(struct soap*, _apr__ConsoleWatchdogDeleteResponse *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogDeleteResponse(struct soap*, const char*, _apr__ConsoleWatchdogDeleteResponse *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogDeleteResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogDeleteResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogDeleteResponse(struct soap*, _apr__ConsoleWatchdogDeleteResponse*); +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogDeleteResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogDeleteResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogDelete +#define SOAP_TYPE__apr__ConsoleWatchdogDelete (446) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogDelete(struct soap*, const char*, int, const _apr__ConsoleWatchdogDelete *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogDelete(struct soap*, _apr__ConsoleWatchdogDelete *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogDelete(struct soap*, const char*, _apr__ConsoleWatchdogDelete *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogDelete * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogDelete(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogDelete(struct soap*, _apr__ConsoleWatchdogDelete*); +SOAP_FMAC3 _apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogDelete(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogDelete(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogCreateResponse +#define SOAP_TYPE__apr__ConsoleWatchdogCreateResponse (445) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogCreateResponse(struct soap*, const char*, int, const _apr__ConsoleWatchdogCreateResponse *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogCreateResponse(struct soap*, _apr__ConsoleWatchdogCreateResponse *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogCreateResponse(struct soap*, const char*, _apr__ConsoleWatchdogCreateResponse *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogCreateResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogCreateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogCreateResponse(struct soap*, _apr__ConsoleWatchdogCreateResponse*); +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogCreateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogCreateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogCreate +#define SOAP_TYPE__apr__ConsoleWatchdogCreate (444) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogCreate(struct soap*, const char*, int, const _apr__ConsoleWatchdogCreate *, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogCreate(struct soap*, _apr__ConsoleWatchdogCreate *, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogCreate(struct soap*, const char*, _apr__ConsoleWatchdogCreate *, const char*); +SOAP_FMAC5 _apr__ConsoleWatchdogCreate * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogCreate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogCreate(struct soap*, _apr__ConsoleWatchdogCreate*); +SOAP_FMAC3 _apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogCreate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogCreate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_apr__AgentPresenceCapabilitiesType +#define SOAP_TYPE_apr__AgentPresenceCapabilitiesType (443) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__AgentPresenceCapabilitiesType(struct soap*, const char*, int, const apr__AgentPresenceCapabilitiesType *, const char*); +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType * SOAP_FMAC4 soap_get_apr__AgentPresenceCapabilitiesType(struct soap*, apr__AgentPresenceCapabilitiesType *, const char*, const char*); +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType * SOAP_FMAC4 soap_in_apr__AgentPresenceCapabilitiesType(struct soap*, const char*, apr__AgentPresenceCapabilitiesType *, const char*); +SOAP_FMAC5 apr__AgentPresenceCapabilitiesType * SOAP_FMAC6 soap_new_apr__AgentPresenceCapabilitiesType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__AgentPresenceCapabilitiesType(struct soap*, apr__AgentPresenceCapabilitiesType*); +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType * SOAP_FMAC4 soap_instantiate_apr__AgentPresenceCapabilitiesType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__AgentPresenceCapabilitiesType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType +#define SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType (442) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__CircuitBreakerHardwarePolicyType(struct soap*, const char*, int, const apr__CircuitBreakerHardwarePolicyType *, const char*); +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_get_apr__CircuitBreakerHardwarePolicyType(struct soap*, apr__CircuitBreakerHardwarePolicyType *, const char*, const char*); +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_in_apr__CircuitBreakerHardwarePolicyType(struct soap*, const char*, apr__CircuitBreakerHardwarePolicyType *, const char*); +SOAP_FMAC5 apr__CircuitBreakerHardwarePolicyType * SOAP_FMAC6 soap_new_apr__CircuitBreakerHardwarePolicyType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__CircuitBreakerHardwarePolicyType(struct soap*, apr__CircuitBreakerHardwarePolicyType*); +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_instantiate_apr__CircuitBreakerHardwarePolicyType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__CircuitBreakerHardwarePolicyType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_apr__ConsoleWatchdogActionType +#define SOAP_TYPE_apr__ConsoleWatchdogActionType (441) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__ConsoleWatchdogActionType(struct soap*, const char*, int, const apr__ConsoleWatchdogActionType *, const char*); +SOAP_FMAC3 apr__ConsoleWatchdogActionType * SOAP_FMAC4 soap_get_apr__ConsoleWatchdogActionType(struct soap*, apr__ConsoleWatchdogActionType *, const char*, const char*); +SOAP_FMAC3 apr__ConsoleWatchdogActionType * SOAP_FMAC4 soap_in_apr__ConsoleWatchdogActionType(struct soap*, const char*, apr__ConsoleWatchdogActionType *, const char*); +SOAP_FMAC5 apr__ConsoleWatchdogActionType * SOAP_FMAC6 soap_new_apr__ConsoleWatchdogActionType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__ConsoleWatchdogActionType(struct soap*, apr__ConsoleWatchdogActionType*); +SOAP_FMAC3 apr__ConsoleWatchdogActionType * SOAP_FMAC4 soap_instantiate_apr__ConsoleWatchdogActionType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__ConsoleWatchdogActionType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_apr__ConsoleWatchdogEntryType +#define SOAP_TYPE_apr__ConsoleWatchdogEntryType (440) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__ConsoleWatchdogEntryType(struct soap*, const char*, int, const apr__ConsoleWatchdogEntryType *, const char*); +SOAP_FMAC3 apr__ConsoleWatchdogEntryType * SOAP_FMAC4 soap_get_apr__ConsoleWatchdogEntryType(struct soap*, apr__ConsoleWatchdogEntryType *, const char*, const char*); +SOAP_FMAC3 apr__ConsoleWatchdogEntryType * SOAP_FMAC4 soap_in_apr__ConsoleWatchdogEntryType(struct soap*, const char*, apr__ConsoleWatchdogEntryType *, const char*); +SOAP_FMAC5 apr__ConsoleWatchdogEntryType * SOAP_FMAC6 soap_new_apr__ConsoleWatchdogEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__ConsoleWatchdogEntryType(struct soap*, apr__ConsoleWatchdogEntryType*); +SOAP_FMAC3 apr__ConsoleWatchdogEntryType * SOAP_FMAC4 soap_instantiate_apr__ConsoleWatchdogEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__ConsoleWatchdogEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_apr__GUID +#define SOAP_TYPE_apr__GUID (439) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__GUID(struct soap*, const char*, int, const apr__GUID *, const char*); +SOAP_FMAC3 apr__GUID * SOAP_FMAC4 soap_get_apr__GUID(struct soap*, apr__GUID *, const char*, const char*); +SOAP_FMAC3 apr__GUID * SOAP_FMAC4 soap_in_apr__GUID(struct soap*, const char*, apr__GUID *, const char*); +SOAP_FMAC5 apr__GUID * SOAP_FMAC6 soap_new_apr__GUID(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__GUID(struct soap*, apr__GUID*); +SOAP_FMAC3 apr__GUID * SOAP_FMAC4 soap_instantiate_apr__GUID(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__GUID(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__hwa__GetAssetDataResponse +#define SOAP_TYPE__hwa__GetAssetDataResponse (438) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__hwa__GetAssetDataResponse(struct soap*, const char*, int, const _hwa__GetAssetDataResponse *, const char*); +SOAP_FMAC3 _hwa__GetAssetDataResponse * SOAP_FMAC4 soap_get__hwa__GetAssetDataResponse(struct soap*, _hwa__GetAssetDataResponse *, const char*, const char*); +SOAP_FMAC3 _hwa__GetAssetDataResponse * SOAP_FMAC4 soap_in__hwa__GetAssetDataResponse(struct soap*, const char*, _hwa__GetAssetDataResponse *, const char*); +SOAP_FMAC5 _hwa__GetAssetDataResponse * SOAP_FMAC6 soap_new__hwa__GetAssetDataResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__hwa__GetAssetDataResponse(struct soap*, _hwa__GetAssetDataResponse*); +SOAP_FMAC3 _hwa__GetAssetDataResponse * SOAP_FMAC4 soap_instantiate__hwa__GetAssetDataResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__hwa__GetAssetDataResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__hwa__GetAssetData +#define SOAP_TYPE__hwa__GetAssetData (437) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__hwa__GetAssetData(struct soap*, const char*, int, const _hwa__GetAssetData *, const char*); +SOAP_FMAC3 _hwa__GetAssetData * SOAP_FMAC4 soap_get__hwa__GetAssetData(struct soap*, _hwa__GetAssetData *, const char*, const char*); +SOAP_FMAC3 _hwa__GetAssetData * SOAP_FMAC4 soap_in__hwa__GetAssetData(struct soap*, const char*, _hwa__GetAssetData *, const char*); +SOAP_FMAC5 _hwa__GetAssetData * SOAP_FMAC6 soap_new__hwa__GetAssetData(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__hwa__GetAssetData(struct soap*, _hwa__GetAssetData*); +SOAP_FMAC3 _hwa__GetAssetData * SOAP_FMAC4 soap_instantiate__hwa__GetAssetData(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__hwa__GetAssetData(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__hwa__EnumerateAssetTypesResponse +#define SOAP_TYPE__hwa__EnumerateAssetTypesResponse (436) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__hwa__EnumerateAssetTypesResponse(struct soap*, const char*, int, const _hwa__EnumerateAssetTypesResponse *, const char*); +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse * SOAP_FMAC4 soap_get__hwa__EnumerateAssetTypesResponse(struct soap*, _hwa__EnumerateAssetTypesResponse *, const char*, const char*); +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse * SOAP_FMAC4 soap_in__hwa__EnumerateAssetTypesResponse(struct soap*, const char*, _hwa__EnumerateAssetTypesResponse *, const char*); +SOAP_FMAC5 _hwa__EnumerateAssetTypesResponse * SOAP_FMAC6 soap_new__hwa__EnumerateAssetTypesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__hwa__EnumerateAssetTypesResponse(struct soap*, _hwa__EnumerateAssetTypesResponse*); +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse * SOAP_FMAC4 soap_instantiate__hwa__EnumerateAssetTypesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__hwa__EnumerateAssetTypesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__hwa__EnumerateAssetTypes +#define SOAP_TYPE__hwa__EnumerateAssetTypes (435) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__hwa__EnumerateAssetTypes(struct soap*, const char*, int, const _hwa__EnumerateAssetTypes *, const char*); +SOAP_FMAC3 _hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_get__hwa__EnumerateAssetTypes(struct soap*, _hwa__EnumerateAssetTypes *, const char*, const char*); +SOAP_FMAC3 _hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_in__hwa__EnumerateAssetTypes(struct soap*, const char*, _hwa__EnumerateAssetTypes *, const char*); +SOAP_FMAC5 _hwa__EnumerateAssetTypes * SOAP_FMAC6 soap_new__hwa__EnumerateAssetTypes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__hwa__EnumerateAssetTypes(struct soap*, _hwa__EnumerateAssetTypes*); +SOAP_FMAC3 _hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_instantiate__hwa__EnumerateAssetTypes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__hwa__EnumerateAssetTypes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE +#define SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE (434) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap*, const char*, int, const hwa__PT_USCOREMEDIA_USCOREDEVICE *, const char*); +SOAP_FMAC3 hwa__PT_USCOREMEDIA_USCOREDEVICE * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap*, hwa__PT_USCOREMEDIA_USCOREDEVICE *, const char*, const char*); +SOAP_FMAC3 hwa__PT_USCOREMEDIA_USCOREDEVICE * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap*, const char*, hwa__PT_USCOREMEDIA_USCOREDEVICE *, const char*); +SOAP_FMAC5 hwa__PT_USCOREMEDIA_USCOREDEVICE * SOAP_FMAC6 soap_new_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap*, hwa__PT_USCOREMEDIA_USCOREDEVICE*); +SOAP_FMAC3 hwa__PT_USCOREMEDIA_USCOREDEVICE * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__PT_USCOREFRU +#define SOAP_TYPE_hwa__PT_USCOREFRU (433) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREFRU(struct soap*, const char*, int, const hwa__PT_USCOREFRU *, const char*); +SOAP_FMAC3 hwa__PT_USCOREFRU * SOAP_FMAC4 soap_get_hwa__PT_USCOREFRU(struct soap*, hwa__PT_USCOREFRU *, const char*, const char*); +SOAP_FMAC3 hwa__PT_USCOREFRU * SOAP_FMAC4 soap_in_hwa__PT_USCOREFRU(struct soap*, const char*, hwa__PT_USCOREFRU *, const char*); +SOAP_FMAC5 hwa__PT_USCOREFRU * SOAP_FMAC6 soap_new_hwa__PT_USCOREFRU(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREFRU(struct soap*, hwa__PT_USCOREFRU*); +SOAP_FMAC3 hwa__PT_USCOREFRU * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREFRU(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREFRU(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE +#define SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE (432) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap*, const char*, int, const hwa__PT_USCOREMEMORY_USCOREMODULE *, const char*); +SOAP_FMAC3 hwa__PT_USCOREMEMORY_USCOREMODULE * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap*, hwa__PT_USCOREMEMORY_USCOREMODULE *, const char*, const char*); +SOAP_FMAC3 hwa__PT_USCOREMEMORY_USCOREMODULE * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap*, const char*, hwa__PT_USCOREMEMORY_USCOREMODULE *, const char*); +SOAP_FMAC5 hwa__PT_USCOREMEMORY_USCOREMODULE * SOAP_FMAC6 soap_new_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap*, hwa__PT_USCOREMEMORY_USCOREMODULE*); +SOAP_FMAC3 hwa__PT_USCOREMEMORY_USCOREMODULE * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR (431) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR(struct soap*, const char*, int, const hwa__PT_USCOREPROCESSOR *, const char*); +SOAP_FMAC3 hwa__PT_USCOREPROCESSOR * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR(struct soap*, hwa__PT_USCOREPROCESSOR *, const char*, const char*); +SOAP_FMAC3 hwa__PT_USCOREPROCESSOR * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR(struct soap*, const char*, hwa__PT_USCOREPROCESSOR *, const char*); +SOAP_FMAC5 hwa__PT_USCOREPROCESSOR * SOAP_FMAC6 soap_new_hwa__PT_USCOREPROCESSOR(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREPROCESSOR(struct soap*, hwa__PT_USCOREPROCESSOR*); +SOAP_FMAC3 hwa__PT_USCOREPROCESSOR * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREPROCESSOR(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREPROCESSOR(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__PT_USCOREBASEBOARD +#define SOAP_TYPE_hwa__PT_USCOREBASEBOARD (430) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREBASEBOARD(struct soap*, const char*, int, const hwa__PT_USCOREBASEBOARD *, const char*); +SOAP_FMAC3 hwa__PT_USCOREBASEBOARD * SOAP_FMAC4 soap_get_hwa__PT_USCOREBASEBOARD(struct soap*, hwa__PT_USCOREBASEBOARD *, const char*, const char*); +SOAP_FMAC3 hwa__PT_USCOREBASEBOARD * SOAP_FMAC4 soap_in_hwa__PT_USCOREBASEBOARD(struct soap*, const char*, hwa__PT_USCOREBASEBOARD *, const char*); +SOAP_FMAC5 hwa__PT_USCOREBASEBOARD * SOAP_FMAC6 soap_new_hwa__PT_USCOREBASEBOARD(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREBASEBOARD(struct soap*, hwa__PT_USCOREBASEBOARD*); +SOAP_FMAC3 hwa__PT_USCOREBASEBOARD * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREBASEBOARD(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREBASEBOARD(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__GUID +#define SOAP_TYPE_hwa__GUID (429) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__GUID(struct soap*, const char*, int, const hwa__GUID *, const char*); +SOAP_FMAC3 hwa__GUID * SOAP_FMAC4 soap_get_hwa__GUID(struct soap*, hwa__GUID *, const char*, const char*); +SOAP_FMAC3 hwa__GUID * SOAP_FMAC4 soap_in_hwa__GUID(struct soap*, const char*, hwa__GUID *, const char*); +SOAP_FMAC5 hwa__GUID * SOAP_FMAC6 soap_new_hwa__GUID(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__GUID(struct soap*, hwa__GUID*); +SOAP_FMAC3 hwa__GUID * SOAP_FMAC4 soap_instantiate_hwa__GUID(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__GUID(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM +#define SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM (428) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap*, const char*, int, const hwa__PT_USCORECOMPUTER_USCORESYSTEM *, const char*); +SOAP_FMAC3 hwa__PT_USCORECOMPUTER_USCORESYSTEM * SOAP_FMAC4 soap_get_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap*, hwa__PT_USCORECOMPUTER_USCORESYSTEM *, const char*, const char*); +SOAP_FMAC3 hwa__PT_USCORECOMPUTER_USCORESYSTEM * SOAP_FMAC4 soap_in_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap*, const char*, hwa__PT_USCORECOMPUTER_USCORESYSTEM *, const char*); +SOAP_FMAC5 hwa__PT_USCORECOMPUTER_USCORESYSTEM * SOAP_FMAC6 soap_new_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap*, hwa__PT_USCORECOMPUTER_USCORESYSTEM*); +SOAP_FMAC3 hwa__PT_USCORECOMPUTER_USCORESYSTEM * SOAP_FMAC4 soap_instantiate_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__PT_USCOREBIOS +#define SOAP_TYPE_hwa__PT_USCOREBIOS (427) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREBIOS(struct soap*, const char*, int, const hwa__PT_USCOREBIOS *, const char*); +SOAP_FMAC3 hwa__PT_USCOREBIOS * SOAP_FMAC4 soap_get_hwa__PT_USCOREBIOS(struct soap*, hwa__PT_USCOREBIOS *, const char*, const char*); +SOAP_FMAC3 hwa__PT_USCOREBIOS * SOAP_FMAC4 soap_in_hwa__PT_USCOREBIOS(struct soap*, const char*, hwa__PT_USCOREBIOS *, const char*); +SOAP_FMAC5 hwa__PT_USCOREBIOS * SOAP_FMAC6 soap_new_hwa__PT_USCOREBIOS(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREBIOS(struct soap*, hwa__PT_USCOREBIOS*); +SOAP_FMAC3 hwa__PT_USCOREBIOS * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREBIOS(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREBIOS(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__AssetDataType +#define SOAP_TYPE_hwa__AssetDataType (426) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__AssetDataType(struct soap*, const char*, int, const hwa__AssetDataType *, const char*); +SOAP_FMAC3 hwa__AssetDataType * SOAP_FMAC4 soap_get_hwa__AssetDataType(struct soap*, hwa__AssetDataType *, const char*, const char*); +SOAP_FMAC3 hwa__AssetDataType * SOAP_FMAC4 soap_in_hwa__AssetDataType(struct soap*, const char*, hwa__AssetDataType *, const char*); +SOAP_FMAC5 hwa__AssetDataType * SOAP_FMAC6 soap_new_hwa__AssetDataType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__AssetDataType(struct soap*, hwa__AssetDataType*); +SOAP_FMAC3 hwa__AssetDataType * SOAP_FMAC4 soap_instantiate_hwa__AssetDataType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__AssetDataType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__AssetDataArrayType +#define SOAP_TYPE_hwa__AssetDataArrayType (425) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__AssetDataArrayType(struct soap*, const char*, int, const hwa__AssetDataArrayType *, const char*); +SOAP_FMAC3 hwa__AssetDataArrayType * SOAP_FMAC4 soap_get_hwa__AssetDataArrayType(struct soap*, hwa__AssetDataArrayType *, const char*, const char*); +SOAP_FMAC3 hwa__AssetDataArrayType * SOAP_FMAC4 soap_in_hwa__AssetDataArrayType(struct soap*, const char*, hwa__AssetDataArrayType *, const char*); +SOAP_FMAC5 hwa__AssetDataArrayType * SOAP_FMAC6 soap_new_hwa__AssetDataArrayType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__AssetDataArrayType(struct soap*, hwa__AssetDataArrayType*); +SOAP_FMAC3 hwa__AssetDataArrayType * SOAP_FMAC4 soap_instantiate_hwa__AssetDataArrayType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__AssetDataArrayType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_hwa__AssetTypeArrayType +#define SOAP_TYPE_hwa__AssetTypeArrayType (424) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__AssetTypeArrayType(struct soap*, const char*, int, const hwa__AssetTypeArrayType *, const char*); +SOAP_FMAC3 hwa__AssetTypeArrayType * SOAP_FMAC4 soap_get_hwa__AssetTypeArrayType(struct soap*, hwa__AssetTypeArrayType *, const char*, const char*); +SOAP_FMAC3 hwa__AssetTypeArrayType * SOAP_FMAC4 soap_in_hwa__AssetTypeArrayType(struct soap*, const char*, hwa__AssetTypeArrayType *, const char*); +SOAP_FMAC5 hwa__AssetTypeArrayType * SOAP_FMAC6 soap_new_hwa__AssetTypeArrayType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__AssetTypeArrayType(struct soap*, hwa__AssetTypeArrayType*); +SOAP_FMAC3 hwa__AssetTypeArrayType * SOAP_FMAC4 soap_instantiate_hwa__AssetTypeArrayType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__AssetTypeArrayType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__GetHcbStateResponse +#define SOAP_TYPE__cb__GetHcbStateResponse (423) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__GetHcbStateResponse(struct soap*, const char*, int, const _cb__GetHcbStateResponse *, const char*); +SOAP_FMAC3 _cb__GetHcbStateResponse * SOAP_FMAC4 soap_get__cb__GetHcbStateResponse(struct soap*, _cb__GetHcbStateResponse *, const char*, const char*); +SOAP_FMAC3 _cb__GetHcbStateResponse * SOAP_FMAC4 soap_in__cb__GetHcbStateResponse(struct soap*, const char*, _cb__GetHcbStateResponse *, const char*); +SOAP_FMAC5 _cb__GetHcbStateResponse * SOAP_FMAC6 soap_new__cb__GetHcbStateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__GetHcbStateResponse(struct soap*, _cb__GetHcbStateResponse*); +SOAP_FMAC3 _cb__GetHcbStateResponse * SOAP_FMAC4 soap_instantiate__cb__GetHcbStateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__GetHcbStateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__GetHcbState +#define SOAP_TYPE__cb__GetHcbState (422) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__GetHcbState(struct soap*, const char*, int, const _cb__GetHcbState *, const char*); +SOAP_FMAC3 _cb__GetHcbState * SOAP_FMAC4 soap_get__cb__GetHcbState(struct soap*, _cb__GetHcbState *, const char*, const char*); +SOAP_FMAC3 _cb__GetHcbState * SOAP_FMAC4 soap_in__cb__GetHcbState(struct soap*, const char*, _cb__GetHcbState *, const char*); +SOAP_FMAC5 _cb__GetHcbState * SOAP_FMAC6 soap_new__cb__GetHcbState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__GetHcbState(struct soap*, _cb__GetHcbState*); +SOAP_FMAC3 _cb__GetHcbState * SOAP_FMAC4 soap_instantiate__cb__GetHcbState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__GetHcbState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__ClearHcbStateResponse +#define SOAP_TYPE__cb__ClearHcbStateResponse (421) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__ClearHcbStateResponse(struct soap*, const char*, int, const _cb__ClearHcbStateResponse *, const char*); +SOAP_FMAC3 _cb__ClearHcbStateResponse * SOAP_FMAC4 soap_get__cb__ClearHcbStateResponse(struct soap*, _cb__ClearHcbStateResponse *, const char*, const char*); +SOAP_FMAC3 _cb__ClearHcbStateResponse * SOAP_FMAC4 soap_in__cb__ClearHcbStateResponse(struct soap*, const char*, _cb__ClearHcbStateResponse *, const char*); +SOAP_FMAC5 _cb__ClearHcbStateResponse * SOAP_FMAC6 soap_new__cb__ClearHcbStateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__ClearHcbStateResponse(struct soap*, _cb__ClearHcbStateResponse*); +SOAP_FMAC3 _cb__ClearHcbStateResponse * SOAP_FMAC4 soap_instantiate__cb__ClearHcbStateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__ClearHcbStateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__ClearHcbState +#define SOAP_TYPE__cb__ClearHcbState (420) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__ClearHcbState(struct soap*, const char*, int, const _cb__ClearHcbState *, const char*); +SOAP_FMAC3 _cb__ClearHcbState * SOAP_FMAC4 soap_get__cb__ClearHcbState(struct soap*, _cb__ClearHcbState *, const char*, const char*); +SOAP_FMAC3 _cb__ClearHcbState * SOAP_FMAC4 soap_in__cb__ClearHcbState(struct soap*, const char*, _cb__ClearHcbState *, const char*); +SOAP_FMAC5 _cb__ClearHcbState * SOAP_FMAC6 soap_new__cb__ClearHcbState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__ClearHcbState(struct soap*, _cb__ClearHcbState*); +SOAP_FMAC3 _cb__ClearHcbState * SOAP_FMAC4 soap_instantiate__cb__ClearHcbState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__ClearHcbState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__GetHcbOptionsResponse +#define SOAP_TYPE__cb__GetHcbOptionsResponse (419) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__GetHcbOptionsResponse(struct soap*, const char*, int, const _cb__GetHcbOptionsResponse *, const char*); +SOAP_FMAC3 _cb__GetHcbOptionsResponse * SOAP_FMAC4 soap_get__cb__GetHcbOptionsResponse(struct soap*, _cb__GetHcbOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _cb__GetHcbOptionsResponse * SOAP_FMAC4 soap_in__cb__GetHcbOptionsResponse(struct soap*, const char*, _cb__GetHcbOptionsResponse *, const char*); +SOAP_FMAC5 _cb__GetHcbOptionsResponse * SOAP_FMAC6 soap_new__cb__GetHcbOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__GetHcbOptionsResponse(struct soap*, _cb__GetHcbOptionsResponse*); +SOAP_FMAC3 _cb__GetHcbOptionsResponse * SOAP_FMAC4 soap_instantiate__cb__GetHcbOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__GetHcbOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__GetHcbOptions +#define SOAP_TYPE__cb__GetHcbOptions (418) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__GetHcbOptions(struct soap*, const char*, int, const _cb__GetHcbOptions *, const char*); +SOAP_FMAC3 _cb__GetHcbOptions * SOAP_FMAC4 soap_get__cb__GetHcbOptions(struct soap*, _cb__GetHcbOptions *, const char*, const char*); +SOAP_FMAC3 _cb__GetHcbOptions * SOAP_FMAC4 soap_in__cb__GetHcbOptions(struct soap*, const char*, _cb__GetHcbOptions *, const char*); +SOAP_FMAC5 _cb__GetHcbOptions * SOAP_FMAC6 soap_new__cb__GetHcbOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__GetHcbOptions(struct soap*, _cb__GetHcbOptions*); +SOAP_FMAC3 _cb__GetHcbOptions * SOAP_FMAC4 soap_instantiate__cb__GetHcbOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__GetHcbOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__SetHcbOptionsResponse +#define SOAP_TYPE__cb__SetHcbOptionsResponse (417) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__SetHcbOptionsResponse(struct soap*, const char*, int, const _cb__SetHcbOptionsResponse *, const char*); +SOAP_FMAC3 _cb__SetHcbOptionsResponse * SOAP_FMAC4 soap_get__cb__SetHcbOptionsResponse(struct soap*, _cb__SetHcbOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _cb__SetHcbOptionsResponse * SOAP_FMAC4 soap_in__cb__SetHcbOptionsResponse(struct soap*, const char*, _cb__SetHcbOptionsResponse *, const char*); +SOAP_FMAC5 _cb__SetHcbOptionsResponse * SOAP_FMAC6 soap_new__cb__SetHcbOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__SetHcbOptionsResponse(struct soap*, _cb__SetHcbOptionsResponse*); +SOAP_FMAC3 _cb__SetHcbOptionsResponse * SOAP_FMAC4 soap_instantiate__cb__SetHcbOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__SetHcbOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__SetHcbOptions +#define SOAP_TYPE__cb__SetHcbOptions (416) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__SetHcbOptions(struct soap*, const char*, int, const _cb__SetHcbOptions *, const char*); +SOAP_FMAC3 _cb__SetHcbOptions * SOAP_FMAC4 soap_get__cb__SetHcbOptions(struct soap*, _cb__SetHcbOptions *, const char*, const char*); +SOAP_FMAC3 _cb__SetHcbOptions * SOAP_FMAC4 soap_in__cb__SetHcbOptions(struct soap*, const char*, _cb__SetHcbOptions *, const char*); +SOAP_FMAC5 _cb__SetHcbOptions * SOAP_FMAC6 soap_new__cb__SetHcbOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__SetHcbOptions(struct soap*, _cb__SetHcbOptions*); +SOAP_FMAC3 _cb__SetHcbOptions * SOAP_FMAC4 soap_instantiate__cb__SetHcbOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__SetHcbOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbQueryCapabilitiesResponse +#define SOAP_TYPE__cb__CbQueryCapabilitiesResponse (415) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbQueryCapabilitiesResponse(struct soap*, const char*, int, const _cb__CbQueryCapabilitiesResponse *, const char*); +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse * SOAP_FMAC4 soap_get__cb__CbQueryCapabilitiesResponse(struct soap*, _cb__CbQueryCapabilitiesResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse * SOAP_FMAC4 soap_in__cb__CbQueryCapabilitiesResponse(struct soap*, const char*, _cb__CbQueryCapabilitiesResponse *, const char*); +SOAP_FMAC5 _cb__CbQueryCapabilitiesResponse * SOAP_FMAC6 soap_new__cb__CbQueryCapabilitiesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbQueryCapabilitiesResponse(struct soap*, _cb__CbQueryCapabilitiesResponse*); +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__cb__CbQueryCapabilitiesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbQueryCapabilitiesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbQueryCapabilities +#define SOAP_TYPE__cb__CbQueryCapabilities (414) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbQueryCapabilities(struct soap*, const char*, int, const _cb__CbQueryCapabilities *, const char*); +SOAP_FMAC3 _cb__CbQueryCapabilities * SOAP_FMAC4 soap_get__cb__CbQueryCapabilities(struct soap*, _cb__CbQueryCapabilities *, const char*, const char*); +SOAP_FMAC3 _cb__CbQueryCapabilities * SOAP_FMAC4 soap_in__cb__CbQueryCapabilities(struct soap*, const char*, _cb__CbQueryCapabilities *, const char*); +SOAP_FMAC5 _cb__CbQueryCapabilities * SOAP_FMAC6 soap_new__cb__CbQueryCapabilities(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbQueryCapabilities(struct soap*, _cb__CbQueryCapabilities*); +SOAP_FMAC3 _cb__CbQueryCapabilities * SOAP_FMAC4 soap_instantiate__cb__CbQueryCapabilities(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbQueryCapabilities(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbFilterEnumerateResponse +#define SOAP_TYPE__cb__CbFilterEnumerateResponse (413) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterEnumerateResponse(struct soap*, const char*, int, const _cb__CbFilterEnumerateResponse *, const char*); +SOAP_FMAC3 _cb__CbFilterEnumerateResponse * SOAP_FMAC4 soap_get__cb__CbFilterEnumerateResponse(struct soap*, _cb__CbFilterEnumerateResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterEnumerateResponse * SOAP_FMAC4 soap_in__cb__CbFilterEnumerateResponse(struct soap*, const char*, _cb__CbFilterEnumerateResponse *, const char*); +SOAP_FMAC5 _cb__CbFilterEnumerateResponse * SOAP_FMAC6 soap_new__cb__CbFilterEnumerateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterEnumerateResponse(struct soap*, _cb__CbFilterEnumerateResponse*); +SOAP_FMAC3 _cb__CbFilterEnumerateResponse * SOAP_FMAC4 soap_instantiate__cb__CbFilterEnumerateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterEnumerateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbFilterEnumerate +#define SOAP_TYPE__cb__CbFilterEnumerate (412) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterEnumerate(struct soap*, const char*, int, const _cb__CbFilterEnumerate *, const char*); +SOAP_FMAC3 _cb__CbFilterEnumerate * SOAP_FMAC4 soap_get__cb__CbFilterEnumerate(struct soap*, _cb__CbFilterEnumerate *, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterEnumerate * SOAP_FMAC4 soap_in__cb__CbFilterEnumerate(struct soap*, const char*, _cb__CbFilterEnumerate *, const char*); +SOAP_FMAC5 _cb__CbFilterEnumerate * SOAP_FMAC6 soap_new__cb__CbFilterEnumerate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterEnumerate(struct soap*, _cb__CbFilterEnumerate*); +SOAP_FMAC3 _cb__CbFilterEnumerate * SOAP_FMAC4 soap_instantiate__cb__CbFilterEnumerate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterEnumerate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbFilterDeleteResponse +#define SOAP_TYPE__cb__CbFilterDeleteResponse (411) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterDeleteResponse(struct soap*, const char*, int, const _cb__CbFilterDeleteResponse *, const char*); +SOAP_FMAC3 _cb__CbFilterDeleteResponse * SOAP_FMAC4 soap_get__cb__CbFilterDeleteResponse(struct soap*, _cb__CbFilterDeleteResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterDeleteResponse * SOAP_FMAC4 soap_in__cb__CbFilterDeleteResponse(struct soap*, const char*, _cb__CbFilterDeleteResponse *, const char*); +SOAP_FMAC5 _cb__CbFilterDeleteResponse * SOAP_FMAC6 soap_new__cb__CbFilterDeleteResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterDeleteResponse(struct soap*, _cb__CbFilterDeleteResponse*); +SOAP_FMAC3 _cb__CbFilterDeleteResponse * SOAP_FMAC4 soap_instantiate__cb__CbFilterDeleteResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterDeleteResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbFilterDelete +#define SOAP_TYPE__cb__CbFilterDelete (410) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterDelete(struct soap*, const char*, int, const _cb__CbFilterDelete *, const char*); +SOAP_FMAC3 _cb__CbFilterDelete * SOAP_FMAC4 soap_get__cb__CbFilterDelete(struct soap*, _cb__CbFilterDelete *, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterDelete * SOAP_FMAC4 soap_in__cb__CbFilterDelete(struct soap*, const char*, _cb__CbFilterDelete *, const char*); +SOAP_FMAC5 _cb__CbFilterDelete * SOAP_FMAC6 soap_new__cb__CbFilterDelete(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterDelete(struct soap*, _cb__CbFilterDelete*); +SOAP_FMAC3 _cb__CbFilterDelete * SOAP_FMAC4 soap_instantiate__cb__CbFilterDelete(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterDelete(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbFilterGetResponse +#define SOAP_TYPE__cb__CbFilterGetResponse (409) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterGetResponse(struct soap*, const char*, int, const _cb__CbFilterGetResponse *, const char*); +SOAP_FMAC3 _cb__CbFilterGetResponse * SOAP_FMAC4 soap_get__cb__CbFilterGetResponse(struct soap*, _cb__CbFilterGetResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterGetResponse * SOAP_FMAC4 soap_in__cb__CbFilterGetResponse(struct soap*, const char*, _cb__CbFilterGetResponse *, const char*); +SOAP_FMAC5 _cb__CbFilterGetResponse * SOAP_FMAC6 soap_new__cb__CbFilterGetResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterGetResponse(struct soap*, _cb__CbFilterGetResponse*); +SOAP_FMAC3 _cb__CbFilterGetResponse * SOAP_FMAC4 soap_instantiate__cb__CbFilterGetResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterGetResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbFilterGet +#define SOAP_TYPE__cb__CbFilterGet (408) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterGet(struct soap*, const char*, int, const _cb__CbFilterGet *, const char*); +SOAP_FMAC3 _cb__CbFilterGet * SOAP_FMAC4 soap_get__cb__CbFilterGet(struct soap*, _cb__CbFilterGet *, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterGet * SOAP_FMAC4 soap_in__cb__CbFilterGet(struct soap*, const char*, _cb__CbFilterGet *, const char*); +SOAP_FMAC5 _cb__CbFilterGet * SOAP_FMAC6 soap_new__cb__CbFilterGet(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterGet(struct soap*, _cb__CbFilterGet*); +SOAP_FMAC3 _cb__CbFilterGet * SOAP_FMAC4 soap_instantiate__cb__CbFilterGet(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterGet(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbFilterCreateResponse +#define SOAP_TYPE__cb__CbFilterCreateResponse (407) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterCreateResponse(struct soap*, const char*, int, const _cb__CbFilterCreateResponse *, const char*); +SOAP_FMAC3 _cb__CbFilterCreateResponse * SOAP_FMAC4 soap_get__cb__CbFilterCreateResponse(struct soap*, _cb__CbFilterCreateResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterCreateResponse * SOAP_FMAC4 soap_in__cb__CbFilterCreateResponse(struct soap*, const char*, _cb__CbFilterCreateResponse *, const char*); +SOAP_FMAC5 _cb__CbFilterCreateResponse * SOAP_FMAC6 soap_new__cb__CbFilterCreateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterCreateResponse(struct soap*, _cb__CbFilterCreateResponse*); +SOAP_FMAC3 _cb__CbFilterCreateResponse * SOAP_FMAC4 soap_instantiate__cb__CbFilterCreateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterCreateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbFilterCreate +#define SOAP_TYPE__cb__CbFilterCreate (406) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterCreate(struct soap*, const char*, int, const _cb__CbFilterCreate *, const char*); +SOAP_FMAC3 _cb__CbFilterCreate * SOAP_FMAC4 soap_get__cb__CbFilterCreate(struct soap*, _cb__CbFilterCreate *, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterCreate * SOAP_FMAC4 soap_in__cb__CbFilterCreate(struct soap*, const char*, _cb__CbFilterCreate *, const char*); +SOAP_FMAC5 _cb__CbFilterCreate * SOAP_FMAC6 soap_new__cb__CbFilterCreate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterCreate(struct soap*, _cb__CbFilterCreate*); +SOAP_FMAC3 _cb__CbFilterCreate * SOAP_FMAC4 soap_instantiate__cb__CbFilterCreate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterCreate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse +#define SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse (405) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetActiveStatisticsResponse(struct soap*, const char*, int, const _cb__CbPolicyGetActiveStatisticsResponse *, const char*); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse * SOAP_FMAC4 soap_get__cb__CbPolicyGetActiveStatisticsResponse(struct soap*, _cb__CbPolicyGetActiveStatisticsResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse * SOAP_FMAC4 soap_in__cb__CbPolicyGetActiveStatisticsResponse(struct soap*, const char*, _cb__CbPolicyGetActiveStatisticsResponse *, const char*); +SOAP_FMAC5 _cb__CbPolicyGetActiveStatisticsResponse * SOAP_FMAC6 soap_new__cb__CbPolicyGetActiveStatisticsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetActiveStatisticsResponse(struct soap*, _cb__CbPolicyGetActiveStatisticsResponse*); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetActiveStatisticsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetActiveStatisticsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyGetActiveStatistics +#define SOAP_TYPE__cb__CbPolicyGetActiveStatistics (404) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetActiveStatistics(struct soap*, const char*, int, const _cb__CbPolicyGetActiveStatistics *, const char*); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_get__cb__CbPolicyGetActiveStatistics(struct soap*, _cb__CbPolicyGetActiveStatistics *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_in__cb__CbPolicyGetActiveStatistics(struct soap*, const char*, _cb__CbPolicyGetActiveStatistics *, const char*); +SOAP_FMAC5 _cb__CbPolicyGetActiveStatistics * SOAP_FMAC6 soap_new__cb__CbPolicyGetActiveStatistics(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetActiveStatistics(struct soap*, _cb__CbPolicyGetActiveStatistics*); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetActiveStatistics(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetActiveStatistics(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyGetEnabledResponse +#define SOAP_TYPE__cb__CbPolicyGetEnabledResponse (403) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetEnabledResponse(struct soap*, const char*, int, const _cb__CbPolicyGetEnabledResponse *, const char*); +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse * SOAP_FMAC4 soap_get__cb__CbPolicyGetEnabledResponse(struct soap*, _cb__CbPolicyGetEnabledResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse * SOAP_FMAC4 soap_in__cb__CbPolicyGetEnabledResponse(struct soap*, const char*, _cb__CbPolicyGetEnabledResponse *, const char*); +SOAP_FMAC5 _cb__CbPolicyGetEnabledResponse * SOAP_FMAC6 soap_new__cb__CbPolicyGetEnabledResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetEnabledResponse(struct soap*, _cb__CbPolicyGetEnabledResponse*); +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetEnabledResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetEnabledResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyGetEnabled +#define SOAP_TYPE__cb__CbPolicyGetEnabled (402) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetEnabled(struct soap*, const char*, int, const _cb__CbPolicyGetEnabled *, const char*); +SOAP_FMAC3 _cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_get__cb__CbPolicyGetEnabled(struct soap*, _cb__CbPolicyGetEnabled *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_in__cb__CbPolicyGetEnabled(struct soap*, const char*, _cb__CbPolicyGetEnabled *, const char*); +SOAP_FMAC5 _cb__CbPolicyGetEnabled * SOAP_FMAC6 soap_new__cb__CbPolicyGetEnabled(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetEnabled(struct soap*, _cb__CbPolicyGetEnabled*); +SOAP_FMAC3 _cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetEnabled(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetEnabled(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyDisableResponse +#define SOAP_TYPE__cb__CbPolicyDisableResponse (401) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyDisableResponse(struct soap*, const char*, int, const _cb__CbPolicyDisableResponse *, const char*); +SOAP_FMAC3 _cb__CbPolicyDisableResponse * SOAP_FMAC4 soap_get__cb__CbPolicyDisableResponse(struct soap*, _cb__CbPolicyDisableResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyDisableResponse * SOAP_FMAC4 soap_in__cb__CbPolicyDisableResponse(struct soap*, const char*, _cb__CbPolicyDisableResponse *, const char*); +SOAP_FMAC5 _cb__CbPolicyDisableResponse * SOAP_FMAC6 soap_new__cb__CbPolicyDisableResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyDisableResponse(struct soap*, _cb__CbPolicyDisableResponse*); +SOAP_FMAC3 _cb__CbPolicyDisableResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyDisableResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyDisableResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyDisable +#define SOAP_TYPE__cb__CbPolicyDisable (400) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyDisable(struct soap*, const char*, int, const _cb__CbPolicyDisable *, const char*); +SOAP_FMAC3 _cb__CbPolicyDisable * SOAP_FMAC4 soap_get__cb__CbPolicyDisable(struct soap*, _cb__CbPolicyDisable *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyDisable * SOAP_FMAC4 soap_in__cb__CbPolicyDisable(struct soap*, const char*, _cb__CbPolicyDisable *, const char*); +SOAP_FMAC5 _cb__CbPolicyDisable * SOAP_FMAC6 soap_new__cb__CbPolicyDisable(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyDisable(struct soap*, _cb__CbPolicyDisable*); +SOAP_FMAC3 _cb__CbPolicyDisable * SOAP_FMAC4 soap_instantiate__cb__CbPolicyDisable(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyDisable(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyEnableResponse +#define SOAP_TYPE__cb__CbPolicyEnableResponse (399) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyEnableResponse(struct soap*, const char*, int, const _cb__CbPolicyEnableResponse *, const char*); +SOAP_FMAC3 _cb__CbPolicyEnableResponse * SOAP_FMAC4 soap_get__cb__CbPolicyEnableResponse(struct soap*, _cb__CbPolicyEnableResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyEnableResponse * SOAP_FMAC4 soap_in__cb__CbPolicyEnableResponse(struct soap*, const char*, _cb__CbPolicyEnableResponse *, const char*); +SOAP_FMAC5 _cb__CbPolicyEnableResponse * SOAP_FMAC6 soap_new__cb__CbPolicyEnableResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyEnableResponse(struct soap*, _cb__CbPolicyEnableResponse*); +SOAP_FMAC3 _cb__CbPolicyEnableResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyEnableResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyEnableResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyEnable +#define SOAP_TYPE__cb__CbPolicyEnable (398) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyEnable(struct soap*, const char*, int, const _cb__CbPolicyEnable *, const char*); +SOAP_FMAC3 _cb__CbPolicyEnable * SOAP_FMAC4 soap_get__cb__CbPolicyEnable(struct soap*, _cb__CbPolicyEnable *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyEnable * SOAP_FMAC4 soap_in__cb__CbPolicyEnable(struct soap*, const char*, _cb__CbPolicyEnable *, const char*); +SOAP_FMAC5 _cb__CbPolicyEnable * SOAP_FMAC6 soap_new__cb__CbPolicyEnable(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyEnable(struct soap*, _cb__CbPolicyEnable*); +SOAP_FMAC3 _cb__CbPolicyEnable * SOAP_FMAC4 soap_instantiate__cb__CbPolicyEnable(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyEnable(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyEnumerateResponse +#define SOAP_TYPE__cb__CbPolicyEnumerateResponse (397) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyEnumerateResponse(struct soap*, const char*, int, const _cb__CbPolicyEnumerateResponse *, const char*); +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse * SOAP_FMAC4 soap_get__cb__CbPolicyEnumerateResponse(struct soap*, _cb__CbPolicyEnumerateResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse * SOAP_FMAC4 soap_in__cb__CbPolicyEnumerateResponse(struct soap*, const char*, _cb__CbPolicyEnumerateResponse *, const char*); +SOAP_FMAC5 _cb__CbPolicyEnumerateResponse * SOAP_FMAC6 soap_new__cb__CbPolicyEnumerateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyEnumerateResponse(struct soap*, _cb__CbPolicyEnumerateResponse*); +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyEnumerateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyEnumerateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyEnumerate +#define SOAP_TYPE__cb__CbPolicyEnumerate (396) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyEnumerate(struct soap*, const char*, int, const _cb__CbPolicyEnumerate *, const char*); +SOAP_FMAC3 _cb__CbPolicyEnumerate * SOAP_FMAC4 soap_get__cb__CbPolicyEnumerate(struct soap*, _cb__CbPolicyEnumerate *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyEnumerate * SOAP_FMAC4 soap_in__cb__CbPolicyEnumerate(struct soap*, const char*, _cb__CbPolicyEnumerate *, const char*); +SOAP_FMAC5 _cb__CbPolicyEnumerate * SOAP_FMAC6 soap_new__cb__CbPolicyEnumerate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyEnumerate(struct soap*, _cb__CbPolicyEnumerate*); +SOAP_FMAC3 _cb__CbPolicyEnumerate * SOAP_FMAC4 soap_instantiate__cb__CbPolicyEnumerate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyEnumerate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyDeleteResponse +#define SOAP_TYPE__cb__CbPolicyDeleteResponse (395) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyDeleteResponse(struct soap*, const char*, int, const _cb__CbPolicyDeleteResponse *, const char*); +SOAP_FMAC3 _cb__CbPolicyDeleteResponse * SOAP_FMAC4 soap_get__cb__CbPolicyDeleteResponse(struct soap*, _cb__CbPolicyDeleteResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyDeleteResponse * SOAP_FMAC4 soap_in__cb__CbPolicyDeleteResponse(struct soap*, const char*, _cb__CbPolicyDeleteResponse *, const char*); +SOAP_FMAC5 _cb__CbPolicyDeleteResponse * SOAP_FMAC6 soap_new__cb__CbPolicyDeleteResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyDeleteResponse(struct soap*, _cb__CbPolicyDeleteResponse*); +SOAP_FMAC3 _cb__CbPolicyDeleteResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyDeleteResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyDeleteResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyDelete +#define SOAP_TYPE__cb__CbPolicyDelete (394) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyDelete(struct soap*, const char*, int, const _cb__CbPolicyDelete *, const char*); +SOAP_FMAC3 _cb__CbPolicyDelete * SOAP_FMAC4 soap_get__cb__CbPolicyDelete(struct soap*, _cb__CbPolicyDelete *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyDelete * SOAP_FMAC4 soap_in__cb__CbPolicyDelete(struct soap*, const char*, _cb__CbPolicyDelete *, const char*); +SOAP_FMAC5 _cb__CbPolicyDelete * SOAP_FMAC6 soap_new__cb__CbPolicyDelete(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyDelete(struct soap*, _cb__CbPolicyDelete*); +SOAP_FMAC3 _cb__CbPolicyDelete * SOAP_FMAC4 soap_instantiate__cb__CbPolicyDelete(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyDelete(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyGetResponse +#define SOAP_TYPE__cb__CbPolicyGetResponse (393) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetResponse(struct soap*, const char*, int, const _cb__CbPolicyGetResponse *, const char*); +SOAP_FMAC3 _cb__CbPolicyGetResponse * SOAP_FMAC4 soap_get__cb__CbPolicyGetResponse(struct soap*, _cb__CbPolicyGetResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetResponse * SOAP_FMAC4 soap_in__cb__CbPolicyGetResponse(struct soap*, const char*, _cb__CbPolicyGetResponse *, const char*); +SOAP_FMAC5 _cb__CbPolicyGetResponse * SOAP_FMAC6 soap_new__cb__CbPolicyGetResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetResponse(struct soap*, _cb__CbPolicyGetResponse*); +SOAP_FMAC3 _cb__CbPolicyGetResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyGet +#define SOAP_TYPE__cb__CbPolicyGet (392) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGet(struct soap*, const char*, int, const _cb__CbPolicyGet *, const char*); +SOAP_FMAC3 _cb__CbPolicyGet * SOAP_FMAC4 soap_get__cb__CbPolicyGet(struct soap*, _cb__CbPolicyGet *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGet * SOAP_FMAC4 soap_in__cb__CbPolicyGet(struct soap*, const char*, _cb__CbPolicyGet *, const char*); +SOAP_FMAC5 _cb__CbPolicyGet * SOAP_FMAC6 soap_new__cb__CbPolicyGet(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGet(struct soap*, _cb__CbPolicyGet*); +SOAP_FMAC3 _cb__CbPolicyGet * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGet(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGet(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyCreateResponse +#define SOAP_TYPE__cb__CbPolicyCreateResponse (391) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyCreateResponse(struct soap*, const char*, int, const _cb__CbPolicyCreateResponse *, const char*); +SOAP_FMAC3 _cb__CbPolicyCreateResponse * SOAP_FMAC4 soap_get__cb__CbPolicyCreateResponse(struct soap*, _cb__CbPolicyCreateResponse *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyCreateResponse * SOAP_FMAC4 soap_in__cb__CbPolicyCreateResponse(struct soap*, const char*, _cb__CbPolicyCreateResponse *, const char*); +SOAP_FMAC5 _cb__CbPolicyCreateResponse * SOAP_FMAC6 soap_new__cb__CbPolicyCreateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyCreateResponse(struct soap*, _cb__CbPolicyCreateResponse*); +SOAP_FMAC3 _cb__CbPolicyCreateResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyCreateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyCreateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__cb__CbPolicyCreate +#define SOAP_TYPE__cb__CbPolicyCreate (390) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyCreate(struct soap*, const char*, int, const _cb__CbPolicyCreate *, const char*); +SOAP_FMAC3 _cb__CbPolicyCreate * SOAP_FMAC4 soap_get__cb__CbPolicyCreate(struct soap*, _cb__CbPolicyCreate *, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyCreate * SOAP_FMAC4 soap_in__cb__CbPolicyCreate(struct soap*, const char*, _cb__CbPolicyCreate *, const char*); +SOAP_FMAC5 _cb__CbPolicyCreate * SOAP_FMAC6 soap_new__cb__CbPolicyCreate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyCreate(struct soap*, _cb__CbPolicyCreate*); +SOAP_FMAC3 _cb__CbPolicyCreate * SOAP_FMAC4 soap_instantiate__cb__CbPolicyCreate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyCreate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__HcbOptionsType +#define SOAP_TYPE_cb__HcbOptionsType (389) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__HcbOptionsType(struct soap*, const char*, int, const cb__HcbOptionsType *, const char*); +SOAP_FMAC3 cb__HcbOptionsType * SOAP_FMAC4 soap_get_cb__HcbOptionsType(struct soap*, cb__HcbOptionsType *, const char*, const char*); +SOAP_FMAC3 cb__HcbOptionsType * SOAP_FMAC4 soap_in_cb__HcbOptionsType(struct soap*, const char*, cb__HcbOptionsType *, const char*); +SOAP_FMAC5 cb__HcbOptionsType * SOAP_FMAC6 soap_new_cb__HcbOptionsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__HcbOptionsType(struct soap*, cb__HcbOptionsType*); +SOAP_FMAC3 cb__HcbOptionsType * SOAP_FMAC4 soap_instantiate_cb__HcbOptionsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__HcbOptionsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__BlockedPortInfoType +#define SOAP_TYPE_cb__BlockedPortInfoType (388) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__BlockedPortInfoType(struct soap*, const char*, int, const cb__BlockedPortInfoType *, const char*); +SOAP_FMAC3 cb__BlockedPortInfoType * SOAP_FMAC4 soap_get_cb__BlockedPortInfoType(struct soap*, cb__BlockedPortInfoType *, const char*, const char*); +SOAP_FMAC3 cb__BlockedPortInfoType * SOAP_FMAC4 soap_in_cb__BlockedPortInfoType(struct soap*, const char*, cb__BlockedPortInfoType *, const char*); +SOAP_FMAC5 cb__BlockedPortInfoType * SOAP_FMAC6 soap_new_cb__BlockedPortInfoType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__BlockedPortInfoType(struct soap*, cb__BlockedPortInfoType*); +SOAP_FMAC3 cb__BlockedPortInfoType * SOAP_FMAC4 soap_instantiate_cb__BlockedPortInfoType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__BlockedPortInfoType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__TimedCounterType +#define SOAP_TYPE_cb__TimedCounterType (387) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__TimedCounterType(struct soap*, const char*, int, const cb__TimedCounterType *, const char*); +SOAP_FMAC3 cb__TimedCounterType * SOAP_FMAC4 soap_get_cb__TimedCounterType(struct soap*, cb__TimedCounterType *, const char*, const char*); +SOAP_FMAC3 cb__TimedCounterType * SOAP_FMAC4 soap_in_cb__TimedCounterType(struct soap*, const char*, cb__TimedCounterType *, const char*); +SOAP_FMAC5 cb__TimedCounterType * SOAP_FMAC6 soap_new_cb__TimedCounterType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__TimedCounterType(struct soap*, cb__TimedCounterType*); +SOAP_FMAC3 cb__TimedCounterType * SOAP_FMAC4 soap_instantiate_cb__TimedCounterType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__TimedCounterType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType +#define SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType (386) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerHardwarePolicyType(struct soap*, const char*, int, const cb__CircuitBreakerHardwarePolicyType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_get_cb__CircuitBreakerHardwarePolicyType(struct soap*, cb__CircuitBreakerHardwarePolicyType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_in_cb__CircuitBreakerHardwarePolicyType(struct soap*, const char*, cb__CircuitBreakerHardwarePolicyType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerHardwarePolicyType * SOAP_FMAC6 soap_new_cb__CircuitBreakerHardwarePolicyType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerHardwarePolicyType(struct soap*, cb__CircuitBreakerHardwarePolicyType*); +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerHardwarePolicyType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerHardwarePolicyType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType +#define SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType (385) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterStatisticsType(struct soap*, const char*, int, const cb__CircuitBreakerFilterStatisticsType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterStatisticsType(struct soap*, cb__CircuitBreakerFilterStatisticsType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterStatisticsType(struct soap*, const char*, cb__CircuitBreakerFilterStatisticsType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerFilterStatisticsType * SOAP_FMAC6 soap_new_cb__CircuitBreakerFilterStatisticsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerFilterStatisticsType(struct soap*, cb__CircuitBreakerFilterStatisticsType*); +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerFilterStatisticsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerFilterStatisticsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerCapabilitiesType +#define SOAP_TYPE_cb__CircuitBreakerCapabilitiesType (384) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerCapabilitiesType(struct soap*, const char*, int, const cb__CircuitBreakerCapabilitiesType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType * SOAP_FMAC4 soap_get_cb__CircuitBreakerCapabilitiesType(struct soap*, cb__CircuitBreakerCapabilitiesType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType * SOAP_FMAC4 soap_in_cb__CircuitBreakerCapabilitiesType(struct soap*, const char*, cb__CircuitBreakerCapabilitiesType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerCapabilitiesType * SOAP_FMAC6 soap_new_cb__CircuitBreakerCapabilitiesType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerCapabilitiesType(struct soap*, cb__CircuitBreakerCapabilitiesType*); +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerCapabilitiesType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerCapabilitiesType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterInfoType +#define SOAP_TYPE_cb__CircuitBreakerFilterInfoType (383) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterInfoType(struct soap*, const char*, int, const cb__CircuitBreakerFilterInfoType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterInfoType(struct soap*, cb__CircuitBreakerFilterInfoType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterInfoType(struct soap*, const char*, cb__CircuitBreakerFilterInfoType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerFilterInfoType * SOAP_FMAC6 soap_new_cb__CircuitBreakerFilterInfoType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerFilterInfoType(struct soap*, cb__CircuitBreakerFilterInfoType*); +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerFilterInfoType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerFilterInfoType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterType +#define SOAP_TYPE_cb__CircuitBreakerFilterType (382) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterType(struct soap*, const char*, int, const cb__CircuitBreakerFilterType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerFilterType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterType(struct soap*, cb__CircuitBreakerFilterType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerFilterType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterType(struct soap*, const char*, cb__CircuitBreakerFilterType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerFilterType * SOAP_FMAC6 soap_new_cb__CircuitBreakerFilterType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerFilterType(struct soap*, cb__CircuitBreakerFilterType*); +SOAP_FMAC3 cb__CircuitBreakerFilterType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerFilterType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerFilterType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketType +#define SOAP_TYPE_cb__CircuitBreakerPacketType (381) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketType(struct soap*, const char*, int, const cb__CircuitBreakerPacketType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketType(struct soap*, cb__CircuitBreakerPacketType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketType(struct soap*, const char*, cb__CircuitBreakerPacketType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerPacketType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketType(struct soap*, cb__CircuitBreakerPacketType*); +SOAP_FMAC3 cb__CircuitBreakerPacketType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketETHType +#define SOAP_TYPE_cb__CircuitBreakerPacketETHType (380) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketETHType(struct soap*, const char*, int, const cb__CircuitBreakerPacketETHType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketETHType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketETHType(struct soap*, cb__CircuitBreakerPacketETHType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketETHType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketETHType(struct soap*, const char*, cb__CircuitBreakerPacketETHType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerPacketETHType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketETHType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketETHType(struct soap*, cb__CircuitBreakerPacketETHType*); +SOAP_FMAC3 cb__CircuitBreakerPacketETHType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketETHType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketETHType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketIPType +#define SOAP_TYPE_cb__CircuitBreakerPacketIPType (379) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketIPType(struct soap*, const char*, int, const cb__CircuitBreakerPacketIPType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketIPType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketIPType(struct soap*, cb__CircuitBreakerPacketIPType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketIPType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketIPType(struct soap*, const char*, cb__CircuitBreakerPacketIPType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerPacketIPType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketIPType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketIPType(struct soap*, cb__CircuitBreakerPacketIPType*); +SOAP_FMAC3 cb__CircuitBreakerPacketIPType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketIPType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketIPType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketTCPType +#define SOAP_TYPE_cb__CircuitBreakerPacketTCPType (378) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketTCPType(struct soap*, const char*, int, const cb__CircuitBreakerPacketTCPType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketTCPType(struct soap*, cb__CircuitBreakerPacketTCPType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketTCPType(struct soap*, const char*, cb__CircuitBreakerPacketTCPType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerPacketTCPType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketTCPType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketTCPType(struct soap*, cb__CircuitBreakerPacketTCPType*); +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketTCPType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketTCPType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketUDPType +#define SOAP_TYPE_cb__CircuitBreakerPacketUDPType (377) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketUDPType(struct soap*, const char*, int, const cb__CircuitBreakerPacketUDPType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketUDPType(struct soap*, cb__CircuitBreakerPacketUDPType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketUDPType(struct soap*, const char*, cb__CircuitBreakerPacketUDPType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerPacketUDPType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketUDPType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketUDPType(struct soap*, cb__CircuitBreakerPacketUDPType*); +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketUDPType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketUDPType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPPacketType +#define SOAP_TYPE_cb__CircuitBreakerIPPacketType (376) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPPacketType(struct soap*, const char*, int, const cb__CircuitBreakerIPPacketType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPPacketType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPPacketType(struct soap*, cb__CircuitBreakerIPPacketType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPPacketType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPPacketType(struct soap*, const char*, cb__CircuitBreakerIPPacketType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerIPPacketType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPPacketType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPPacketType(struct soap*, cb__CircuitBreakerIPPacketType*); +SOAP_FMAC3 cb__CircuitBreakerIPPacketType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPPacketType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPPacketType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPv6Type +#define SOAP_TYPE_cb__CircuitBreakerIPv6Type (375) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPv6Type(struct soap*, const char*, int, const cb__CircuitBreakerIPv6Type *, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv6Type * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPv6Type(struct soap*, cb__CircuitBreakerIPv6Type *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv6Type * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPv6Type(struct soap*, const char*, cb__CircuitBreakerIPv6Type *, const char*); +SOAP_FMAC5 cb__CircuitBreakerIPv6Type * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPv6Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPv6Type(struct soap*, cb__CircuitBreakerIPv6Type*); +SOAP_FMAC3 cb__CircuitBreakerIPv6Type * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPv6Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPv6Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPv4Type +#define SOAP_TYPE_cb__CircuitBreakerIPv4Type (374) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPv4Type(struct soap*, const char*, int, const cb__CircuitBreakerIPv4Type *, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv4Type * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPv4Type(struct soap*, cb__CircuitBreakerIPv4Type *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv4Type * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPv4Type(struct soap*, const char*, cb__CircuitBreakerIPv4Type *, const char*); +SOAP_FMAC5 cb__CircuitBreakerIPv4Type * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPv4Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPv4Type(struct soap*, cb__CircuitBreakerIPv4Type*); +SOAP_FMAC3 cb__CircuitBreakerIPv4Type * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPv4Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPv4Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType +#define SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType (373) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, const char*, int, const cb__CircuitBreakerIPLayeredTCPFlagsType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, cb__CircuitBreakerIPLayeredTCPFlagsType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, const char*, cb__CircuitBreakerIPLayeredTCPFlagsType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerIPLayeredTCPFlagsType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, cb__CircuitBreakerIPLayeredTCPFlagsType*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType +#define SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType (372) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPLayeredPortType(struct soap*, const char*, int, const cb__CircuitBreakerIPLayeredPortType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPLayeredPortType(struct soap*, cb__CircuitBreakerIPLayeredPortType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPLayeredPortType(struct soap*, const char*, cb__CircuitBreakerIPLayeredPortType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerIPLayeredPortType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPLayeredPortType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPLayeredPortType(struct soap*, cb__CircuitBreakerIPLayeredPortType*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPLayeredPortType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPLayeredPortType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType +#define SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType (371) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPLayeredPortRangeType(struct soap*, const char*, int, const cb__CircuitBreakerIPLayeredPortRangeType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPLayeredPortRangeType(struct soap*, cb__CircuitBreakerIPLayeredPortRangeType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPLayeredPortRangeType(struct soap*, const char*, cb__CircuitBreakerIPLayeredPortRangeType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerIPLayeredPortRangeType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPLayeredPortRangeType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPLayeredPortRangeType(struct soap*, cb__CircuitBreakerIPLayeredPortRangeType*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPLayeredPortRangeType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPLayeredPortRangeType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType +#define SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType (370) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, const char*, int, const cb__CircuitBreakerIPLayeredPortSimpleType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, cb__CircuitBreakerIPLayeredPortSimpleType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, const char*, cb__CircuitBreakerIPLayeredPortSimpleType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerIPLayeredPortSimpleType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, cb__CircuitBreakerIPLayeredPortSimpleType*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType +#define SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType (369) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, const char*, int, const cb__CircuitBreakerIPv6AddressAndMaskType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv6AddressAndMaskType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, const char*, cb__CircuitBreakerIPv6AddressAndMaskType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerIPv6AddressAndMaskType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv6AddressAndMaskType*); +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType +#define SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType (368) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, const char*, int, const cb__CircuitBreakerIPv4AddressAndMaskType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv4AddressAndMaskType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, const char*, cb__CircuitBreakerIPv4AddressAndMaskType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerIPv4AddressAndMaskType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv4AddressAndMaskType*); +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerPolicyInfoType +#define SOAP_TYPE_cb__CircuitBreakerPolicyInfoType (367) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPolicyInfoType(struct soap*, const char*, int, const cb__CircuitBreakerPolicyInfoType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPolicyInfoType(struct soap*, cb__CircuitBreakerPolicyInfoType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPolicyInfoType(struct soap*, const char*, cb__CircuitBreakerPolicyInfoType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerPolicyInfoType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPolicyInfoType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPolicyInfoType(struct soap*, cb__CircuitBreakerPolicyInfoType*); +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPolicyInfoType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPolicyInfoType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerPolicyType +#define SOAP_TYPE_cb__CircuitBreakerPolicyType (366) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPolicyType(struct soap*, const char*, int, const cb__CircuitBreakerPolicyType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerPolicyType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPolicyType(struct soap*, cb__CircuitBreakerPolicyType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPolicyType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPolicyType(struct soap*, const char*, cb__CircuitBreakerPolicyType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerPolicyType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPolicyType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPolicyType(struct soap*, cb__CircuitBreakerPolicyType*); +SOAP_FMAC3 cb__CircuitBreakerPolicyType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPolicyType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPolicyType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerDefaultFilterType +#define SOAP_TYPE_cb__CircuitBreakerDefaultFilterType (365) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerDefaultFilterType(struct soap*, const char*, int, const cb__CircuitBreakerDefaultFilterType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType * SOAP_FMAC4 soap_get_cb__CircuitBreakerDefaultFilterType(struct soap*, cb__CircuitBreakerDefaultFilterType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType * SOAP_FMAC4 soap_in_cb__CircuitBreakerDefaultFilterType(struct soap*, const char*, cb__CircuitBreakerDefaultFilterType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerDefaultFilterType * SOAP_FMAC6 soap_new_cb__CircuitBreakerDefaultFilterType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerDefaultFilterType(struct soap*, cb__CircuitBreakerDefaultFilterType*); +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerDefaultFilterType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerDefaultFilterType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType +#define SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType (364) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerAntiSpoofingFilterType(struct soap*, const char*, int, const cb__CircuitBreakerAntiSpoofingFilterType *, const char*); +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType * SOAP_FMAC4 soap_get_cb__CircuitBreakerAntiSpoofingFilterType(struct soap*, cb__CircuitBreakerAntiSpoofingFilterType *, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType * SOAP_FMAC4 soap_in_cb__CircuitBreakerAntiSpoofingFilterType(struct soap*, const char*, cb__CircuitBreakerAntiSpoofingFilterType *, const char*); +SOAP_FMAC5 cb__CircuitBreakerAntiSpoofingFilterType * SOAP_FMAC6 soap_new_cb__CircuitBreakerAntiSpoofingFilterType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerAntiSpoofingFilterType(struct soap*, cb__CircuitBreakerAntiSpoofingFilterType*); +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerAntiSpoofingFilterType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerAntiSpoofingFilterType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse +#define SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse (363) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetGeneralAlertSubscriptionResponse(struct soap*, const char*, int, const _emi__GetGeneralAlertSubscriptionResponse *, const char*); +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse * SOAP_FMAC4 soap_get__emi__GetGeneralAlertSubscriptionResponse(struct soap*, _emi__GetGeneralAlertSubscriptionResponse *, const char*, const char*); +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse * SOAP_FMAC4 soap_in__emi__GetGeneralAlertSubscriptionResponse(struct soap*, const char*, _emi__GetGeneralAlertSubscriptionResponse *, const char*); +SOAP_FMAC5 _emi__GetGeneralAlertSubscriptionResponse * SOAP_FMAC6 soap_new__emi__GetGeneralAlertSubscriptionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetGeneralAlertSubscriptionResponse(struct soap*, _emi__GetGeneralAlertSubscriptionResponse*); +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse * SOAP_FMAC4 soap_instantiate__emi__GetGeneralAlertSubscriptionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetGeneralAlertSubscriptionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetGeneralAlertSubscription +#define SOAP_TYPE__emi__GetGeneralAlertSubscription (362) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetGeneralAlertSubscription(struct soap*, const char*, int, const _emi__GetGeneralAlertSubscription *, const char*); +SOAP_FMAC3 _emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_get__emi__GetGeneralAlertSubscription(struct soap*, _emi__GetGeneralAlertSubscription *, const char*, const char*); +SOAP_FMAC3 _emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_in__emi__GetGeneralAlertSubscription(struct soap*, const char*, _emi__GetGeneralAlertSubscription *, const char*); +SOAP_FMAC5 _emi__GetGeneralAlertSubscription * SOAP_FMAC6 soap_new__emi__GetGeneralAlertSubscription(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetGeneralAlertSubscription(struct soap*, _emi__GetGeneralAlertSubscription*); +SOAP_FMAC3 _emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_instantiate__emi__GetGeneralAlertSubscription(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetGeneralAlertSubscription(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse +#define SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse (361) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, const char*, int, const _emi__EnumerateGeneralAlertSubscriptionsResponse *, const char*); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse * SOAP_FMAC4 soap_get__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, _emi__EnumerateGeneralAlertSubscriptionsResponse *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse * SOAP_FMAC4 soap_in__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, const char*, _emi__EnumerateGeneralAlertSubscriptionsResponse *, const char*); +SOAP_FMAC5 _emi__EnumerateGeneralAlertSubscriptionsResponse * SOAP_FMAC6 soap_new__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, _emi__EnumerateGeneralAlertSubscriptionsResponse*); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions +#define SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions (360) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateGeneralAlertSubscriptions(struct soap*, const char*, int, const _emi__EnumerateGeneralAlertSubscriptions *, const char*); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_get__emi__EnumerateGeneralAlertSubscriptions(struct soap*, _emi__EnumerateGeneralAlertSubscriptions *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_in__emi__EnumerateGeneralAlertSubscriptions(struct soap*, const char*, _emi__EnumerateGeneralAlertSubscriptions *, const char*); +SOAP_FMAC5 _emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC6 soap_new__emi__EnumerateGeneralAlertSubscriptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateGeneralAlertSubscriptions(struct soap*, _emi__EnumerateGeneralAlertSubscriptions*); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_instantiate__emi__EnumerateGeneralAlertSubscriptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateGeneralAlertSubscriptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__SubscribeForGeneralAlertResponse +#define SOAP_TYPE__emi__SubscribeForGeneralAlertResponse (359) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SubscribeForGeneralAlertResponse(struct soap*, const char*, int, const _emi__SubscribeForGeneralAlertResponse *, const char*); +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse * SOAP_FMAC4 soap_get__emi__SubscribeForGeneralAlertResponse(struct soap*, _emi__SubscribeForGeneralAlertResponse *, const char*, const char*); +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse * SOAP_FMAC4 soap_in__emi__SubscribeForGeneralAlertResponse(struct soap*, const char*, _emi__SubscribeForGeneralAlertResponse *, const char*); +SOAP_FMAC5 _emi__SubscribeForGeneralAlertResponse * SOAP_FMAC6 soap_new__emi__SubscribeForGeneralAlertResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SubscribeForGeneralAlertResponse(struct soap*, _emi__SubscribeForGeneralAlertResponse*); +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse * SOAP_FMAC4 soap_instantiate__emi__SubscribeForGeneralAlertResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SubscribeForGeneralAlertResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__SubscribeForGeneralAlert +#define SOAP_TYPE__emi__SubscribeForGeneralAlert (358) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SubscribeForGeneralAlert(struct soap*, const char*, int, const _emi__SubscribeForGeneralAlert *, const char*); +SOAP_FMAC3 _emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_get__emi__SubscribeForGeneralAlert(struct soap*, _emi__SubscribeForGeneralAlert *, const char*, const char*); +SOAP_FMAC3 _emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_in__emi__SubscribeForGeneralAlert(struct soap*, const char*, _emi__SubscribeForGeneralAlert *, const char*); +SOAP_FMAC5 _emi__SubscribeForGeneralAlert * SOAP_FMAC6 soap_new__emi__SubscribeForGeneralAlert(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SubscribeForGeneralAlert(struct soap*, _emi__SubscribeForGeneralAlert*); +SOAP_FMAC3 _emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_instantiate__emi__SubscribeForGeneralAlert(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SubscribeForGeneralAlert(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__CancelAlertSubscriptionResponse +#define SOAP_TYPE__emi__CancelAlertSubscriptionResponse (357) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__CancelAlertSubscriptionResponse(struct soap*, const char*, int, const _emi__CancelAlertSubscriptionResponse *, const char*); +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse * SOAP_FMAC4 soap_get__emi__CancelAlertSubscriptionResponse(struct soap*, _emi__CancelAlertSubscriptionResponse *, const char*, const char*); +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse * SOAP_FMAC4 soap_in__emi__CancelAlertSubscriptionResponse(struct soap*, const char*, _emi__CancelAlertSubscriptionResponse *, const char*); +SOAP_FMAC5 _emi__CancelAlertSubscriptionResponse * SOAP_FMAC6 soap_new__emi__CancelAlertSubscriptionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__CancelAlertSubscriptionResponse(struct soap*, _emi__CancelAlertSubscriptionResponse*); +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse * SOAP_FMAC4 soap_instantiate__emi__CancelAlertSubscriptionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__CancelAlertSubscriptionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__CancelAlertSubscription +#define SOAP_TYPE__emi__CancelAlertSubscription (356) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__CancelAlertSubscription(struct soap*, const char*, int, const _emi__CancelAlertSubscription *, const char*); +SOAP_FMAC3 _emi__CancelAlertSubscription * SOAP_FMAC4 soap_get__emi__CancelAlertSubscription(struct soap*, _emi__CancelAlertSubscription *, const char*, const char*); +SOAP_FMAC3 _emi__CancelAlertSubscription * SOAP_FMAC4 soap_in__emi__CancelAlertSubscription(struct soap*, const char*, _emi__CancelAlertSubscription *, const char*); +SOAP_FMAC5 _emi__CancelAlertSubscription * SOAP_FMAC6 soap_new__emi__CancelAlertSubscription(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__CancelAlertSubscription(struct soap*, _emi__CancelAlertSubscription*); +SOAP_FMAC3 _emi__CancelAlertSubscription * SOAP_FMAC4 soap_instantiate__emi__CancelAlertSubscription(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__CancelAlertSubscription(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetSensorAttributesResponse +#define SOAP_TYPE__emi__GetSensorAttributesResponse (355) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetSensorAttributesResponse(struct soap*, const char*, int, const _emi__GetSensorAttributesResponse *, const char*); +SOAP_FMAC3 _emi__GetSensorAttributesResponse * SOAP_FMAC4 soap_get__emi__GetSensorAttributesResponse(struct soap*, _emi__GetSensorAttributesResponse *, const char*, const char*); +SOAP_FMAC3 _emi__GetSensorAttributesResponse * SOAP_FMAC4 soap_in__emi__GetSensorAttributesResponse(struct soap*, const char*, _emi__GetSensorAttributesResponse *, const char*); +SOAP_FMAC5 _emi__GetSensorAttributesResponse * SOAP_FMAC6 soap_new__emi__GetSensorAttributesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetSensorAttributesResponse(struct soap*, _emi__GetSensorAttributesResponse*); +SOAP_FMAC3 _emi__GetSensorAttributesResponse * SOAP_FMAC4 soap_instantiate__emi__GetSensorAttributesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetSensorAttributesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetSensorAttributes +#define SOAP_TYPE__emi__GetSensorAttributes (354) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetSensorAttributes(struct soap*, const char*, int, const _emi__GetSensorAttributes *, const char*); +SOAP_FMAC3 _emi__GetSensorAttributes * SOAP_FMAC4 soap_get__emi__GetSensorAttributes(struct soap*, _emi__GetSensorAttributes *, const char*, const char*); +SOAP_FMAC3 _emi__GetSensorAttributes * SOAP_FMAC4 soap_in__emi__GetSensorAttributes(struct soap*, const char*, _emi__GetSensorAttributes *, const char*); +SOAP_FMAC5 _emi__GetSensorAttributes * SOAP_FMAC6 soap_new__emi__GetSensorAttributes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetSensorAttributes(struct soap*, _emi__GetSensorAttributes*); +SOAP_FMAC3 _emi__GetSensorAttributes * SOAP_FMAC4 soap_instantiate__emi__GetSensorAttributes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetSensorAttributes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateSensorsResponse +#define SOAP_TYPE__emi__EnumerateSensorsResponse (353) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateSensorsResponse(struct soap*, const char*, int, const _emi__EnumerateSensorsResponse *, const char*); +SOAP_FMAC3 _emi__EnumerateSensorsResponse * SOAP_FMAC4 soap_get__emi__EnumerateSensorsResponse(struct soap*, _emi__EnumerateSensorsResponse *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateSensorsResponse * SOAP_FMAC4 soap_in__emi__EnumerateSensorsResponse(struct soap*, const char*, _emi__EnumerateSensorsResponse *, const char*); +SOAP_FMAC5 _emi__EnumerateSensorsResponse * SOAP_FMAC6 soap_new__emi__EnumerateSensorsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateSensorsResponse(struct soap*, _emi__EnumerateSensorsResponse*); +SOAP_FMAC3 _emi__EnumerateSensorsResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateSensorsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateSensorsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateSensors +#define SOAP_TYPE__emi__EnumerateSensors (352) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateSensors(struct soap*, const char*, int, const _emi__EnumerateSensors *, const char*); +SOAP_FMAC3 _emi__EnumerateSensors * SOAP_FMAC4 soap_get__emi__EnumerateSensors(struct soap*, _emi__EnumerateSensors *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateSensors * SOAP_FMAC4 soap_in__emi__EnumerateSensors(struct soap*, const char*, _emi__EnumerateSensors *, const char*); +SOAP_FMAC5 _emi__EnumerateSensors * SOAP_FMAC6 soap_new__emi__EnumerateSensors(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateSensors(struct soap*, _emi__EnumerateSensors*); +SOAP_FMAC3 _emi__EnumerateSensors * SOAP_FMAC4 soap_instantiate__emi__EnumerateSensors(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateSensors(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetEventLogTimestampClockResponse +#define SOAP_TYPE__emi__GetEventLogTimestampClockResponse (351) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventLogTimestampClockResponse(struct soap*, const char*, int, const _emi__GetEventLogTimestampClockResponse *, const char*); +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse * SOAP_FMAC4 soap_get__emi__GetEventLogTimestampClockResponse(struct soap*, _emi__GetEventLogTimestampClockResponse *, const char*, const char*); +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse * SOAP_FMAC4 soap_in__emi__GetEventLogTimestampClockResponse(struct soap*, const char*, _emi__GetEventLogTimestampClockResponse *, const char*); +SOAP_FMAC5 _emi__GetEventLogTimestampClockResponse * SOAP_FMAC6 soap_new__emi__GetEventLogTimestampClockResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventLogTimestampClockResponse(struct soap*, _emi__GetEventLogTimestampClockResponse*); +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse * SOAP_FMAC4 soap_instantiate__emi__GetEventLogTimestampClockResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventLogTimestampClockResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetEventLogTimestampClock +#define SOAP_TYPE__emi__GetEventLogTimestampClock (350) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventLogTimestampClock(struct soap*, const char*, int, const _emi__GetEventLogTimestampClock *, const char*); +SOAP_FMAC3 _emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_get__emi__GetEventLogTimestampClock(struct soap*, _emi__GetEventLogTimestampClock *, const char*, const char*); +SOAP_FMAC3 _emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_in__emi__GetEventLogTimestampClock(struct soap*, const char*, _emi__GetEventLogTimestampClock *, const char*); +SOAP_FMAC5 _emi__GetEventLogTimestampClock * SOAP_FMAC6 soap_new__emi__GetEventLogTimestampClock(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventLogTimestampClock(struct soap*, _emi__GetEventLogTimestampClock*); +SOAP_FMAC3 _emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_instantiate__emi__GetEventLogTimestampClock(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventLogTimestampClock(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__SetEventLogTimestampClockResponse +#define SOAP_TYPE__emi__SetEventLogTimestampClockResponse (349) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SetEventLogTimestampClockResponse(struct soap*, const char*, int, const _emi__SetEventLogTimestampClockResponse *, const char*); +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse * SOAP_FMAC4 soap_get__emi__SetEventLogTimestampClockResponse(struct soap*, _emi__SetEventLogTimestampClockResponse *, const char*, const char*); +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse * SOAP_FMAC4 soap_in__emi__SetEventLogTimestampClockResponse(struct soap*, const char*, _emi__SetEventLogTimestampClockResponse *, const char*); +SOAP_FMAC5 _emi__SetEventLogTimestampClockResponse * SOAP_FMAC6 soap_new__emi__SetEventLogTimestampClockResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SetEventLogTimestampClockResponse(struct soap*, _emi__SetEventLogTimestampClockResponse*); +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse * SOAP_FMAC4 soap_instantiate__emi__SetEventLogTimestampClockResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SetEventLogTimestampClockResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__SetEventLogTimestampClock +#define SOAP_TYPE__emi__SetEventLogTimestampClock (348) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SetEventLogTimestampClock(struct soap*, const char*, int, const _emi__SetEventLogTimestampClock *, const char*); +SOAP_FMAC3 _emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_get__emi__SetEventLogTimestampClock(struct soap*, _emi__SetEventLogTimestampClock *, const char*, const char*); +SOAP_FMAC3 _emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_in__emi__SetEventLogTimestampClock(struct soap*, const char*, _emi__SetEventLogTimestampClock *, const char*); +SOAP_FMAC5 _emi__SetEventLogTimestampClock * SOAP_FMAC6 soap_new__emi__SetEventLogTimestampClock(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SetEventLogTimestampClock(struct soap*, _emi__SetEventLogTimestampClock*); +SOAP_FMAC3 _emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_instantiate__emi__SetEventLogTimestampClock(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SetEventLogTimestampClock(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__FreezeEventLogResponse +#define SOAP_TYPE__emi__FreezeEventLogResponse (347) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__FreezeEventLogResponse(struct soap*, const char*, int, const _emi__FreezeEventLogResponse *, const char*); +SOAP_FMAC3 _emi__FreezeEventLogResponse * SOAP_FMAC4 soap_get__emi__FreezeEventLogResponse(struct soap*, _emi__FreezeEventLogResponse *, const char*, const char*); +SOAP_FMAC3 _emi__FreezeEventLogResponse * SOAP_FMAC4 soap_in__emi__FreezeEventLogResponse(struct soap*, const char*, _emi__FreezeEventLogResponse *, const char*); +SOAP_FMAC5 _emi__FreezeEventLogResponse * SOAP_FMAC6 soap_new__emi__FreezeEventLogResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__FreezeEventLogResponse(struct soap*, _emi__FreezeEventLogResponse*); +SOAP_FMAC3 _emi__FreezeEventLogResponse * SOAP_FMAC4 soap_instantiate__emi__FreezeEventLogResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__FreezeEventLogResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__FreezeEventLog +#define SOAP_TYPE__emi__FreezeEventLog (346) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__FreezeEventLog(struct soap*, const char*, int, const _emi__FreezeEventLog *, const char*); +SOAP_FMAC3 _emi__FreezeEventLog * SOAP_FMAC4 soap_get__emi__FreezeEventLog(struct soap*, _emi__FreezeEventLog *, const char*, const char*); +SOAP_FMAC3 _emi__FreezeEventLog * SOAP_FMAC4 soap_in__emi__FreezeEventLog(struct soap*, const char*, _emi__FreezeEventLog *, const char*); +SOAP_FMAC5 _emi__FreezeEventLog * SOAP_FMAC6 soap_new__emi__FreezeEventLog(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__FreezeEventLog(struct soap*, _emi__FreezeEventLog*); +SOAP_FMAC3 _emi__FreezeEventLog * SOAP_FMAC4 soap_instantiate__emi__FreezeEventLog(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__FreezeEventLog(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__ClearEventLogResponse +#define SOAP_TYPE__emi__ClearEventLogResponse (345) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__ClearEventLogResponse(struct soap*, const char*, int, const _emi__ClearEventLogResponse *, const char*); +SOAP_FMAC3 _emi__ClearEventLogResponse * SOAP_FMAC4 soap_get__emi__ClearEventLogResponse(struct soap*, _emi__ClearEventLogResponse *, const char*, const char*); +SOAP_FMAC3 _emi__ClearEventLogResponse * SOAP_FMAC4 soap_in__emi__ClearEventLogResponse(struct soap*, const char*, _emi__ClearEventLogResponse *, const char*); +SOAP_FMAC5 _emi__ClearEventLogResponse * SOAP_FMAC6 soap_new__emi__ClearEventLogResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__ClearEventLogResponse(struct soap*, _emi__ClearEventLogResponse*); +SOAP_FMAC3 _emi__ClearEventLogResponse * SOAP_FMAC4 soap_instantiate__emi__ClearEventLogResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__ClearEventLogResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__ClearEventLog +#define SOAP_TYPE__emi__ClearEventLog (344) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__ClearEventLog(struct soap*, const char*, int, const _emi__ClearEventLog *, const char*); +SOAP_FMAC3 _emi__ClearEventLog * SOAP_FMAC4 soap_get__emi__ClearEventLog(struct soap*, _emi__ClearEventLog *, const char*, const char*); +SOAP_FMAC3 _emi__ClearEventLog * SOAP_FMAC4 soap_in__emi__ClearEventLog(struct soap*, const char*, _emi__ClearEventLog *, const char*); +SOAP_FMAC5 _emi__ClearEventLog * SOAP_FMAC6 soap_new__emi__ClearEventLog(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__ClearEventLog(struct soap*, _emi__ClearEventLog*); +SOAP_FMAC3 _emi__ClearEventLog * SOAP_FMAC4 soap_instantiate__emi__ClearEventLog(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__ClearEventLog(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetEventLogStatusResponse +#define SOAP_TYPE__emi__GetEventLogStatusResponse (343) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventLogStatusResponse(struct soap*, const char*, int, const _emi__GetEventLogStatusResponse *, const char*); +SOAP_FMAC3 _emi__GetEventLogStatusResponse * SOAP_FMAC4 soap_get__emi__GetEventLogStatusResponse(struct soap*, _emi__GetEventLogStatusResponse *, const char*, const char*); +SOAP_FMAC3 _emi__GetEventLogStatusResponse * SOAP_FMAC4 soap_in__emi__GetEventLogStatusResponse(struct soap*, const char*, _emi__GetEventLogStatusResponse *, const char*); +SOAP_FMAC5 _emi__GetEventLogStatusResponse * SOAP_FMAC6 soap_new__emi__GetEventLogStatusResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventLogStatusResponse(struct soap*, _emi__GetEventLogStatusResponse*); +SOAP_FMAC3 _emi__GetEventLogStatusResponse * SOAP_FMAC4 soap_instantiate__emi__GetEventLogStatusResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventLogStatusResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetEventLogStatus +#define SOAP_TYPE__emi__GetEventLogStatus (342) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventLogStatus(struct soap*, const char*, int, const _emi__GetEventLogStatus *, const char*); +SOAP_FMAC3 _emi__GetEventLogStatus * SOAP_FMAC4 soap_get__emi__GetEventLogStatus(struct soap*, _emi__GetEventLogStatus *, const char*, const char*); +SOAP_FMAC3 _emi__GetEventLogStatus * SOAP_FMAC4 soap_in__emi__GetEventLogStatus(struct soap*, const char*, _emi__GetEventLogStatus *, const char*); +SOAP_FMAC5 _emi__GetEventLogStatus * SOAP_FMAC6 soap_new__emi__GetEventLogStatus(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventLogStatus(struct soap*, _emi__GetEventLogStatus*); +SOAP_FMAC3 _emi__GetEventLogStatus * SOAP_FMAC4 soap_instantiate__emi__GetEventLogStatus(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventLogStatus(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__ReadEventLogRecordsResponse +#define SOAP_TYPE__emi__ReadEventLogRecordsResponse (341) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__ReadEventLogRecordsResponse(struct soap*, const char*, int, const _emi__ReadEventLogRecordsResponse *, const char*); +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse * SOAP_FMAC4 soap_get__emi__ReadEventLogRecordsResponse(struct soap*, _emi__ReadEventLogRecordsResponse *, const char*, const char*); +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse * SOAP_FMAC4 soap_in__emi__ReadEventLogRecordsResponse(struct soap*, const char*, _emi__ReadEventLogRecordsResponse *, const char*); +SOAP_FMAC5 _emi__ReadEventLogRecordsResponse * SOAP_FMAC6 soap_new__emi__ReadEventLogRecordsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__ReadEventLogRecordsResponse(struct soap*, _emi__ReadEventLogRecordsResponse*); +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse * SOAP_FMAC4 soap_instantiate__emi__ReadEventLogRecordsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__ReadEventLogRecordsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__ReadEventLogRecords +#define SOAP_TYPE__emi__ReadEventLogRecords (340) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__ReadEventLogRecords(struct soap*, const char*, int, const _emi__ReadEventLogRecords *, const char*); +SOAP_FMAC3 _emi__ReadEventLogRecords * SOAP_FMAC4 soap_get__emi__ReadEventLogRecords(struct soap*, _emi__ReadEventLogRecords *, const char*, const char*); +SOAP_FMAC3 _emi__ReadEventLogRecords * SOAP_FMAC4 soap_in__emi__ReadEventLogRecords(struct soap*, const char*, _emi__ReadEventLogRecords *, const char*); +SOAP_FMAC5 _emi__ReadEventLogRecords * SOAP_FMAC6 soap_new__emi__ReadEventLogRecords(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__ReadEventLogRecords(struct soap*, _emi__ReadEventLogRecords*); +SOAP_FMAC3 _emi__ReadEventLogRecords * SOAP_FMAC4 soap_instantiate__emi__ReadEventLogRecords(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__ReadEventLogRecords(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__RemoveEventFilterResponse +#define SOAP_TYPE__emi__RemoveEventFilterResponse (339) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__RemoveEventFilterResponse(struct soap*, const char*, int, const _emi__RemoveEventFilterResponse *, const char*); +SOAP_FMAC3 _emi__RemoveEventFilterResponse * SOAP_FMAC4 soap_get__emi__RemoveEventFilterResponse(struct soap*, _emi__RemoveEventFilterResponse *, const char*, const char*); +SOAP_FMAC3 _emi__RemoveEventFilterResponse * SOAP_FMAC4 soap_in__emi__RemoveEventFilterResponse(struct soap*, const char*, _emi__RemoveEventFilterResponse *, const char*); +SOAP_FMAC5 _emi__RemoveEventFilterResponse * SOAP_FMAC6 soap_new__emi__RemoveEventFilterResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__RemoveEventFilterResponse(struct soap*, _emi__RemoveEventFilterResponse*); +SOAP_FMAC3 _emi__RemoveEventFilterResponse * SOAP_FMAC4 soap_instantiate__emi__RemoveEventFilterResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__RemoveEventFilterResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__RemoveEventFilter +#define SOAP_TYPE__emi__RemoveEventFilter (338) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__RemoveEventFilter(struct soap*, const char*, int, const _emi__RemoveEventFilter *, const char*); +SOAP_FMAC3 _emi__RemoveEventFilter * SOAP_FMAC4 soap_get__emi__RemoveEventFilter(struct soap*, _emi__RemoveEventFilter *, const char*, const char*); +SOAP_FMAC3 _emi__RemoveEventFilter * SOAP_FMAC4 soap_in__emi__RemoveEventFilter(struct soap*, const char*, _emi__RemoveEventFilter *, const char*); +SOAP_FMAC5 _emi__RemoveEventFilter * SOAP_FMAC6 soap_new__emi__RemoveEventFilter(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__RemoveEventFilter(struct soap*, _emi__RemoveEventFilter*); +SOAP_FMAC3 _emi__RemoveEventFilter * SOAP_FMAC4 soap_instantiate__emi__RemoveEventFilter(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__RemoveEventFilter(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__UpdateEventFilterResponse +#define SOAP_TYPE__emi__UpdateEventFilterResponse (337) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__UpdateEventFilterResponse(struct soap*, const char*, int, const _emi__UpdateEventFilterResponse *, const char*); +SOAP_FMAC3 _emi__UpdateEventFilterResponse * SOAP_FMAC4 soap_get__emi__UpdateEventFilterResponse(struct soap*, _emi__UpdateEventFilterResponse *, const char*, const char*); +SOAP_FMAC3 _emi__UpdateEventFilterResponse * SOAP_FMAC4 soap_in__emi__UpdateEventFilterResponse(struct soap*, const char*, _emi__UpdateEventFilterResponse *, const char*); +SOAP_FMAC5 _emi__UpdateEventFilterResponse * SOAP_FMAC6 soap_new__emi__UpdateEventFilterResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__UpdateEventFilterResponse(struct soap*, _emi__UpdateEventFilterResponse*); +SOAP_FMAC3 _emi__UpdateEventFilterResponse * SOAP_FMAC4 soap_instantiate__emi__UpdateEventFilterResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__UpdateEventFilterResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__UpdateEventFilter +#define SOAP_TYPE__emi__UpdateEventFilter (336) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__UpdateEventFilter(struct soap*, const char*, int, const _emi__UpdateEventFilter *, const char*); +SOAP_FMAC3 _emi__UpdateEventFilter * SOAP_FMAC4 soap_get__emi__UpdateEventFilter(struct soap*, _emi__UpdateEventFilter *, const char*, const char*); +SOAP_FMAC3 _emi__UpdateEventFilter * SOAP_FMAC4 soap_in__emi__UpdateEventFilter(struct soap*, const char*, _emi__UpdateEventFilter *, const char*); +SOAP_FMAC5 _emi__UpdateEventFilter * SOAP_FMAC6 soap_new__emi__UpdateEventFilter(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__UpdateEventFilter(struct soap*, _emi__UpdateEventFilter*); +SOAP_FMAC3 _emi__UpdateEventFilter * SOAP_FMAC4 soap_instantiate__emi__UpdateEventFilter(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__UpdateEventFilter(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetEventFilterResponse +#define SOAP_TYPE__emi__GetEventFilterResponse (335) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventFilterResponse(struct soap*, const char*, int, const _emi__GetEventFilterResponse *, const char*); +SOAP_FMAC3 _emi__GetEventFilterResponse * SOAP_FMAC4 soap_get__emi__GetEventFilterResponse(struct soap*, _emi__GetEventFilterResponse *, const char*, const char*); +SOAP_FMAC3 _emi__GetEventFilterResponse * SOAP_FMAC4 soap_in__emi__GetEventFilterResponse(struct soap*, const char*, _emi__GetEventFilterResponse *, const char*); +SOAP_FMAC5 _emi__GetEventFilterResponse * SOAP_FMAC6 soap_new__emi__GetEventFilterResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventFilterResponse(struct soap*, _emi__GetEventFilterResponse*); +SOAP_FMAC3 _emi__GetEventFilterResponse * SOAP_FMAC4 soap_instantiate__emi__GetEventFilterResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventFilterResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetEventFilter +#define SOAP_TYPE__emi__GetEventFilter (334) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventFilter(struct soap*, const char*, int, const _emi__GetEventFilter *, const char*); +SOAP_FMAC3 _emi__GetEventFilter * SOAP_FMAC4 soap_get__emi__GetEventFilter(struct soap*, _emi__GetEventFilter *, const char*, const char*); +SOAP_FMAC3 _emi__GetEventFilter * SOAP_FMAC4 soap_in__emi__GetEventFilter(struct soap*, const char*, _emi__GetEventFilter *, const char*); +SOAP_FMAC5 _emi__GetEventFilter * SOAP_FMAC6 soap_new__emi__GetEventFilter(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventFilter(struct soap*, _emi__GetEventFilter*); +SOAP_FMAC3 _emi__GetEventFilter * SOAP_FMAC4 soap_instantiate__emi__GetEventFilter(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventFilter(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateEventFiltersResponse +#define SOAP_TYPE__emi__EnumerateEventFiltersResponse (333) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateEventFiltersResponse(struct soap*, const char*, int, const _emi__EnumerateEventFiltersResponse *, const char*); +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse * SOAP_FMAC4 soap_get__emi__EnumerateEventFiltersResponse(struct soap*, _emi__EnumerateEventFiltersResponse *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse * SOAP_FMAC4 soap_in__emi__EnumerateEventFiltersResponse(struct soap*, const char*, _emi__EnumerateEventFiltersResponse *, const char*); +SOAP_FMAC5 _emi__EnumerateEventFiltersResponse * SOAP_FMAC6 soap_new__emi__EnumerateEventFiltersResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateEventFiltersResponse(struct soap*, _emi__EnumerateEventFiltersResponse*); +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateEventFiltersResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateEventFiltersResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateEventFilters +#define SOAP_TYPE__emi__EnumerateEventFilters (332) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateEventFilters(struct soap*, const char*, int, const _emi__EnumerateEventFilters *, const char*); +SOAP_FMAC3 _emi__EnumerateEventFilters * SOAP_FMAC4 soap_get__emi__EnumerateEventFilters(struct soap*, _emi__EnumerateEventFilters *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateEventFilters * SOAP_FMAC4 soap_in__emi__EnumerateEventFilters(struct soap*, const char*, _emi__EnumerateEventFilters *, const char*); +SOAP_FMAC5 _emi__EnumerateEventFilters * SOAP_FMAC6 soap_new__emi__EnumerateEventFilters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateEventFilters(struct soap*, _emi__EnumerateEventFilters*); +SOAP_FMAC3 _emi__EnumerateEventFilters * SOAP_FMAC4 soap_instantiate__emi__EnumerateEventFilters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateEventFilters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__AddEventFilterResponse +#define SOAP_TYPE__emi__AddEventFilterResponse (331) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__AddEventFilterResponse(struct soap*, const char*, int, const _emi__AddEventFilterResponse *, const char*); +SOAP_FMAC3 _emi__AddEventFilterResponse * SOAP_FMAC4 soap_get__emi__AddEventFilterResponse(struct soap*, _emi__AddEventFilterResponse *, const char*, const char*); +SOAP_FMAC3 _emi__AddEventFilterResponse * SOAP_FMAC4 soap_in__emi__AddEventFilterResponse(struct soap*, const char*, _emi__AddEventFilterResponse *, const char*); +SOAP_FMAC5 _emi__AddEventFilterResponse * SOAP_FMAC6 soap_new__emi__AddEventFilterResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__AddEventFilterResponse(struct soap*, _emi__AddEventFilterResponse*); +SOAP_FMAC3 _emi__AddEventFilterResponse * SOAP_FMAC4 soap_instantiate__emi__AddEventFilterResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__AddEventFilterResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__AddEventFilter +#define SOAP_TYPE__emi__AddEventFilter (330) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__AddEventFilter(struct soap*, const char*, int, const _emi__AddEventFilter *, const char*); +SOAP_FMAC3 _emi__AddEventFilter * SOAP_FMAC4 soap_get__emi__AddEventFilter(struct soap*, _emi__AddEventFilter *, const char*, const char*); +SOAP_FMAC3 _emi__AddEventFilter * SOAP_FMAC4 soap_in__emi__AddEventFilter(struct soap*, const char*, _emi__AddEventFilter *, const char*); +SOAP_FMAC5 _emi__AddEventFilter * SOAP_FMAC6 soap_new__emi__AddEventFilter(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__AddEventFilter(struct soap*, _emi__AddEventFilter*); +SOAP_FMAC3 _emi__AddEventFilter * SOAP_FMAC4 soap_instantiate__emi__AddEventFilter(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__AddEventFilter(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetAlertCommunityStringResponse +#define SOAP_TYPE__emi__GetAlertCommunityStringResponse (329) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetAlertCommunityStringResponse(struct soap*, const char*, int, const _emi__GetAlertCommunityStringResponse *, const char*); +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse * SOAP_FMAC4 soap_get__emi__GetAlertCommunityStringResponse(struct soap*, _emi__GetAlertCommunityStringResponse *, const char*, const char*); +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse * SOAP_FMAC4 soap_in__emi__GetAlertCommunityStringResponse(struct soap*, const char*, _emi__GetAlertCommunityStringResponse *, const char*); +SOAP_FMAC5 _emi__GetAlertCommunityStringResponse * SOAP_FMAC6 soap_new__emi__GetAlertCommunityStringResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetAlertCommunityStringResponse(struct soap*, _emi__GetAlertCommunityStringResponse*); +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse * SOAP_FMAC4 soap_instantiate__emi__GetAlertCommunityStringResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetAlertCommunityStringResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetAlertCommunityString +#define SOAP_TYPE__emi__GetAlertCommunityString (328) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetAlertCommunityString(struct soap*, const char*, int, const _emi__GetAlertCommunityString *, const char*); +SOAP_FMAC3 _emi__GetAlertCommunityString * SOAP_FMAC4 soap_get__emi__GetAlertCommunityString(struct soap*, _emi__GetAlertCommunityString *, const char*, const char*); +SOAP_FMAC3 _emi__GetAlertCommunityString * SOAP_FMAC4 soap_in__emi__GetAlertCommunityString(struct soap*, const char*, _emi__GetAlertCommunityString *, const char*); +SOAP_FMAC5 _emi__GetAlertCommunityString * SOAP_FMAC6 soap_new__emi__GetAlertCommunityString(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetAlertCommunityString(struct soap*, _emi__GetAlertCommunityString*); +SOAP_FMAC3 _emi__GetAlertCommunityString * SOAP_FMAC4 soap_instantiate__emi__GetAlertCommunityString(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetAlertCommunityString(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__SetAlertCommunityStringResponse +#define SOAP_TYPE__emi__SetAlertCommunityStringResponse (327) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SetAlertCommunityStringResponse(struct soap*, const char*, int, const _emi__SetAlertCommunityStringResponse *, const char*); +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse * SOAP_FMAC4 soap_get__emi__SetAlertCommunityStringResponse(struct soap*, _emi__SetAlertCommunityStringResponse *, const char*, const char*); +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse * SOAP_FMAC4 soap_in__emi__SetAlertCommunityStringResponse(struct soap*, const char*, _emi__SetAlertCommunityStringResponse *, const char*); +SOAP_FMAC5 _emi__SetAlertCommunityStringResponse * SOAP_FMAC6 soap_new__emi__SetAlertCommunityStringResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SetAlertCommunityStringResponse(struct soap*, _emi__SetAlertCommunityStringResponse*); +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse * SOAP_FMAC4 soap_instantiate__emi__SetAlertCommunityStringResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SetAlertCommunityStringResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__SetAlertCommunityString +#define SOAP_TYPE__emi__SetAlertCommunityString (326) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SetAlertCommunityString(struct soap*, const char*, int, const _emi__SetAlertCommunityString *, const char*); +SOAP_FMAC3 _emi__SetAlertCommunityString * SOAP_FMAC4 soap_get__emi__SetAlertCommunityString(struct soap*, _emi__SetAlertCommunityString *, const char*, const char*); +SOAP_FMAC3 _emi__SetAlertCommunityString * SOAP_FMAC4 soap_in__emi__SetAlertCommunityString(struct soap*, const char*, _emi__SetAlertCommunityString *, const char*); +SOAP_FMAC5 _emi__SetAlertCommunityString * SOAP_FMAC6 soap_new__emi__SetAlertCommunityString(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SetAlertCommunityString(struct soap*, _emi__SetAlertCommunityString*); +SOAP_FMAC3 _emi__SetAlertCommunityString * SOAP_FMAC4 soap_instantiate__emi__SetAlertCommunityString(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SetAlertCommunityString(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateAlertPoliciesResponse +#define SOAP_TYPE__emi__EnumerateAlertPoliciesResponse (325) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateAlertPoliciesResponse(struct soap*, const char*, int, const _emi__EnumerateAlertPoliciesResponse *, const char*); +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse * SOAP_FMAC4 soap_get__emi__EnumerateAlertPoliciesResponse(struct soap*, _emi__EnumerateAlertPoliciesResponse *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse * SOAP_FMAC4 soap_in__emi__EnumerateAlertPoliciesResponse(struct soap*, const char*, _emi__EnumerateAlertPoliciesResponse *, const char*); +SOAP_FMAC5 _emi__EnumerateAlertPoliciesResponse * SOAP_FMAC6 soap_new__emi__EnumerateAlertPoliciesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateAlertPoliciesResponse(struct soap*, _emi__EnumerateAlertPoliciesResponse*); +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateAlertPoliciesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateAlertPoliciesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateAlertPolicies +#define SOAP_TYPE__emi__EnumerateAlertPolicies (324) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateAlertPolicies(struct soap*, const char*, int, const _emi__EnumerateAlertPolicies *, const char*); +SOAP_FMAC3 _emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_get__emi__EnumerateAlertPolicies(struct soap*, _emi__EnumerateAlertPolicies *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_in__emi__EnumerateAlertPolicies(struct soap*, const char*, _emi__EnumerateAlertPolicies *, const char*); +SOAP_FMAC5 _emi__EnumerateAlertPolicies * SOAP_FMAC6 soap_new__emi__EnumerateAlertPolicies(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateAlertPolicies(struct soap*, _emi__EnumerateAlertPolicies*); +SOAP_FMAC3 _emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_instantiate__emi__EnumerateAlertPolicies(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateAlertPolicies(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetAlertSubscriptionResponse +#define SOAP_TYPE__emi__GetAlertSubscriptionResponse (323) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetAlertSubscriptionResponse(struct soap*, const char*, int, const _emi__GetAlertSubscriptionResponse *, const char*); +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse * SOAP_FMAC4 soap_get__emi__GetAlertSubscriptionResponse(struct soap*, _emi__GetAlertSubscriptionResponse *, const char*, const char*); +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse * SOAP_FMAC4 soap_in__emi__GetAlertSubscriptionResponse(struct soap*, const char*, _emi__GetAlertSubscriptionResponse *, const char*); +SOAP_FMAC5 _emi__GetAlertSubscriptionResponse * SOAP_FMAC6 soap_new__emi__GetAlertSubscriptionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetAlertSubscriptionResponse(struct soap*, _emi__GetAlertSubscriptionResponse*); +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse * SOAP_FMAC4 soap_instantiate__emi__GetAlertSubscriptionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetAlertSubscriptionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__GetAlertSubscription +#define SOAP_TYPE__emi__GetAlertSubscription (322) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetAlertSubscription(struct soap*, const char*, int, const _emi__GetAlertSubscription *, const char*); +SOAP_FMAC3 _emi__GetAlertSubscription * SOAP_FMAC4 soap_get__emi__GetAlertSubscription(struct soap*, _emi__GetAlertSubscription *, const char*, const char*); +SOAP_FMAC3 _emi__GetAlertSubscription * SOAP_FMAC4 soap_in__emi__GetAlertSubscription(struct soap*, const char*, _emi__GetAlertSubscription *, const char*); +SOAP_FMAC5 _emi__GetAlertSubscription * SOAP_FMAC6 soap_new__emi__GetAlertSubscription(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetAlertSubscription(struct soap*, _emi__GetAlertSubscription*); +SOAP_FMAC3 _emi__GetAlertSubscription * SOAP_FMAC4 soap_instantiate__emi__GetAlertSubscription(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetAlertSubscription(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse +#define SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse (321) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateAlertSubscriptionsResponse(struct soap*, const char*, int, const _emi__EnumerateAlertSubscriptionsResponse *, const char*); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse * SOAP_FMAC4 soap_get__emi__EnumerateAlertSubscriptionsResponse(struct soap*, _emi__EnumerateAlertSubscriptionsResponse *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse * SOAP_FMAC4 soap_in__emi__EnumerateAlertSubscriptionsResponse(struct soap*, const char*, _emi__EnumerateAlertSubscriptionsResponse *, const char*); +SOAP_FMAC5 _emi__EnumerateAlertSubscriptionsResponse * SOAP_FMAC6 soap_new__emi__EnumerateAlertSubscriptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateAlertSubscriptionsResponse(struct soap*, _emi__EnumerateAlertSubscriptionsResponse*); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateAlertSubscriptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateAlertSubscriptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__EnumerateAlertSubscriptions +#define SOAP_TYPE__emi__EnumerateAlertSubscriptions (320) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateAlertSubscriptions(struct soap*, const char*, int, const _emi__EnumerateAlertSubscriptions *, const char*); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_get__emi__EnumerateAlertSubscriptions(struct soap*, _emi__EnumerateAlertSubscriptions *, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_in__emi__EnumerateAlertSubscriptions(struct soap*, const char*, _emi__EnumerateAlertSubscriptions *, const char*); +SOAP_FMAC5 _emi__EnumerateAlertSubscriptions * SOAP_FMAC6 soap_new__emi__EnumerateAlertSubscriptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateAlertSubscriptions(struct soap*, _emi__EnumerateAlertSubscriptions*); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_instantiate__emi__EnumerateAlertSubscriptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateAlertSubscriptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__SubscribeForAlertResponse +#define SOAP_TYPE__emi__SubscribeForAlertResponse (319) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SubscribeForAlertResponse(struct soap*, const char*, int, const _emi__SubscribeForAlertResponse *, const char*); +SOAP_FMAC3 _emi__SubscribeForAlertResponse * SOAP_FMAC4 soap_get__emi__SubscribeForAlertResponse(struct soap*, _emi__SubscribeForAlertResponse *, const char*, const char*); +SOAP_FMAC3 _emi__SubscribeForAlertResponse * SOAP_FMAC4 soap_in__emi__SubscribeForAlertResponse(struct soap*, const char*, _emi__SubscribeForAlertResponse *, const char*); +SOAP_FMAC5 _emi__SubscribeForAlertResponse * SOAP_FMAC6 soap_new__emi__SubscribeForAlertResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SubscribeForAlertResponse(struct soap*, _emi__SubscribeForAlertResponse*); +SOAP_FMAC3 _emi__SubscribeForAlertResponse * SOAP_FMAC4 soap_instantiate__emi__SubscribeForAlertResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SubscribeForAlertResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__emi__SubscribeForAlert +#define SOAP_TYPE__emi__SubscribeForAlert (318) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SubscribeForAlert(struct soap*, const char*, int, const _emi__SubscribeForAlert *, const char*); +SOAP_FMAC3 _emi__SubscribeForAlert * SOAP_FMAC4 soap_get__emi__SubscribeForAlert(struct soap*, _emi__SubscribeForAlert *, const char*, const char*); +SOAP_FMAC3 _emi__SubscribeForAlert * SOAP_FMAC4 soap_in__emi__SubscribeForAlert(struct soap*, const char*, _emi__SubscribeForAlert *, const char*); +SOAP_FMAC5 _emi__SubscribeForAlert * SOAP_FMAC6 soap_new__emi__SubscribeForAlert(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SubscribeForAlert(struct soap*, _emi__SubscribeForAlert*); +SOAP_FMAC3 _emi__SubscribeForAlert * SOAP_FMAC4 soap_instantiate__emi__SubscribeForAlert(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SubscribeForAlert(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__AlertSubscriptionGeneralType +#define SOAP_TYPE_emi__AlertSubscriptionGeneralType (317) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionGeneralType(struct soap*, const char*, int, const emi__AlertSubscriptionGeneralType *, const char*); +SOAP_FMAC3 emi__AlertSubscriptionGeneralType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionGeneralType(struct soap*, emi__AlertSubscriptionGeneralType *, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionGeneralType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionGeneralType(struct soap*, const char*, emi__AlertSubscriptionGeneralType *, const char*); +SOAP_FMAC5 emi__AlertSubscriptionGeneralType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionGeneralType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionGeneralType(struct soap*, emi__AlertSubscriptionGeneralType*); +SOAP_FMAC3 emi__AlertSubscriptionGeneralType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionGeneralType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionGeneralType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__AlertSubscriptionSoapType +#define SOAP_TYPE_emi__AlertSubscriptionSoapType (316) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionSoapType(struct soap*, const char*, int, const emi__AlertSubscriptionSoapType *, const char*); +SOAP_FMAC3 emi__AlertSubscriptionSoapType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionSoapType(struct soap*, emi__AlertSubscriptionSoapType *, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionSoapType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionSoapType(struct soap*, const char*, emi__AlertSubscriptionSoapType *, const char*); +SOAP_FMAC5 emi__AlertSubscriptionSoapType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionSoapType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionSoapType(struct soap*, emi__AlertSubscriptionSoapType*); +SOAP_FMAC3 emi__AlertSubscriptionSoapType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionSoapType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionSoapType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__AlertSubscriptionSNMPType +#define SOAP_TYPE_emi__AlertSubscriptionSNMPType (315) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionSNMPType(struct soap*, const char*, int, const emi__AlertSubscriptionSNMPType *, const char*); +SOAP_FMAC3 emi__AlertSubscriptionSNMPType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionSNMPType(struct soap*, emi__AlertSubscriptionSNMPType *, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionSNMPType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionSNMPType(struct soap*, const char*, emi__AlertSubscriptionSNMPType *, const char*); +SOAP_FMAC5 emi__AlertSubscriptionSNMPType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionSNMPType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionSNMPType(struct soap*, emi__AlertSubscriptionSNMPType*); +SOAP_FMAC3 emi__AlertSubscriptionSNMPType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionSNMPType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionSNMPType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__AlertCredentialsType +#define SOAP_TYPE_emi__AlertCredentialsType (314) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertCredentialsType(struct soap*, const char*, int, const emi__AlertCredentialsType *, const char*); +SOAP_FMAC3 emi__AlertCredentialsType * SOAP_FMAC4 soap_get_emi__AlertCredentialsType(struct soap*, emi__AlertCredentialsType *, const char*, const char*); +SOAP_FMAC3 emi__AlertCredentialsType * SOAP_FMAC4 soap_in_emi__AlertCredentialsType(struct soap*, const char*, emi__AlertCredentialsType *, const char*); +SOAP_FMAC5 emi__AlertCredentialsType * SOAP_FMAC6 soap_new_emi__AlertCredentialsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertCredentialsType(struct soap*, emi__AlertCredentialsType*); +SOAP_FMAC3 emi__AlertCredentialsType * SOAP_FMAC4 soap_instantiate_emi__AlertCredentialsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertCredentialsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__ByteStr +#define SOAP_TYPE_emi__ByteStr (313) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__ByteStr(struct soap*, const char*, int, const emi__ByteStr *, const char*); +SOAP_FMAC3 emi__ByteStr * SOAP_FMAC4 soap_get_emi__ByteStr(struct soap*, emi__ByteStr *, const char*, const char*); +SOAP_FMAC3 emi__ByteStr * SOAP_FMAC4 soap_in_emi__ByteStr(struct soap*, const char*, emi__ByteStr *, const char*); +SOAP_FMAC5 emi__ByteStr * SOAP_FMAC6 soap_new_emi__ByteStr(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__ByteStr(struct soap*, emi__ByteStr*); +SOAP_FMAC3 emi__ByteStr * SOAP_FMAC4 soap_instantiate_emi__ByteStr(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__ByteStr(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__SensorAttributesType +#define SOAP_TYPE_emi__SensorAttributesType (312) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__SensorAttributesType(struct soap*, const char*, int, const emi__SensorAttributesType *, const char*); +SOAP_FMAC3 emi__SensorAttributesType * SOAP_FMAC4 soap_get_emi__SensorAttributesType(struct soap*, emi__SensorAttributesType *, const char*, const char*); +SOAP_FMAC3 emi__SensorAttributesType * SOAP_FMAC4 soap_in_emi__SensorAttributesType(struct soap*, const char*, emi__SensorAttributesType *, const char*); +SOAP_FMAC5 emi__SensorAttributesType * SOAP_FMAC6 soap_new_emi__SensorAttributesType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__SensorAttributesType(struct soap*, emi__SensorAttributesType*); +SOAP_FMAC3 emi__SensorAttributesType * SOAP_FMAC4 soap_instantiate_emi__SensorAttributesType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__SensorAttributesType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__SensorHandleArrayType +#define SOAP_TYPE_emi__SensorHandleArrayType (311) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__SensorHandleArrayType(struct soap*, const char*, int, const emi__SensorHandleArrayType *, const char*); +SOAP_FMAC3 emi__SensorHandleArrayType * SOAP_FMAC4 soap_get_emi__SensorHandleArrayType(struct soap*, emi__SensorHandleArrayType *, const char*, const char*); +SOAP_FMAC3 emi__SensorHandleArrayType * SOAP_FMAC4 soap_in_emi__SensorHandleArrayType(struct soap*, const char*, emi__SensorHandleArrayType *, const char*); +SOAP_FMAC5 emi__SensorHandleArrayType * SOAP_FMAC6 soap_new_emi__SensorHandleArrayType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__SensorHandleArrayType(struct soap*, emi__SensorHandleArrayType*); +SOAP_FMAC3 emi__SensorHandleArrayType * SOAP_FMAC4 soap_instantiate_emi__SensorHandleArrayType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__SensorHandleArrayType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__EventLogRecordArrayType +#define SOAP_TYPE_emi__EventLogRecordArrayType (310) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventLogRecordArrayType(struct soap*, const char*, int, const emi__EventLogRecordArrayType *, const char*); +SOAP_FMAC3 emi__EventLogRecordArrayType * SOAP_FMAC4 soap_get_emi__EventLogRecordArrayType(struct soap*, emi__EventLogRecordArrayType *, const char*, const char*); +SOAP_FMAC3 emi__EventLogRecordArrayType * SOAP_FMAC4 soap_in_emi__EventLogRecordArrayType(struct soap*, const char*, emi__EventLogRecordArrayType *, const char*); +SOAP_FMAC5 emi__EventLogRecordArrayType * SOAP_FMAC6 soap_new_emi__EventLogRecordArrayType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__EventLogRecordArrayType(struct soap*, emi__EventLogRecordArrayType*); +SOAP_FMAC3 emi__EventLogRecordArrayType * SOAP_FMAC4 soap_instantiate_emi__EventLogRecordArrayType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__EventLogRecordArrayType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__EventFilterHandleArrayType +#define SOAP_TYPE_emi__EventFilterHandleArrayType (309) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventFilterHandleArrayType(struct soap*, const char*, int, const emi__EventFilterHandleArrayType *, const char*); +SOAP_FMAC3 emi__EventFilterHandleArrayType * SOAP_FMAC4 soap_get_emi__EventFilterHandleArrayType(struct soap*, emi__EventFilterHandleArrayType *, const char*, const char*); +SOAP_FMAC3 emi__EventFilterHandleArrayType * SOAP_FMAC4 soap_in_emi__EventFilterHandleArrayType(struct soap*, const char*, emi__EventFilterHandleArrayType *, const char*); +SOAP_FMAC5 emi__EventFilterHandleArrayType * SOAP_FMAC6 soap_new_emi__EventFilterHandleArrayType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__EventFilterHandleArrayType(struct soap*, emi__EventFilterHandleArrayType*); +SOAP_FMAC3 emi__EventFilterHandleArrayType * SOAP_FMAC4 soap_instantiate_emi__EventFilterHandleArrayType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__EventFilterHandleArrayType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__AlertSubscriptionHandleArrayType +#define SOAP_TYPE_emi__AlertSubscriptionHandleArrayType (308) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionHandleArrayType(struct soap*, const char*, int, const emi__AlertSubscriptionHandleArrayType *, const char*); +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionHandleArrayType(struct soap*, emi__AlertSubscriptionHandleArrayType *, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionHandleArrayType(struct soap*, const char*, emi__AlertSubscriptionHandleArrayType *, const char*); +SOAP_FMAC5 emi__AlertSubscriptionHandleArrayType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionHandleArrayType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionHandleArrayType(struct soap*, emi__AlertSubscriptionHandleArrayType*); +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionHandleArrayType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionHandleArrayType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__AlertSubscriptionType +#define SOAP_TYPE_emi__AlertSubscriptionType (307) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionType(struct soap*, const char*, int, const emi__AlertSubscriptionType *, const char*); +SOAP_FMAC3 emi__AlertSubscriptionType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionType(struct soap*, emi__AlertSubscriptionType *, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionType(struct soap*, const char*, emi__AlertSubscriptionType *, const char*); +SOAP_FMAC5 emi__AlertSubscriptionType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionType(struct soap*, emi__AlertSubscriptionType*); +SOAP_FMAC3 emi__AlertSubscriptionType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__EventFilterType +#define SOAP_TYPE_emi__EventFilterType (306) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventFilterType(struct soap*, const char*, int, const emi__EventFilterType *, const char*); +SOAP_FMAC3 emi__EventFilterType * SOAP_FMAC4 soap_get_emi__EventFilterType(struct soap*, emi__EventFilterType *, const char*, const char*); +SOAP_FMAC3 emi__EventFilterType * SOAP_FMAC4 soap_in_emi__EventFilterType(struct soap*, const char*, emi__EventFilterType *, const char*); +SOAP_FMAC5 emi__EventFilterType * SOAP_FMAC6 soap_new_emi__EventFilterType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__EventFilterType(struct soap*, emi__EventFilterType*); +SOAP_FMAC3 emi__EventFilterType * SOAP_FMAC4 soap_instantiate_emi__EventFilterType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__EventFilterType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__EventLogRecordType +#define SOAP_TYPE_emi__EventLogRecordType (305) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventLogRecordType(struct soap*, const char*, int, const emi__EventLogRecordType *, const char*); +SOAP_FMAC3 emi__EventLogRecordType * SOAP_FMAC4 soap_get_emi__EventLogRecordType(struct soap*, emi__EventLogRecordType *, const char*, const char*); +SOAP_FMAC3 emi__EventLogRecordType * SOAP_FMAC4 soap_in_emi__EventLogRecordType(struct soap*, const char*, emi__EventLogRecordType *, const char*); +SOAP_FMAC5 emi__EventLogRecordType * SOAP_FMAC6 soap_new_emi__EventLogRecordType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__EventLogRecordType(struct soap*, emi__EventLogRecordType*); +SOAP_FMAC3 emi__EventLogRecordType * SOAP_FMAC4 soap_instantiate_emi__EventLogRecordType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__EventLogRecordType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__ByteData +#define SOAP_TYPE_emi__ByteData (304) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__ByteData(struct soap*, const char*, int, const emi__ByteData *, const char*); +SOAP_FMAC3 emi__ByteData * SOAP_FMAC4 soap_get_emi__ByteData(struct soap*, emi__ByteData *, const char*, const char*); +SOAP_FMAC3 emi__ByteData * SOAP_FMAC4 soap_in_emi__ByteData(struct soap*, const char*, emi__ByteData *, const char*); +SOAP_FMAC5 emi__ByteData * SOAP_FMAC6 soap_new_emi__ByteData(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__ByteData(struct soap*, emi__ByteData*); +SOAP_FMAC3 emi__ByteData * SOAP_FMAC4 soap_instantiate_emi__ByteData(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__ByteData(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType +#define SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType (303) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionPolicyIDArrayType(struct soap*, const char*, int, const emi__AlertSubscriptionPolicyIDArrayType *, const char*); +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionPolicyIDArrayType(struct soap*, emi__AlertSubscriptionPolicyIDArrayType *, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionPolicyIDArrayType(struct soap*, const char*, emi__AlertSubscriptionPolicyIDArrayType *, const char*); +SOAP_FMAC5 emi__AlertSubscriptionPolicyIDArrayType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionPolicyIDArrayType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionPolicyIDArrayType(struct soap*, emi__AlertSubscriptionPolicyIDArrayType*); +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionPolicyIDArrayType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionPolicyIDArrayType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse +#define SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse (302) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__RemoveStorageFpaclEntryResponse(struct soap*, const char*, int, const _stra__RemoveStorageFpaclEntryResponse *, const char*); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse * SOAP_FMAC4 soap_get__stra__RemoveStorageFpaclEntryResponse(struct soap*, _stra__RemoveStorageFpaclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse * SOAP_FMAC4 soap_in__stra__RemoveStorageFpaclEntryResponse(struct soap*, const char*, _stra__RemoveStorageFpaclEntryResponse *, const char*); +SOAP_FMAC5 _stra__RemoveStorageFpaclEntryResponse * SOAP_FMAC6 soap_new__stra__RemoveStorageFpaclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__RemoveStorageFpaclEntryResponse(struct soap*, _stra__RemoveStorageFpaclEntryResponse*); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__RemoveStorageFpaclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__RemoveStorageFpaclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__RemoveStorageFpaclEntry +#define SOAP_TYPE__stra__RemoveStorageFpaclEntry (301) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__RemoveStorageFpaclEntry(struct soap*, const char*, int, const _stra__RemoveStorageFpaclEntry *, const char*); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_get__stra__RemoveStorageFpaclEntry(struct soap*, _stra__RemoveStorageFpaclEntry *, const char*, const char*); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_in__stra__RemoveStorageFpaclEntry(struct soap*, const char*, _stra__RemoveStorageFpaclEntry *, const char*); +SOAP_FMAC5 _stra__RemoveStorageFpaclEntry * SOAP_FMAC6 soap_new__stra__RemoveStorageFpaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__RemoveStorageFpaclEntry(struct soap*, _stra__RemoveStorageFpaclEntry*); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_instantiate__stra__RemoveStorageFpaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__RemoveStorageFpaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse +#define SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse (300) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__UpdateStorageFpaclEntryResponse(struct soap*, const char*, int, const _stra__UpdateStorageFpaclEntryResponse *, const char*); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse * SOAP_FMAC4 soap_get__stra__UpdateStorageFpaclEntryResponse(struct soap*, _stra__UpdateStorageFpaclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse * SOAP_FMAC4 soap_in__stra__UpdateStorageFpaclEntryResponse(struct soap*, const char*, _stra__UpdateStorageFpaclEntryResponse *, const char*); +SOAP_FMAC5 _stra__UpdateStorageFpaclEntryResponse * SOAP_FMAC6 soap_new__stra__UpdateStorageFpaclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__UpdateStorageFpaclEntryResponse(struct soap*, _stra__UpdateStorageFpaclEntryResponse*); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__UpdateStorageFpaclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__UpdateStorageFpaclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__UpdateStorageFpaclEntry +#define SOAP_TYPE__stra__UpdateStorageFpaclEntry (299) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__UpdateStorageFpaclEntry(struct soap*, const char*, int, const _stra__UpdateStorageFpaclEntry *, const char*); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_get__stra__UpdateStorageFpaclEntry(struct soap*, _stra__UpdateStorageFpaclEntry *, const char*, const char*); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_in__stra__UpdateStorageFpaclEntry(struct soap*, const char*, _stra__UpdateStorageFpaclEntry *, const char*); +SOAP_FMAC5 _stra__UpdateStorageFpaclEntry * SOAP_FMAC6 soap_new__stra__UpdateStorageFpaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__UpdateStorageFpaclEntry(struct soap*, _stra__UpdateStorageFpaclEntry*); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_instantiate__stra__UpdateStorageFpaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__UpdateStorageFpaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__GetStorageAllocEntryResponse +#define SOAP_TYPE__stra__GetStorageAllocEntryResponse (298) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetStorageAllocEntryResponse(struct soap*, const char*, int, const _stra__GetStorageAllocEntryResponse *, const char*); +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse * SOAP_FMAC4 soap_get__stra__GetStorageAllocEntryResponse(struct soap*, _stra__GetStorageAllocEntryResponse *, const char*, const char*); +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse * SOAP_FMAC4 soap_in__stra__GetStorageAllocEntryResponse(struct soap*, const char*, _stra__GetStorageAllocEntryResponse *, const char*); +SOAP_FMAC5 _stra__GetStorageAllocEntryResponse * SOAP_FMAC6 soap_new__stra__GetStorageAllocEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetStorageAllocEntryResponse(struct soap*, _stra__GetStorageAllocEntryResponse*); +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse * SOAP_FMAC4 soap_instantiate__stra__GetStorageAllocEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetStorageAllocEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__GetStorageAllocEntry +#define SOAP_TYPE__stra__GetStorageAllocEntry (297) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetStorageAllocEntry(struct soap*, const char*, int, const _stra__GetStorageAllocEntry *, const char*); +SOAP_FMAC3 _stra__GetStorageAllocEntry * SOAP_FMAC4 soap_get__stra__GetStorageAllocEntry(struct soap*, _stra__GetStorageAllocEntry *, const char*, const char*); +SOAP_FMAC3 _stra__GetStorageAllocEntry * SOAP_FMAC4 soap_in__stra__GetStorageAllocEntry(struct soap*, const char*, _stra__GetStorageAllocEntry *, const char*); +SOAP_FMAC5 _stra__GetStorageAllocEntry * SOAP_FMAC6 soap_new__stra__GetStorageAllocEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetStorageAllocEntry(struct soap*, _stra__GetStorageAllocEntry*); +SOAP_FMAC3 _stra__GetStorageAllocEntry * SOAP_FMAC4 soap_instantiate__stra__GetStorageAllocEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetStorageAllocEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse +#define SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse (296) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__EnumerateStorageAllocEntriesResponse(struct soap*, const char*, int, const _stra__EnumerateStorageAllocEntriesResponse *, const char*); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse * SOAP_FMAC4 soap_get__stra__EnumerateStorageAllocEntriesResponse(struct soap*, _stra__EnumerateStorageAllocEntriesResponse *, const char*, const char*); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse * SOAP_FMAC4 soap_in__stra__EnumerateStorageAllocEntriesResponse(struct soap*, const char*, _stra__EnumerateStorageAllocEntriesResponse *, const char*); +SOAP_FMAC5 _stra__EnumerateStorageAllocEntriesResponse * SOAP_FMAC6 soap_new__stra__EnumerateStorageAllocEntriesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__EnumerateStorageAllocEntriesResponse(struct soap*, _stra__EnumerateStorageAllocEntriesResponse*); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse * SOAP_FMAC4 soap_instantiate__stra__EnumerateStorageAllocEntriesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__EnumerateStorageAllocEntriesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__EnumerateStorageAllocEntries +#define SOAP_TYPE__stra__EnumerateStorageAllocEntries (295) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__EnumerateStorageAllocEntries(struct soap*, const char*, int, const _stra__EnumerateStorageAllocEntries *, const char*); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_get__stra__EnumerateStorageAllocEntries(struct soap*, _stra__EnumerateStorageAllocEntries *, const char*, const char*); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_in__stra__EnumerateStorageAllocEntries(struct soap*, const char*, _stra__EnumerateStorageAllocEntries *, const char*); +SOAP_FMAC5 _stra__EnumerateStorageAllocEntries * SOAP_FMAC6 soap_new__stra__EnumerateStorageAllocEntries(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__EnumerateStorageAllocEntries(struct soap*, _stra__EnumerateStorageAllocEntries*); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_instantiate__stra__EnumerateStorageAllocEntries(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__EnumerateStorageAllocEntries(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AddStorageFpaclEntryResponse +#define SOAP_TYPE__stra__AddStorageFpaclEntryResponse (294) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AddStorageFpaclEntryResponse(struct soap*, const char*, int, const _stra__AddStorageFpaclEntryResponse *, const char*); +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse * SOAP_FMAC4 soap_get__stra__AddStorageFpaclEntryResponse(struct soap*, _stra__AddStorageFpaclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse * SOAP_FMAC4 soap_in__stra__AddStorageFpaclEntryResponse(struct soap*, const char*, _stra__AddStorageFpaclEntryResponse *, const char*); +SOAP_FMAC5 _stra__AddStorageFpaclEntryResponse * SOAP_FMAC6 soap_new__stra__AddStorageFpaclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AddStorageFpaclEntryResponse(struct soap*, _stra__AddStorageFpaclEntryResponse*); +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__AddStorageFpaclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AddStorageFpaclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AddStorageFpaclEntry +#define SOAP_TYPE__stra__AddStorageFpaclEntry (293) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AddStorageFpaclEntry(struct soap*, const char*, int, const _stra__AddStorageFpaclEntry *, const char*); +SOAP_FMAC3 _stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_get__stra__AddStorageFpaclEntry(struct soap*, _stra__AddStorageFpaclEntry *, const char*, const char*); +SOAP_FMAC3 _stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_in__stra__AddStorageFpaclEntry(struct soap*, const char*, _stra__AddStorageFpaclEntry *, const char*); +SOAP_FMAC5 _stra__AddStorageFpaclEntry * SOAP_FMAC6 soap_new__stra__AddStorageFpaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AddStorageFpaclEntry(struct soap*, _stra__AddStorageFpaclEntry*); +SOAP_FMAC3 _stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_instantiate__stra__AddStorageFpaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AddStorageFpaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__RemoveStorageEaclEntryResponse +#define SOAP_TYPE__stra__RemoveStorageEaclEntryResponse (292) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__RemoveStorageEaclEntryResponse(struct soap*, const char*, int, const _stra__RemoveStorageEaclEntryResponse *, const char*); +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse * SOAP_FMAC4 soap_get__stra__RemoveStorageEaclEntryResponse(struct soap*, _stra__RemoveStorageEaclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse * SOAP_FMAC4 soap_in__stra__RemoveStorageEaclEntryResponse(struct soap*, const char*, _stra__RemoveStorageEaclEntryResponse *, const char*); +SOAP_FMAC5 _stra__RemoveStorageEaclEntryResponse * SOAP_FMAC6 soap_new__stra__RemoveStorageEaclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__RemoveStorageEaclEntryResponse(struct soap*, _stra__RemoveStorageEaclEntryResponse*); +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__RemoveStorageEaclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__RemoveStorageEaclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__RemoveStorageEaclEntry +#define SOAP_TYPE__stra__RemoveStorageEaclEntry (291) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__RemoveStorageEaclEntry(struct soap*, const char*, int, const _stra__RemoveStorageEaclEntry *, const char*); +SOAP_FMAC3 _stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_get__stra__RemoveStorageEaclEntry(struct soap*, _stra__RemoveStorageEaclEntry *, const char*, const char*); +SOAP_FMAC3 _stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_in__stra__RemoveStorageEaclEntry(struct soap*, const char*, _stra__RemoveStorageEaclEntry *, const char*); +SOAP_FMAC5 _stra__RemoveStorageEaclEntry * SOAP_FMAC6 soap_new__stra__RemoveStorageEaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__RemoveStorageEaclEntry(struct soap*, _stra__RemoveStorageEaclEntry*); +SOAP_FMAC3 _stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_instantiate__stra__RemoveStorageEaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__RemoveStorageEaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__GetStorageEaclEntryResponse +#define SOAP_TYPE__stra__GetStorageEaclEntryResponse (290) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetStorageEaclEntryResponse(struct soap*, const char*, int, const _stra__GetStorageEaclEntryResponse *, const char*); +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse * SOAP_FMAC4 soap_get__stra__GetStorageEaclEntryResponse(struct soap*, _stra__GetStorageEaclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse * SOAP_FMAC4 soap_in__stra__GetStorageEaclEntryResponse(struct soap*, const char*, _stra__GetStorageEaclEntryResponse *, const char*); +SOAP_FMAC5 _stra__GetStorageEaclEntryResponse * SOAP_FMAC6 soap_new__stra__GetStorageEaclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetStorageEaclEntryResponse(struct soap*, _stra__GetStorageEaclEntryResponse*); +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__GetStorageEaclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetStorageEaclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__GetStorageEaclEntry +#define SOAP_TYPE__stra__GetStorageEaclEntry (289) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetStorageEaclEntry(struct soap*, const char*, int, const _stra__GetStorageEaclEntry *, const char*); +SOAP_FMAC3 _stra__GetStorageEaclEntry * SOAP_FMAC4 soap_get__stra__GetStorageEaclEntry(struct soap*, _stra__GetStorageEaclEntry *, const char*, const char*); +SOAP_FMAC3 _stra__GetStorageEaclEntry * SOAP_FMAC4 soap_in__stra__GetStorageEaclEntry(struct soap*, const char*, _stra__GetStorageEaclEntry *, const char*); +SOAP_FMAC5 _stra__GetStorageEaclEntry * SOAP_FMAC6 soap_new__stra__GetStorageEaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetStorageEaclEntry(struct soap*, _stra__GetStorageEaclEntry*); +SOAP_FMAC3 _stra__GetStorageEaclEntry * SOAP_FMAC4 soap_instantiate__stra__GetStorageEaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetStorageEaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse +#define SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse (288) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__EnumerateStorageEaclEntriesResponse(struct soap*, const char*, int, const _stra__EnumerateStorageEaclEntriesResponse *, const char*); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse * SOAP_FMAC4 soap_get__stra__EnumerateStorageEaclEntriesResponse(struct soap*, _stra__EnumerateStorageEaclEntriesResponse *, const char*, const char*); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse * SOAP_FMAC4 soap_in__stra__EnumerateStorageEaclEntriesResponse(struct soap*, const char*, _stra__EnumerateStorageEaclEntriesResponse *, const char*); +SOAP_FMAC5 _stra__EnumerateStorageEaclEntriesResponse * SOAP_FMAC6 soap_new__stra__EnumerateStorageEaclEntriesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__EnumerateStorageEaclEntriesResponse(struct soap*, _stra__EnumerateStorageEaclEntriesResponse*); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse * SOAP_FMAC4 soap_instantiate__stra__EnumerateStorageEaclEntriesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__EnumerateStorageEaclEntriesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__EnumerateStorageEaclEntries +#define SOAP_TYPE__stra__EnumerateStorageEaclEntries (287) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__EnumerateStorageEaclEntries(struct soap*, const char*, int, const _stra__EnumerateStorageEaclEntries *, const char*); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_get__stra__EnumerateStorageEaclEntries(struct soap*, _stra__EnumerateStorageEaclEntries *, const char*, const char*); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_in__stra__EnumerateStorageEaclEntries(struct soap*, const char*, _stra__EnumerateStorageEaclEntries *, const char*); +SOAP_FMAC5 _stra__EnumerateStorageEaclEntries * SOAP_FMAC6 soap_new__stra__EnumerateStorageEaclEntries(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__EnumerateStorageEaclEntries(struct soap*, _stra__EnumerateStorageEaclEntries*); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_instantiate__stra__EnumerateStorageEaclEntries(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__EnumerateStorageEaclEntries(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AddStorageEaclEntryResponse +#define SOAP_TYPE__stra__AddStorageEaclEntryResponse (286) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AddStorageEaclEntryResponse(struct soap*, const char*, int, const _stra__AddStorageEaclEntryResponse *, const char*); +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse * SOAP_FMAC4 soap_get__stra__AddStorageEaclEntryResponse(struct soap*, _stra__AddStorageEaclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse * SOAP_FMAC4 soap_in__stra__AddStorageEaclEntryResponse(struct soap*, const char*, _stra__AddStorageEaclEntryResponse *, const char*); +SOAP_FMAC5 _stra__AddStorageEaclEntryResponse * SOAP_FMAC6 soap_new__stra__AddStorageEaclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AddStorageEaclEntryResponse(struct soap*, _stra__AddStorageEaclEntryResponse*); +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__AddStorageEaclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AddStorageEaclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AddStorageEaclEntry +#define SOAP_TYPE__stra__AddStorageEaclEntry (285) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AddStorageEaclEntry(struct soap*, const char*, int, const _stra__AddStorageEaclEntry *, const char*); +SOAP_FMAC3 _stra__AddStorageEaclEntry * SOAP_FMAC4 soap_get__stra__AddStorageEaclEntry(struct soap*, _stra__AddStorageEaclEntry *, const char*, const char*); +SOAP_FMAC3 _stra__AddStorageEaclEntry * SOAP_FMAC4 soap_in__stra__AddStorageEaclEntry(struct soap*, const char*, _stra__AddStorageEaclEntry *, const char*); +SOAP_FMAC5 _stra__AddStorageEaclEntry * SOAP_FMAC6 soap_new__stra__AddStorageEaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AddStorageEaclEntry(struct soap*, _stra__AddStorageEaclEntry*); +SOAP_FMAC3 _stra__AddStorageEaclEntry * SOAP_FMAC4 soap_instantiate__stra__AddStorageEaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AddStorageEaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AdminRemoveApplicationResponse +#define SOAP_TYPE__stra__AdminRemoveApplicationResponse (284) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminRemoveApplicationResponse(struct soap*, const char*, int, const _stra__AdminRemoveApplicationResponse *, const char*); +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse * SOAP_FMAC4 soap_get__stra__AdminRemoveApplicationResponse(struct soap*, _stra__AdminRemoveApplicationResponse *, const char*, const char*); +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse * SOAP_FMAC4 soap_in__stra__AdminRemoveApplicationResponse(struct soap*, const char*, _stra__AdminRemoveApplicationResponse *, const char*); +SOAP_FMAC5 _stra__AdminRemoveApplicationResponse * SOAP_FMAC6 soap_new__stra__AdminRemoveApplicationResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminRemoveApplicationResponse(struct soap*, _stra__AdminRemoveApplicationResponse*); +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse * SOAP_FMAC4 soap_instantiate__stra__AdminRemoveApplicationResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminRemoveApplicationResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AdminRemoveApplication +#define SOAP_TYPE__stra__AdminRemoveApplication (283) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminRemoveApplication(struct soap*, const char*, int, const _stra__AdminRemoveApplication *, const char*); +SOAP_FMAC3 _stra__AdminRemoveApplication * SOAP_FMAC4 soap_get__stra__AdminRemoveApplication(struct soap*, _stra__AdminRemoveApplication *, const char*, const char*); +SOAP_FMAC3 _stra__AdminRemoveApplication * SOAP_FMAC4 soap_in__stra__AdminRemoveApplication(struct soap*, const char*, _stra__AdminRemoveApplication *, const char*); +SOAP_FMAC5 _stra__AdminRemoveApplication * SOAP_FMAC6 soap_new__stra__AdminRemoveApplication(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminRemoveApplication(struct soap*, _stra__AdminRemoveApplication*); +SOAP_FMAC3 _stra__AdminRemoveApplication * SOAP_FMAC4 soap_instantiate__stra__AdminRemoveApplication(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminRemoveApplication(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AdminGetApplicationAttributesResponse +#define SOAP_TYPE__stra__AdminGetApplicationAttributesResponse (282) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminGetApplicationAttributesResponse(struct soap*, const char*, int, const _stra__AdminGetApplicationAttributesResponse *, const char*); +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse * SOAP_FMAC4 soap_get__stra__AdminGetApplicationAttributesResponse(struct soap*, _stra__AdminGetApplicationAttributesResponse *, const char*, const char*); +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse * SOAP_FMAC4 soap_in__stra__AdminGetApplicationAttributesResponse(struct soap*, const char*, _stra__AdminGetApplicationAttributesResponse *, const char*); +SOAP_FMAC5 _stra__AdminGetApplicationAttributesResponse * SOAP_FMAC6 soap_new__stra__AdminGetApplicationAttributesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminGetApplicationAttributesResponse(struct soap*, _stra__AdminGetApplicationAttributesResponse*); +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse * SOAP_FMAC4 soap_instantiate__stra__AdminGetApplicationAttributesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminGetApplicationAttributesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AdminGetApplicationAttributes +#define SOAP_TYPE__stra__AdminGetApplicationAttributes (281) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminGetApplicationAttributes(struct soap*, const char*, int, const _stra__AdminGetApplicationAttributes *, const char*); +SOAP_FMAC3 _stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_get__stra__AdminGetApplicationAttributes(struct soap*, _stra__AdminGetApplicationAttributes *, const char*, const char*); +SOAP_FMAC3 _stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_in__stra__AdminGetApplicationAttributes(struct soap*, const char*, _stra__AdminGetApplicationAttributes *, const char*); +SOAP_FMAC5 _stra__AdminGetApplicationAttributes * SOAP_FMAC6 soap_new__stra__AdminGetApplicationAttributes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminGetApplicationAttributes(struct soap*, _stra__AdminGetApplicationAttributes*); +SOAP_FMAC3 _stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_instantiate__stra__AdminGetApplicationAttributes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminGetApplicationAttributes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse +#define SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse (280) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminGetRegisteredApplicationsResponse(struct soap*, const char*, int, const _stra__AdminGetRegisteredApplicationsResponse *, const char*); +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse * SOAP_FMAC4 soap_get__stra__AdminGetRegisteredApplicationsResponse(struct soap*, _stra__AdminGetRegisteredApplicationsResponse *, const char*, const char*); +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse * SOAP_FMAC4 soap_in__stra__AdminGetRegisteredApplicationsResponse(struct soap*, const char*, _stra__AdminGetRegisteredApplicationsResponse *, const char*); +SOAP_FMAC5 _stra__AdminGetRegisteredApplicationsResponse * SOAP_FMAC6 soap_new__stra__AdminGetRegisteredApplicationsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminGetRegisteredApplicationsResponse(struct soap*, _stra__AdminGetRegisteredApplicationsResponse*); +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse * SOAP_FMAC4 soap_instantiate__stra__AdminGetRegisteredApplicationsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminGetRegisteredApplicationsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__AdminGetRegisteredApplications +#define SOAP_TYPE__stra__AdminGetRegisteredApplications (279) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminGetRegisteredApplications(struct soap*, const char*, int, const _stra__AdminGetRegisteredApplications *, const char*); +SOAP_FMAC3 _stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_get__stra__AdminGetRegisteredApplications(struct soap*, _stra__AdminGetRegisteredApplications *, const char*, const char*); +SOAP_FMAC3 _stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_in__stra__AdminGetRegisteredApplications(struct soap*, const char*, _stra__AdminGetRegisteredApplications *, const char*); +SOAP_FMAC5 _stra__AdminGetRegisteredApplications * SOAP_FMAC6 soap_new__stra__AdminGetRegisteredApplications(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminGetRegisteredApplications(struct soap*, _stra__AdminGetRegisteredApplications*); +SOAP_FMAC3 _stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_instantiate__stra__AdminGetRegisteredApplications(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminGetRegisteredApplications(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__SetGlobalStorageAttributesResponse +#define SOAP_TYPE__stra__SetGlobalStorageAttributesResponse (278) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__SetGlobalStorageAttributesResponse(struct soap*, const char*, int, const _stra__SetGlobalStorageAttributesResponse *, const char*); +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_get__stra__SetGlobalStorageAttributesResponse(struct soap*, _stra__SetGlobalStorageAttributesResponse *, const char*, const char*); +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_in__stra__SetGlobalStorageAttributesResponse(struct soap*, const char*, _stra__SetGlobalStorageAttributesResponse *, const char*); +SOAP_FMAC5 _stra__SetGlobalStorageAttributesResponse * SOAP_FMAC6 soap_new__stra__SetGlobalStorageAttributesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__SetGlobalStorageAttributesResponse(struct soap*, _stra__SetGlobalStorageAttributesResponse*); +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_instantiate__stra__SetGlobalStorageAttributesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__SetGlobalStorageAttributesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__SetGlobalStorageAttributes +#define SOAP_TYPE__stra__SetGlobalStorageAttributes (277) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__SetGlobalStorageAttributes(struct soap*, const char*, int, const _stra__SetGlobalStorageAttributes *, const char*); +SOAP_FMAC3 _stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_get__stra__SetGlobalStorageAttributes(struct soap*, _stra__SetGlobalStorageAttributes *, const char*, const char*); +SOAP_FMAC3 _stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_in__stra__SetGlobalStorageAttributes(struct soap*, const char*, _stra__SetGlobalStorageAttributes *, const char*); +SOAP_FMAC5 _stra__SetGlobalStorageAttributes * SOAP_FMAC6 soap_new__stra__SetGlobalStorageAttributes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__SetGlobalStorageAttributes(struct soap*, _stra__SetGlobalStorageAttributes*); +SOAP_FMAC3 _stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_instantiate__stra__SetGlobalStorageAttributes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__SetGlobalStorageAttributes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__GetGlobalStorageAttributesResponse +#define SOAP_TYPE__stra__GetGlobalStorageAttributesResponse (276) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetGlobalStorageAttributesResponse(struct soap*, const char*, int, const _stra__GetGlobalStorageAttributesResponse *, const char*); +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_get__stra__GetGlobalStorageAttributesResponse(struct soap*, _stra__GetGlobalStorageAttributesResponse *, const char*, const char*); +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_in__stra__GetGlobalStorageAttributesResponse(struct soap*, const char*, _stra__GetGlobalStorageAttributesResponse *, const char*); +SOAP_FMAC5 _stra__GetGlobalStorageAttributesResponse * SOAP_FMAC6 soap_new__stra__GetGlobalStorageAttributesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetGlobalStorageAttributesResponse(struct soap*, _stra__GetGlobalStorageAttributesResponse*); +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_instantiate__stra__GetGlobalStorageAttributesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetGlobalStorageAttributesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__stra__GetGlobalStorageAttributes +#define SOAP_TYPE__stra__GetGlobalStorageAttributes (275) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetGlobalStorageAttributes(struct soap*, const char*, int, const _stra__GetGlobalStorageAttributes *, const char*); +SOAP_FMAC3 _stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_get__stra__GetGlobalStorageAttributes(struct soap*, _stra__GetGlobalStorageAttributes *, const char*, const char*); +SOAP_FMAC3 _stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_in__stra__GetGlobalStorageAttributes(struct soap*, const char*, _stra__GetGlobalStorageAttributes *, const char*); +SOAP_FMAC5 _stra__GetGlobalStorageAttributes * SOAP_FMAC6 soap_new__stra__GetGlobalStorageAttributes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetGlobalStorageAttributes(struct soap*, _stra__GetGlobalStorageAttributes*); +SOAP_FMAC3 _stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_instantiate__stra__GetGlobalStorageAttributes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetGlobalStorageAttributes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__StorageApplicationAttributesType +#define SOAP_TYPE_stra__StorageApplicationAttributesType (274) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageApplicationAttributesType(struct soap*, const char*, int, const stra__StorageApplicationAttributesType *, const char*); +SOAP_FMAC3 stra__StorageApplicationAttributesType * SOAP_FMAC4 soap_get_stra__StorageApplicationAttributesType(struct soap*, stra__StorageApplicationAttributesType *, const char*, const char*); +SOAP_FMAC3 stra__StorageApplicationAttributesType * SOAP_FMAC4 soap_in_stra__StorageApplicationAttributesType(struct soap*, const char*, stra__StorageApplicationAttributesType *, const char*); +SOAP_FMAC5 stra__StorageApplicationAttributesType * SOAP_FMAC6 soap_new_stra__StorageApplicationAttributesType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageApplicationAttributesType(struct soap*, stra__StorageApplicationAttributesType*); +SOAP_FMAC3 stra__StorageApplicationAttributesType * SOAP_FMAC4 soap_instantiate_stra__StorageApplicationAttributesType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageApplicationAttributesType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__StorageSnrpApplicationAttributeType +#define SOAP_TYPE_stra__StorageSnrpApplicationAttributeType (273) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageSnrpApplicationAttributeType(struct soap*, const char*, int, const stra__StorageSnrpApplicationAttributeType *, const char*); +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType * SOAP_FMAC4 soap_get_stra__StorageSnrpApplicationAttributeType(struct soap*, stra__StorageSnrpApplicationAttributeType *, const char*, const char*); +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType * SOAP_FMAC4 soap_in_stra__StorageSnrpApplicationAttributeType(struct soap*, const char*, stra__StorageSnrpApplicationAttributeType *, const char*); +SOAP_FMAC5 stra__StorageSnrpApplicationAttributeType * SOAP_FMAC6 soap_new_stra__StorageSnrpApplicationAttributeType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageSnrpApplicationAttributeType(struct soap*, stra__StorageSnrpApplicationAttributeType*); +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType * SOAP_FMAC4 soap_instantiate_stra__StorageSnrpApplicationAttributeType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageSnrpApplicationAttributeType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__StorageApplicationHandleListType +#define SOAP_TYPE_stra__StorageApplicationHandleListType (272) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageApplicationHandleListType(struct soap*, const char*, int, const stra__StorageApplicationHandleListType *, const char*); +SOAP_FMAC3 stra__StorageApplicationHandleListType * SOAP_FMAC4 soap_get_stra__StorageApplicationHandleListType(struct soap*, stra__StorageApplicationHandleListType *, const char*, const char*); +SOAP_FMAC3 stra__StorageApplicationHandleListType * SOAP_FMAC4 soap_in_stra__StorageApplicationHandleListType(struct soap*, const char*, stra__StorageApplicationHandleListType *, const char*); +SOAP_FMAC5 stra__StorageApplicationHandleListType * SOAP_FMAC6 soap_new_stra__StorageApplicationHandleListType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageApplicationHandleListType(struct soap*, stra__StorageApplicationHandleListType*); +SOAP_FMAC3 stra__StorageApplicationHandleListType * SOAP_FMAC4 soap_instantiate_stra__StorageApplicationHandleListType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageApplicationHandleListType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__GlobalStorageAttributesType +#define SOAP_TYPE_stra__GlobalStorageAttributesType (271) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__GlobalStorageAttributesType(struct soap*, const char*, int, const stra__GlobalStorageAttributesType *, const char*); +SOAP_FMAC3 stra__GlobalStorageAttributesType * SOAP_FMAC4 soap_get_stra__GlobalStorageAttributesType(struct soap*, stra__GlobalStorageAttributesType *, const char*, const char*); +SOAP_FMAC3 stra__GlobalStorageAttributesType * SOAP_FMAC4 soap_in_stra__GlobalStorageAttributesType(struct soap*, const char*, stra__GlobalStorageAttributesType *, const char*); +SOAP_FMAC5 stra__GlobalStorageAttributesType * SOAP_FMAC6 soap_new_stra__GlobalStorageAttributesType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__GlobalStorageAttributesType(struct soap*, stra__GlobalStorageAttributesType*); +SOAP_FMAC3 stra__GlobalStorageAttributesType * SOAP_FMAC4 soap_instantiate_stra__GlobalStorageAttributesType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__GlobalStorageAttributesType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__GUID +#define SOAP_TYPE_stra__GUID (270) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__GUID(struct soap*, const char*, int, const stra__GUID *, const char*); +SOAP_FMAC3 stra__GUID * SOAP_FMAC4 soap_get_stra__GUID(struct soap*, stra__GUID *, const char*, const char*); +SOAP_FMAC3 stra__GUID * SOAP_FMAC4 soap_in_stra__GUID(struct soap*, const char*, stra__GUID *, const char*); +SOAP_FMAC5 stra__GUID * SOAP_FMAC6 soap_new_stra__GUID(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__GUID(struct soap*, stra__GUID*); +SOAP_FMAC3 stra__GUID * SOAP_FMAC4 soap_instantiate_stra__GUID(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__GUID(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__StorageAllocEntryHandleListType +#define SOAP_TYPE_stra__StorageAllocEntryHandleListType (269) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageAllocEntryHandleListType(struct soap*, const char*, int, const stra__StorageAllocEntryHandleListType *, const char*); +SOAP_FMAC3 stra__StorageAllocEntryHandleListType * SOAP_FMAC4 soap_get_stra__StorageAllocEntryHandleListType(struct soap*, stra__StorageAllocEntryHandleListType *, const char*, const char*); +SOAP_FMAC3 stra__StorageAllocEntryHandleListType * SOAP_FMAC4 soap_in_stra__StorageAllocEntryHandleListType(struct soap*, const char*, stra__StorageAllocEntryHandleListType *, const char*); +SOAP_FMAC5 stra__StorageAllocEntryHandleListType * SOAP_FMAC6 soap_new_stra__StorageAllocEntryHandleListType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageAllocEntryHandleListType(struct soap*, stra__StorageAllocEntryHandleListType*); +SOAP_FMAC3 stra__StorageAllocEntryHandleListType * SOAP_FMAC4 soap_instantiate_stra__StorageAllocEntryHandleListType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageAllocEntryHandleListType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__StorageAllocSnrpEntryType +#define SOAP_TYPE_stra__StorageAllocSnrpEntryType (268) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageAllocSnrpEntryType(struct soap*, const char*, int, const stra__StorageAllocSnrpEntryType *, const char*); +SOAP_FMAC3 stra__StorageAllocSnrpEntryType * SOAP_FMAC4 soap_get_stra__StorageAllocSnrpEntryType(struct soap*, stra__StorageAllocSnrpEntryType *, const char*, const char*); +SOAP_FMAC3 stra__StorageAllocSnrpEntryType * SOAP_FMAC4 soap_in_stra__StorageAllocSnrpEntryType(struct soap*, const char*, stra__StorageAllocSnrpEntryType *, const char*); +SOAP_FMAC5 stra__StorageAllocSnrpEntryType * SOAP_FMAC6 soap_new_stra__StorageAllocSnrpEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageAllocSnrpEntryType(struct soap*, stra__StorageAllocSnrpEntryType*); +SOAP_FMAC3 stra__StorageAllocSnrpEntryType * SOAP_FMAC4 soap_instantiate_stra__StorageAllocSnrpEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageAllocSnrpEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__StorageAllocEntryType +#define SOAP_TYPE_stra__StorageAllocEntryType (267) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageAllocEntryType(struct soap*, const char*, int, const stra__StorageAllocEntryType *, const char*); +SOAP_FMAC3 stra__StorageAllocEntryType * SOAP_FMAC4 soap_get_stra__StorageAllocEntryType(struct soap*, stra__StorageAllocEntryType *, const char*, const char*); +SOAP_FMAC3 stra__StorageAllocEntryType * SOAP_FMAC4 soap_in_stra__StorageAllocEntryType(struct soap*, const char*, stra__StorageAllocEntryType *, const char*); +SOAP_FMAC5 stra__StorageAllocEntryType * SOAP_FMAC6 soap_new_stra__StorageAllocEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageAllocEntryType(struct soap*, stra__StorageAllocEntryType*); +SOAP_FMAC3 stra__StorageAllocEntryType * SOAP_FMAC4 soap_instantiate_stra__StorageAllocEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageAllocEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__StorageEaclEntryHandleListType +#define SOAP_TYPE_stra__StorageEaclEntryHandleListType (266) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageEaclEntryHandleListType(struct soap*, const char*, int, const stra__StorageEaclEntryHandleListType *, const char*); +SOAP_FMAC3 stra__StorageEaclEntryHandleListType * SOAP_FMAC4 soap_get_stra__StorageEaclEntryHandleListType(struct soap*, stra__StorageEaclEntryHandleListType *, const char*, const char*); +SOAP_FMAC3 stra__StorageEaclEntryHandleListType * SOAP_FMAC4 soap_in_stra__StorageEaclEntryHandleListType(struct soap*, const char*, stra__StorageEaclEntryHandleListType *, const char*); +SOAP_FMAC5 stra__StorageEaclEntryHandleListType * SOAP_FMAC6 soap_new_stra__StorageEaclEntryHandleListType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageEaclEntryHandleListType(struct soap*, stra__StorageEaclEntryHandleListType*); +SOAP_FMAC3 stra__StorageEaclEntryHandleListType * SOAP_FMAC4 soap_instantiate_stra__StorageEaclEntryHandleListType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageEaclEntryHandleListType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_stra__StorageEaclEntryType +#define SOAP_TYPE_stra__StorageEaclEntryType (265) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageEaclEntryType(struct soap*, const char*, int, const stra__StorageEaclEntryType *, const char*); +SOAP_FMAC3 stra__StorageEaclEntryType * SOAP_FMAC4 soap_get_stra__StorageEaclEntryType(struct soap*, stra__StorageEaclEntryType *, const char*, const char*); +SOAP_FMAC3 stra__StorageEaclEntryType * SOAP_FMAC4 soap_in_stra__StorageEaclEntryType(struct soap*, const char*, stra__StorageEaclEntryType *, const char*); +SOAP_FMAC5 stra__StorageEaclEntryType * SOAP_FMAC6 soap_new_stra__StorageEaclEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageEaclEntryType(struct soap*, stra__StorageEaclEntryType*); +SOAP_FMAC3 stra__StorageEaclEntryType * SOAP_FMAC4 soap_instantiate_stra__StorageEaclEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageEaclEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Get8021XPxeTimeoutResponse +#define SOAP_TYPE__net__Get8021XPxeTimeoutResponse (264) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XPxeTimeoutResponse(struct soap*, const char*, int, const _net__Get8021XPxeTimeoutResponse *, const char*); +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse * SOAP_FMAC4 soap_get__net__Get8021XPxeTimeoutResponse(struct soap*, _net__Get8021XPxeTimeoutResponse *, const char*, const char*); +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse * SOAP_FMAC4 soap_in__net__Get8021XPxeTimeoutResponse(struct soap*, const char*, _net__Get8021XPxeTimeoutResponse *, const char*); +SOAP_FMAC5 _net__Get8021XPxeTimeoutResponse * SOAP_FMAC6 soap_new__net__Get8021XPxeTimeoutResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XPxeTimeoutResponse(struct soap*, _net__Get8021XPxeTimeoutResponse*); +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse * SOAP_FMAC4 soap_instantiate__net__Get8021XPxeTimeoutResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XPxeTimeoutResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Get8021XPxeTimeout +#define SOAP_TYPE__net__Get8021XPxeTimeout (263) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XPxeTimeout(struct soap*, const char*, int, const _net__Get8021XPxeTimeout *, const char*); +SOAP_FMAC3 _net__Get8021XPxeTimeout * SOAP_FMAC4 soap_get__net__Get8021XPxeTimeout(struct soap*, _net__Get8021XPxeTimeout *, const char*, const char*); +SOAP_FMAC3 _net__Get8021XPxeTimeout * SOAP_FMAC4 soap_in__net__Get8021XPxeTimeout(struct soap*, const char*, _net__Get8021XPxeTimeout *, const char*); +SOAP_FMAC5 _net__Get8021XPxeTimeout * SOAP_FMAC6 soap_new__net__Get8021XPxeTimeout(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XPxeTimeout(struct soap*, _net__Get8021XPxeTimeout*); +SOAP_FMAC3 _net__Get8021XPxeTimeout * SOAP_FMAC4 soap_instantiate__net__Get8021XPxeTimeout(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XPxeTimeout(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Set8021XPxeTimeoutResponse +#define SOAP_TYPE__net__Set8021XPxeTimeoutResponse (262) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XPxeTimeoutResponse(struct soap*, const char*, int, const _net__Set8021XPxeTimeoutResponse *, const char*); +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse * SOAP_FMAC4 soap_get__net__Set8021XPxeTimeoutResponse(struct soap*, _net__Set8021XPxeTimeoutResponse *, const char*, const char*); +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse * SOAP_FMAC4 soap_in__net__Set8021XPxeTimeoutResponse(struct soap*, const char*, _net__Set8021XPxeTimeoutResponse *, const char*); +SOAP_FMAC5 _net__Set8021XPxeTimeoutResponse * SOAP_FMAC6 soap_new__net__Set8021XPxeTimeoutResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XPxeTimeoutResponse(struct soap*, _net__Set8021XPxeTimeoutResponse*); +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse * SOAP_FMAC4 soap_instantiate__net__Set8021XPxeTimeoutResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XPxeTimeoutResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Set8021XPxeTimeout +#define SOAP_TYPE__net__Set8021XPxeTimeout (261) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XPxeTimeout(struct soap*, const char*, int, const _net__Set8021XPxeTimeout *, const char*); +SOAP_FMAC3 _net__Set8021XPxeTimeout * SOAP_FMAC4 soap_get__net__Set8021XPxeTimeout(struct soap*, _net__Set8021XPxeTimeout *, const char*, const char*); +SOAP_FMAC3 _net__Set8021XPxeTimeout * SOAP_FMAC4 soap_in__net__Set8021XPxeTimeout(struct soap*, const char*, _net__Set8021XPxeTimeout *, const char*); +SOAP_FMAC5 _net__Set8021XPxeTimeout * SOAP_FMAC6 soap_new__net__Set8021XPxeTimeout(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XPxeTimeout(struct soap*, _net__Set8021XPxeTimeout*); +SOAP_FMAC3 _net__Set8021XPxeTimeout * SOAP_FMAC4 soap_instantiate__net__Set8021XPxeTimeout(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XPxeTimeout(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Get8021XActiveS0Response +#define SOAP_TYPE__net__Get8021XActiveS0Response (260) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XActiveS0Response(struct soap*, const char*, int, const _net__Get8021XActiveS0Response *, const char*); +SOAP_FMAC3 _net__Get8021XActiveS0Response * SOAP_FMAC4 soap_get__net__Get8021XActiveS0Response(struct soap*, _net__Get8021XActiveS0Response *, const char*, const char*); +SOAP_FMAC3 _net__Get8021XActiveS0Response * SOAP_FMAC4 soap_in__net__Get8021XActiveS0Response(struct soap*, const char*, _net__Get8021XActiveS0Response *, const char*); +SOAP_FMAC5 _net__Get8021XActiveS0Response * SOAP_FMAC6 soap_new__net__Get8021XActiveS0Response(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XActiveS0Response(struct soap*, _net__Get8021XActiveS0Response*); +SOAP_FMAC3 _net__Get8021XActiveS0Response * SOAP_FMAC4 soap_instantiate__net__Get8021XActiveS0Response(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XActiveS0Response(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Get8021XActiveS0 +#define SOAP_TYPE__net__Get8021XActiveS0 (259) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XActiveS0(struct soap*, const char*, int, const _net__Get8021XActiveS0 *, const char*); +SOAP_FMAC3 _net__Get8021XActiveS0 * SOAP_FMAC4 soap_get__net__Get8021XActiveS0(struct soap*, _net__Get8021XActiveS0 *, const char*, const char*); +SOAP_FMAC3 _net__Get8021XActiveS0 * SOAP_FMAC4 soap_in__net__Get8021XActiveS0(struct soap*, const char*, _net__Get8021XActiveS0 *, const char*); +SOAP_FMAC5 _net__Get8021XActiveS0 * SOAP_FMAC6 soap_new__net__Get8021XActiveS0(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XActiveS0(struct soap*, _net__Get8021XActiveS0*); +SOAP_FMAC3 _net__Get8021XActiveS0 * SOAP_FMAC4 soap_instantiate__net__Get8021XActiveS0(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XActiveS0(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Set8021XActiveS0Response +#define SOAP_TYPE__net__Set8021XActiveS0Response (258) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XActiveS0Response(struct soap*, const char*, int, const _net__Set8021XActiveS0Response *, const char*); +SOAP_FMAC3 _net__Set8021XActiveS0Response * SOAP_FMAC4 soap_get__net__Set8021XActiveS0Response(struct soap*, _net__Set8021XActiveS0Response *, const char*, const char*); +SOAP_FMAC3 _net__Set8021XActiveS0Response * SOAP_FMAC4 soap_in__net__Set8021XActiveS0Response(struct soap*, const char*, _net__Set8021XActiveS0Response *, const char*); +SOAP_FMAC5 _net__Set8021XActiveS0Response * SOAP_FMAC6 soap_new__net__Set8021XActiveS0Response(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XActiveS0Response(struct soap*, _net__Set8021XActiveS0Response*); +SOAP_FMAC3 _net__Set8021XActiveS0Response * SOAP_FMAC4 soap_instantiate__net__Set8021XActiveS0Response(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XActiveS0Response(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Set8021XActiveS0 +#define SOAP_TYPE__net__Set8021XActiveS0 (257) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XActiveS0(struct soap*, const char*, int, const _net__Set8021XActiveS0 *, const char*); +SOAP_FMAC3 _net__Set8021XActiveS0 * SOAP_FMAC4 soap_get__net__Set8021XActiveS0(struct soap*, _net__Set8021XActiveS0 *, const char*, const char*); +SOAP_FMAC3 _net__Set8021XActiveS0 * SOAP_FMAC4 soap_in__net__Set8021XActiveS0(struct soap*, const char*, _net__Set8021XActiveS0 *, const char*); +SOAP_FMAC5 _net__Set8021XActiveS0 * SOAP_FMAC6 soap_new__net__Set8021XActiveS0(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XActiveS0(struct soap*, _net__Set8021XActiveS0*); +SOAP_FMAC3 _net__Set8021XActiveS0 * SOAP_FMAC4 soap_instantiate__net__Set8021XActiveS0(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XActiveS0(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Set8021XWiredProfileResponse +#define SOAP_TYPE__net__Set8021XWiredProfileResponse (256) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XWiredProfileResponse(struct soap*, const char*, int, const _net__Set8021XWiredProfileResponse *, const char*); +SOAP_FMAC3 _net__Set8021XWiredProfileResponse * SOAP_FMAC4 soap_get__net__Set8021XWiredProfileResponse(struct soap*, _net__Set8021XWiredProfileResponse *, const char*, const char*); +SOAP_FMAC3 _net__Set8021XWiredProfileResponse * SOAP_FMAC4 soap_in__net__Set8021XWiredProfileResponse(struct soap*, const char*, _net__Set8021XWiredProfileResponse *, const char*); +SOAP_FMAC5 _net__Set8021XWiredProfileResponse * SOAP_FMAC6 soap_new__net__Set8021XWiredProfileResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XWiredProfileResponse(struct soap*, _net__Set8021XWiredProfileResponse*); +SOAP_FMAC3 _net__Set8021XWiredProfileResponse * SOAP_FMAC4 soap_instantiate__net__Set8021XWiredProfileResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XWiredProfileResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Set8021XWiredProfile +#define SOAP_TYPE__net__Set8021XWiredProfile (255) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XWiredProfile(struct soap*, const char*, int, const _net__Set8021XWiredProfile *, const char*); +SOAP_FMAC3 _net__Set8021XWiredProfile * SOAP_FMAC4 soap_get__net__Set8021XWiredProfile(struct soap*, _net__Set8021XWiredProfile *, const char*, const char*); +SOAP_FMAC3 _net__Set8021XWiredProfile * SOAP_FMAC4 soap_in__net__Set8021XWiredProfile(struct soap*, const char*, _net__Set8021XWiredProfile *, const char*); +SOAP_FMAC5 _net__Set8021XWiredProfile * SOAP_FMAC6 soap_new__net__Set8021XWiredProfile(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XWiredProfile(struct soap*, _net__Set8021XWiredProfile*); +SOAP_FMAC3 _net__Set8021XWiredProfile * SOAP_FMAC4 soap_instantiate__net__Set8021XWiredProfile(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XWiredProfile(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Get8021XWiredProfileResponse +#define SOAP_TYPE__net__Get8021XWiredProfileResponse (254) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XWiredProfileResponse(struct soap*, const char*, int, const _net__Get8021XWiredProfileResponse *, const char*); +SOAP_FMAC3 _net__Get8021XWiredProfileResponse * SOAP_FMAC4 soap_get__net__Get8021XWiredProfileResponse(struct soap*, _net__Get8021XWiredProfileResponse *, const char*, const char*); +SOAP_FMAC3 _net__Get8021XWiredProfileResponse * SOAP_FMAC4 soap_in__net__Get8021XWiredProfileResponse(struct soap*, const char*, _net__Get8021XWiredProfileResponse *, const char*); +SOAP_FMAC5 _net__Get8021XWiredProfileResponse * SOAP_FMAC6 soap_new__net__Get8021XWiredProfileResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XWiredProfileResponse(struct soap*, _net__Get8021XWiredProfileResponse*); +SOAP_FMAC3 _net__Get8021XWiredProfileResponse * SOAP_FMAC4 soap_instantiate__net__Get8021XWiredProfileResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XWiredProfileResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__Get8021XWiredProfile +#define SOAP_TYPE__net__Get8021XWiredProfile (253) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XWiredProfile(struct soap*, const char*, int, const _net__Get8021XWiredProfile *, const char*); +SOAP_FMAC3 _net__Get8021XWiredProfile * SOAP_FMAC4 soap_get__net__Get8021XWiredProfile(struct soap*, _net__Get8021XWiredProfile *, const char*, const char*); +SOAP_FMAC3 _net__Get8021XWiredProfile * SOAP_FMAC4 soap_in__net__Get8021XWiredProfile(struct soap*, const char*, _net__Get8021XWiredProfile *, const char*); +SOAP_FMAC5 _net__Get8021XWiredProfile * SOAP_FMAC6 soap_new__net__Get8021XWiredProfile(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XWiredProfile(struct soap*, _net__Get8021XWiredProfile*); +SOAP_FMAC3 _net__Get8021XWiredProfile * SOAP_FMAC4 soap_instantiate__net__Get8021XWiredProfile(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XWiredProfile(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetInterfaceSettingsResponse +#define SOAP_TYPE__net__SetInterfaceSettingsResponse (252) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetInterfaceSettingsResponse(struct soap*, const char*, int, const _net__SetInterfaceSettingsResponse *, const char*); +SOAP_FMAC3 _net__SetInterfaceSettingsResponse * SOAP_FMAC4 soap_get__net__SetInterfaceSettingsResponse(struct soap*, _net__SetInterfaceSettingsResponse *, const char*, const char*); +SOAP_FMAC3 _net__SetInterfaceSettingsResponse * SOAP_FMAC4 soap_in__net__SetInterfaceSettingsResponse(struct soap*, const char*, _net__SetInterfaceSettingsResponse *, const char*); +SOAP_FMAC5 _net__SetInterfaceSettingsResponse * SOAP_FMAC6 soap_new__net__SetInterfaceSettingsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetInterfaceSettingsResponse(struct soap*, _net__SetInterfaceSettingsResponse*); +SOAP_FMAC3 _net__SetInterfaceSettingsResponse * SOAP_FMAC4 soap_instantiate__net__SetInterfaceSettingsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetInterfaceSettingsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetInterfaceSettings +#define SOAP_TYPE__net__SetInterfaceSettings (251) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetInterfaceSettings(struct soap*, const char*, int, const _net__SetInterfaceSettings *, const char*); +SOAP_FMAC3 _net__SetInterfaceSettings * SOAP_FMAC4 soap_get__net__SetInterfaceSettings(struct soap*, _net__SetInterfaceSettings *, const char*, const char*); +SOAP_FMAC3 _net__SetInterfaceSettings * SOAP_FMAC4 soap_in__net__SetInterfaceSettings(struct soap*, const char*, _net__SetInterfaceSettings *, const char*); +SOAP_FMAC5 _net__SetInterfaceSettings * SOAP_FMAC6 soap_new__net__SetInterfaceSettings(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetInterfaceSettings(struct soap*, _net__SetInterfaceSettings*); +SOAP_FMAC3 _net__SetInterfaceSettings * SOAP_FMAC4 soap_instantiate__net__SetInterfaceSettings(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetInterfaceSettings(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetInterfaceSettingsResponse +#define SOAP_TYPE__net__GetInterfaceSettingsResponse (250) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetInterfaceSettingsResponse(struct soap*, const char*, int, const _net__GetInterfaceSettingsResponse *, const char*); +SOAP_FMAC3 _net__GetInterfaceSettingsResponse * SOAP_FMAC4 soap_get__net__GetInterfaceSettingsResponse(struct soap*, _net__GetInterfaceSettingsResponse *, const char*, const char*); +SOAP_FMAC3 _net__GetInterfaceSettingsResponse * SOAP_FMAC4 soap_in__net__GetInterfaceSettingsResponse(struct soap*, const char*, _net__GetInterfaceSettingsResponse *, const char*); +SOAP_FMAC5 _net__GetInterfaceSettingsResponse * SOAP_FMAC6 soap_new__net__GetInterfaceSettingsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetInterfaceSettingsResponse(struct soap*, _net__GetInterfaceSettingsResponse*); +SOAP_FMAC3 _net__GetInterfaceSettingsResponse * SOAP_FMAC4 soap_instantiate__net__GetInterfaceSettingsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetInterfaceSettingsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetInterfaceSettings +#define SOAP_TYPE__net__GetInterfaceSettings (249) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetInterfaceSettings(struct soap*, const char*, int, const _net__GetInterfaceSettings *, const char*); +SOAP_FMAC3 _net__GetInterfaceSettings * SOAP_FMAC4 soap_get__net__GetInterfaceSettings(struct soap*, _net__GetInterfaceSettings *, const char*, const char*); +SOAP_FMAC3 _net__GetInterfaceSettings * SOAP_FMAC4 soap_in__net__GetInterfaceSettings(struct soap*, const char*, _net__GetInterfaceSettings *, const char*); +SOAP_FMAC5 _net__GetInterfaceSettings * SOAP_FMAC6 soap_new__net__GetInterfaceSettings(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetInterfaceSettings(struct soap*, _net__GetInterfaceSettings*); +SOAP_FMAC3 _net__GetInterfaceSettings * SOAP_FMAC4 soap_instantiate__net__GetInterfaceSettings(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetInterfaceSettings(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__EnumerateInterfacesResponse +#define SOAP_TYPE__net__EnumerateInterfacesResponse (248) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__EnumerateInterfacesResponse(struct soap*, const char*, int, const _net__EnumerateInterfacesResponse *, const char*); +SOAP_FMAC3 _net__EnumerateInterfacesResponse * SOAP_FMAC4 soap_get__net__EnumerateInterfacesResponse(struct soap*, _net__EnumerateInterfacesResponse *, const char*, const char*); +SOAP_FMAC3 _net__EnumerateInterfacesResponse * SOAP_FMAC4 soap_in__net__EnumerateInterfacesResponse(struct soap*, const char*, _net__EnumerateInterfacesResponse *, const char*); +SOAP_FMAC5 _net__EnumerateInterfacesResponse * SOAP_FMAC6 soap_new__net__EnumerateInterfacesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__EnumerateInterfacesResponse(struct soap*, _net__EnumerateInterfacesResponse*); +SOAP_FMAC3 _net__EnumerateInterfacesResponse * SOAP_FMAC4 soap_instantiate__net__EnumerateInterfacesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__EnumerateInterfacesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__EnumerateInterfaces +#define SOAP_TYPE__net__EnumerateInterfaces (247) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__EnumerateInterfaces(struct soap*, const char*, int, const _net__EnumerateInterfaces *, const char*); +SOAP_FMAC3 _net__EnumerateInterfaces * SOAP_FMAC4 soap_get__net__EnumerateInterfaces(struct soap*, _net__EnumerateInterfaces *, const char*, const char*); +SOAP_FMAC3 _net__EnumerateInterfaces * SOAP_FMAC4 soap_in__net__EnumerateInterfaces(struct soap*, const char*, _net__EnumerateInterfaces *, const char*); +SOAP_FMAC5 _net__EnumerateInterfaces * SOAP_FMAC6 soap_new__net__EnumerateInterfaces(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__EnumerateInterfaces(struct soap*, _net__EnumerateInterfaces*); +SOAP_FMAC3 _net__EnumerateInterfaces * SOAP_FMAC4 soap_instantiate__net__EnumerateInterfaces(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__EnumerateInterfaces(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetPingResponseResponse +#define SOAP_TYPE__net__GetPingResponseResponse (246) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetPingResponseResponse(struct soap*, const char*, int, const _net__GetPingResponseResponse *, const char*); +SOAP_FMAC3 _net__GetPingResponseResponse * SOAP_FMAC4 soap_get__net__GetPingResponseResponse(struct soap*, _net__GetPingResponseResponse *, const char*, const char*); +SOAP_FMAC3 _net__GetPingResponseResponse * SOAP_FMAC4 soap_in__net__GetPingResponseResponse(struct soap*, const char*, _net__GetPingResponseResponse *, const char*); +SOAP_FMAC5 _net__GetPingResponseResponse * SOAP_FMAC6 soap_new__net__GetPingResponseResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetPingResponseResponse(struct soap*, _net__GetPingResponseResponse*); +SOAP_FMAC3 _net__GetPingResponseResponse * SOAP_FMAC4 soap_instantiate__net__GetPingResponseResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetPingResponseResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetPingResponse +#define SOAP_TYPE__net__GetPingResponse (245) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetPingResponse(struct soap*, const char*, int, const _net__GetPingResponse *, const char*); +SOAP_FMAC3 _net__GetPingResponse * SOAP_FMAC4 soap_get__net__GetPingResponse(struct soap*, _net__GetPingResponse *, const char*, const char*); +SOAP_FMAC3 _net__GetPingResponse * SOAP_FMAC4 soap_in__net__GetPingResponse(struct soap*, const char*, _net__GetPingResponse *, const char*); +SOAP_FMAC5 _net__GetPingResponse * SOAP_FMAC6 soap_new__net__GetPingResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetPingResponse(struct soap*, _net__GetPingResponse*); +SOAP_FMAC3 _net__GetPingResponse * SOAP_FMAC4 soap_instantiate__net__GetPingResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetPingResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetPingResponseResponse +#define SOAP_TYPE__net__SetPingResponseResponse (244) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetPingResponseResponse(struct soap*, const char*, int, const _net__SetPingResponseResponse *, const char*); +SOAP_FMAC3 _net__SetPingResponseResponse * SOAP_FMAC4 soap_get__net__SetPingResponseResponse(struct soap*, _net__SetPingResponseResponse *, const char*, const char*); +SOAP_FMAC3 _net__SetPingResponseResponse * SOAP_FMAC4 soap_in__net__SetPingResponseResponse(struct soap*, const char*, _net__SetPingResponseResponse *, const char*); +SOAP_FMAC5 _net__SetPingResponseResponse * SOAP_FMAC6 soap_new__net__SetPingResponseResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetPingResponseResponse(struct soap*, _net__SetPingResponseResponse*); +SOAP_FMAC3 _net__SetPingResponseResponse * SOAP_FMAC4 soap_instantiate__net__SetPingResponseResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetPingResponseResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetPingResponse +#define SOAP_TYPE__net__SetPingResponse (243) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetPingResponse(struct soap*, const char*, int, const _net__SetPingResponse *, const char*); +SOAP_FMAC3 _net__SetPingResponse * SOAP_FMAC4 soap_get__net__SetPingResponse(struct soap*, _net__SetPingResponse *, const char*, const char*); +SOAP_FMAC3 _net__SetPingResponse * SOAP_FMAC4 soap_in__net__SetPingResponse(struct soap*, const char*, _net__SetPingResponse *, const char*); +SOAP_FMAC5 _net__SetPingResponse * SOAP_FMAC6 soap_new__net__SetPingResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetPingResponse(struct soap*, _net__SetPingResponse*); +SOAP_FMAC3 _net__SetPingResponse * SOAP_FMAC4 soap_instantiate__net__SetPingResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetPingResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetVlanParametersResponse +#define SOAP_TYPE__net__GetVlanParametersResponse (242) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetVlanParametersResponse(struct soap*, const char*, int, const _net__GetVlanParametersResponse *, const char*); +SOAP_FMAC3 _net__GetVlanParametersResponse * SOAP_FMAC4 soap_get__net__GetVlanParametersResponse(struct soap*, _net__GetVlanParametersResponse *, const char*, const char*); +SOAP_FMAC3 _net__GetVlanParametersResponse * SOAP_FMAC4 soap_in__net__GetVlanParametersResponse(struct soap*, const char*, _net__GetVlanParametersResponse *, const char*); +SOAP_FMAC5 _net__GetVlanParametersResponse * SOAP_FMAC6 soap_new__net__GetVlanParametersResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetVlanParametersResponse(struct soap*, _net__GetVlanParametersResponse*); +SOAP_FMAC3 _net__GetVlanParametersResponse * SOAP_FMAC4 soap_instantiate__net__GetVlanParametersResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetVlanParametersResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetVlanParameters +#define SOAP_TYPE__net__GetVlanParameters (241) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetVlanParameters(struct soap*, const char*, int, const _net__GetVlanParameters *, const char*); +SOAP_FMAC3 _net__GetVlanParameters * SOAP_FMAC4 soap_get__net__GetVlanParameters(struct soap*, _net__GetVlanParameters *, const char*, const char*); +SOAP_FMAC3 _net__GetVlanParameters * SOAP_FMAC4 soap_in__net__GetVlanParameters(struct soap*, const char*, _net__GetVlanParameters *, const char*); +SOAP_FMAC5 _net__GetVlanParameters * SOAP_FMAC6 soap_new__net__GetVlanParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetVlanParameters(struct soap*, _net__GetVlanParameters*); +SOAP_FMAC3 _net__GetVlanParameters * SOAP_FMAC4 soap_instantiate__net__GetVlanParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetVlanParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetVlanParametersResponse +#define SOAP_TYPE__net__SetVlanParametersResponse (240) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetVlanParametersResponse(struct soap*, const char*, int, const _net__SetVlanParametersResponse *, const char*); +SOAP_FMAC3 _net__SetVlanParametersResponse * SOAP_FMAC4 soap_get__net__SetVlanParametersResponse(struct soap*, _net__SetVlanParametersResponse *, const char*, const char*); +SOAP_FMAC3 _net__SetVlanParametersResponse * SOAP_FMAC4 soap_in__net__SetVlanParametersResponse(struct soap*, const char*, _net__SetVlanParametersResponse *, const char*); +SOAP_FMAC5 _net__SetVlanParametersResponse * SOAP_FMAC6 soap_new__net__SetVlanParametersResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetVlanParametersResponse(struct soap*, _net__SetVlanParametersResponse*); +SOAP_FMAC3 _net__SetVlanParametersResponse * SOAP_FMAC4 soap_instantiate__net__SetVlanParametersResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetVlanParametersResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetVlanParameters +#define SOAP_TYPE__net__SetVlanParameters (239) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetVlanParameters(struct soap*, const char*, int, const _net__SetVlanParameters *, const char*); +SOAP_FMAC3 _net__SetVlanParameters * SOAP_FMAC4 soap_get__net__SetVlanParameters(struct soap*, _net__SetVlanParameters *, const char*, const char*); +SOAP_FMAC3 _net__SetVlanParameters * SOAP_FMAC4 soap_in__net__SetVlanParameters(struct soap*, const char*, _net__SetVlanParameters *, const char*); +SOAP_FMAC5 _net__SetVlanParameters * SOAP_FMAC6 soap_new__net__SetVlanParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetVlanParameters(struct soap*, _net__SetVlanParameters*); +SOAP_FMAC3 _net__SetVlanParameters * SOAP_FMAC4 soap_instantiate__net__SetVlanParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetVlanParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetTcpIpParametersResponse +#define SOAP_TYPE__net__GetTcpIpParametersResponse (238) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetTcpIpParametersResponse(struct soap*, const char*, int, const _net__GetTcpIpParametersResponse *, const char*); +SOAP_FMAC3 _net__GetTcpIpParametersResponse * SOAP_FMAC4 soap_get__net__GetTcpIpParametersResponse(struct soap*, _net__GetTcpIpParametersResponse *, const char*, const char*); +SOAP_FMAC3 _net__GetTcpIpParametersResponse * SOAP_FMAC4 soap_in__net__GetTcpIpParametersResponse(struct soap*, const char*, _net__GetTcpIpParametersResponse *, const char*); +SOAP_FMAC5 _net__GetTcpIpParametersResponse * SOAP_FMAC6 soap_new__net__GetTcpIpParametersResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetTcpIpParametersResponse(struct soap*, _net__GetTcpIpParametersResponse*); +SOAP_FMAC3 _net__GetTcpIpParametersResponse * SOAP_FMAC4 soap_instantiate__net__GetTcpIpParametersResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetTcpIpParametersResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetTcpIpParameters +#define SOAP_TYPE__net__GetTcpIpParameters (237) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetTcpIpParameters(struct soap*, const char*, int, const _net__GetTcpIpParameters *, const char*); +SOAP_FMAC3 _net__GetTcpIpParameters * SOAP_FMAC4 soap_get__net__GetTcpIpParameters(struct soap*, _net__GetTcpIpParameters *, const char*, const char*); +SOAP_FMAC3 _net__GetTcpIpParameters * SOAP_FMAC4 soap_in__net__GetTcpIpParameters(struct soap*, const char*, _net__GetTcpIpParameters *, const char*); +SOAP_FMAC5 _net__GetTcpIpParameters * SOAP_FMAC6 soap_new__net__GetTcpIpParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetTcpIpParameters(struct soap*, _net__GetTcpIpParameters*); +SOAP_FMAC3 _net__GetTcpIpParameters * SOAP_FMAC4 soap_instantiate__net__GetTcpIpParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetTcpIpParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetTcpIpParametersResponse +#define SOAP_TYPE__net__SetTcpIpParametersResponse (236) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetTcpIpParametersResponse(struct soap*, const char*, int, const _net__SetTcpIpParametersResponse *, const char*); +SOAP_FMAC3 _net__SetTcpIpParametersResponse * SOAP_FMAC4 soap_get__net__SetTcpIpParametersResponse(struct soap*, _net__SetTcpIpParametersResponse *, const char*, const char*); +SOAP_FMAC3 _net__SetTcpIpParametersResponse * SOAP_FMAC4 soap_in__net__SetTcpIpParametersResponse(struct soap*, const char*, _net__SetTcpIpParametersResponse *, const char*); +SOAP_FMAC5 _net__SetTcpIpParametersResponse * SOAP_FMAC6 soap_new__net__SetTcpIpParametersResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetTcpIpParametersResponse(struct soap*, _net__SetTcpIpParametersResponse*); +SOAP_FMAC3 _net__SetTcpIpParametersResponse * SOAP_FMAC4 soap_instantiate__net__SetTcpIpParametersResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetTcpIpParametersResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetTcpIpParameters +#define SOAP_TYPE__net__SetTcpIpParameters (235) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetTcpIpParameters(struct soap*, const char*, int, const _net__SetTcpIpParameters *, const char*); +SOAP_FMAC3 _net__SetTcpIpParameters * SOAP_FMAC4 soap_get__net__SetTcpIpParameters(struct soap*, _net__SetTcpIpParameters *, const char*, const char*); +SOAP_FMAC3 _net__SetTcpIpParameters * SOAP_FMAC4 soap_in__net__SetTcpIpParameters(struct soap*, const char*, _net__SetTcpIpParameters *, const char*); +SOAP_FMAC5 _net__SetTcpIpParameters * SOAP_FMAC6 soap_new__net__SetTcpIpParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetTcpIpParameters(struct soap*, _net__SetTcpIpParameters*); +SOAP_FMAC3 _net__SetTcpIpParameters * SOAP_FMAC4 soap_instantiate__net__SetTcpIpParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetTcpIpParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetDomainNameResponse +#define SOAP_TYPE__net__GetDomainNameResponse (234) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetDomainNameResponse(struct soap*, const char*, int, const _net__GetDomainNameResponse *, const char*); +SOAP_FMAC3 _net__GetDomainNameResponse * SOAP_FMAC4 soap_get__net__GetDomainNameResponse(struct soap*, _net__GetDomainNameResponse *, const char*, const char*); +SOAP_FMAC3 _net__GetDomainNameResponse * SOAP_FMAC4 soap_in__net__GetDomainNameResponse(struct soap*, const char*, _net__GetDomainNameResponse *, const char*); +SOAP_FMAC5 _net__GetDomainNameResponse * SOAP_FMAC6 soap_new__net__GetDomainNameResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetDomainNameResponse(struct soap*, _net__GetDomainNameResponse*); +SOAP_FMAC3 _net__GetDomainNameResponse * SOAP_FMAC4 soap_instantiate__net__GetDomainNameResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetDomainNameResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetDomainName +#define SOAP_TYPE__net__GetDomainName (233) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetDomainName(struct soap*, const char*, int, const _net__GetDomainName *, const char*); +SOAP_FMAC3 _net__GetDomainName * SOAP_FMAC4 soap_get__net__GetDomainName(struct soap*, _net__GetDomainName *, const char*, const char*); +SOAP_FMAC3 _net__GetDomainName * SOAP_FMAC4 soap_in__net__GetDomainName(struct soap*, const char*, _net__GetDomainName *, const char*); +SOAP_FMAC5 _net__GetDomainName * SOAP_FMAC6 soap_new__net__GetDomainName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetDomainName(struct soap*, _net__GetDomainName*); +SOAP_FMAC3 _net__GetDomainName * SOAP_FMAC4 soap_instantiate__net__GetDomainName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetDomainName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetDomainNameResponse +#define SOAP_TYPE__net__SetDomainNameResponse (232) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetDomainNameResponse(struct soap*, const char*, int, const _net__SetDomainNameResponse *, const char*); +SOAP_FMAC3 _net__SetDomainNameResponse * SOAP_FMAC4 soap_get__net__SetDomainNameResponse(struct soap*, _net__SetDomainNameResponse *, const char*, const char*); +SOAP_FMAC3 _net__SetDomainNameResponse * SOAP_FMAC4 soap_in__net__SetDomainNameResponse(struct soap*, const char*, _net__SetDomainNameResponse *, const char*); +SOAP_FMAC5 _net__SetDomainNameResponse * SOAP_FMAC6 soap_new__net__SetDomainNameResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetDomainNameResponse(struct soap*, _net__SetDomainNameResponse*); +SOAP_FMAC3 _net__SetDomainNameResponse * SOAP_FMAC4 soap_instantiate__net__SetDomainNameResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetDomainNameResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetDomainName +#define SOAP_TYPE__net__SetDomainName (231) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetDomainName(struct soap*, const char*, int, const _net__SetDomainName *, const char*); +SOAP_FMAC3 _net__SetDomainName * SOAP_FMAC4 soap_get__net__SetDomainName(struct soap*, _net__SetDomainName *, const char*, const char*); +SOAP_FMAC3 _net__SetDomainName * SOAP_FMAC4 soap_in__net__SetDomainName(struct soap*, const char*, _net__SetDomainName *, const char*); +SOAP_FMAC5 _net__SetDomainName * SOAP_FMAC6 soap_new__net__SetDomainName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetDomainName(struct soap*, _net__SetDomainName*); +SOAP_FMAC3 _net__SetDomainName * SOAP_FMAC4 soap_instantiate__net__SetDomainName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetDomainName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetHostNameResponse +#define SOAP_TYPE__net__GetHostNameResponse (230) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetHostNameResponse(struct soap*, const char*, int, const _net__GetHostNameResponse *, const char*); +SOAP_FMAC3 _net__GetHostNameResponse * SOAP_FMAC4 soap_get__net__GetHostNameResponse(struct soap*, _net__GetHostNameResponse *, const char*, const char*); +SOAP_FMAC3 _net__GetHostNameResponse * SOAP_FMAC4 soap_in__net__GetHostNameResponse(struct soap*, const char*, _net__GetHostNameResponse *, const char*); +SOAP_FMAC5 _net__GetHostNameResponse * SOAP_FMAC6 soap_new__net__GetHostNameResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetHostNameResponse(struct soap*, _net__GetHostNameResponse*); +SOAP_FMAC3 _net__GetHostNameResponse * SOAP_FMAC4 soap_instantiate__net__GetHostNameResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetHostNameResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__GetHostName +#define SOAP_TYPE__net__GetHostName (229) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetHostName(struct soap*, const char*, int, const _net__GetHostName *, const char*); +SOAP_FMAC3 _net__GetHostName * SOAP_FMAC4 soap_get__net__GetHostName(struct soap*, _net__GetHostName *, const char*, const char*); +SOAP_FMAC3 _net__GetHostName * SOAP_FMAC4 soap_in__net__GetHostName(struct soap*, const char*, _net__GetHostName *, const char*); +SOAP_FMAC5 _net__GetHostName * SOAP_FMAC6 soap_new__net__GetHostName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetHostName(struct soap*, _net__GetHostName*); +SOAP_FMAC3 _net__GetHostName * SOAP_FMAC4 soap_instantiate__net__GetHostName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetHostName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetHostNameResponse +#define SOAP_TYPE__net__SetHostNameResponse (228) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetHostNameResponse(struct soap*, const char*, int, const _net__SetHostNameResponse *, const char*); +SOAP_FMAC3 _net__SetHostNameResponse * SOAP_FMAC4 soap_get__net__SetHostNameResponse(struct soap*, _net__SetHostNameResponse *, const char*, const char*); +SOAP_FMAC3 _net__SetHostNameResponse * SOAP_FMAC4 soap_in__net__SetHostNameResponse(struct soap*, const char*, _net__SetHostNameResponse *, const char*); +SOAP_FMAC5 _net__SetHostNameResponse * SOAP_FMAC6 soap_new__net__SetHostNameResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetHostNameResponse(struct soap*, _net__SetHostNameResponse*); +SOAP_FMAC3 _net__SetHostNameResponse * SOAP_FMAC4 soap_instantiate__net__SetHostNameResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetHostNameResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__net__SetHostName +#define SOAP_TYPE__net__SetHostName (227) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetHostName(struct soap*, const char*, int, const _net__SetHostName *, const char*); +SOAP_FMAC3 _net__SetHostName * SOAP_FMAC4 soap_get__net__SetHostName(struct soap*, _net__SetHostName *, const char*, const char*); +SOAP_FMAC3 _net__SetHostName * SOAP_FMAC4 soap_in__net__SetHostName(struct soap*, const char*, _net__SetHostName *, const char*); +SOAP_FMAC5 _net__SetHostName * SOAP_FMAC6 soap_new__net__SetHostName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetHostName(struct soap*, _net__SetHostName*); +SOAP_FMAC3 _net__SetHostName * SOAP_FMAC4 soap_instantiate__net__SetHostName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetHostName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_net__InterfaceDescriptorGetType +#define SOAP_TYPE_net__InterfaceDescriptorGetType (226) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__InterfaceDescriptorGetType(struct soap*, const char*, int, const net__InterfaceDescriptorGetType *, const char*); +SOAP_FMAC3 net__InterfaceDescriptorGetType * SOAP_FMAC4 soap_get_net__InterfaceDescriptorGetType(struct soap*, net__InterfaceDescriptorGetType *, const char*, const char*); +SOAP_FMAC3 net__InterfaceDescriptorGetType * SOAP_FMAC4 soap_in_net__InterfaceDescriptorGetType(struct soap*, const char*, net__InterfaceDescriptorGetType *, const char*); +SOAP_FMAC5 net__InterfaceDescriptorGetType * SOAP_FMAC6 soap_new_net__InterfaceDescriptorGetType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__InterfaceDescriptorGetType(struct soap*, net__InterfaceDescriptorGetType*); +SOAP_FMAC3 net__InterfaceDescriptorGetType * SOAP_FMAC4 soap_instantiate_net__InterfaceDescriptorGetType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__InterfaceDescriptorGetType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_net__InterfaceDescriptorSetType +#define SOAP_TYPE_net__InterfaceDescriptorSetType (225) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__InterfaceDescriptorSetType(struct soap*, const char*, int, const net__InterfaceDescriptorSetType *, const char*); +SOAP_FMAC3 net__InterfaceDescriptorSetType * SOAP_FMAC4 soap_get_net__InterfaceDescriptorSetType(struct soap*, net__InterfaceDescriptorSetType *, const char*, const char*); +SOAP_FMAC3 net__InterfaceDescriptorSetType * SOAP_FMAC4 soap_in_net__InterfaceDescriptorSetType(struct soap*, const char*, net__InterfaceDescriptorSetType *, const char*); +SOAP_FMAC5 net__InterfaceDescriptorSetType * SOAP_FMAC6 soap_new_net__InterfaceDescriptorSetType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__InterfaceDescriptorSetType(struct soap*, net__InterfaceDescriptorSetType*); +SOAP_FMAC3 net__InterfaceDescriptorSetType * SOAP_FMAC4 soap_instantiate_net__InterfaceDescriptorSetType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__InterfaceDescriptorSetType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_net__IPv4ParametersType +#define SOAP_TYPE_net__IPv4ParametersType (224) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__IPv4ParametersType(struct soap*, const char*, int, const net__IPv4ParametersType *, const char*); +SOAP_FMAC3 net__IPv4ParametersType * SOAP_FMAC4 soap_get_net__IPv4ParametersType(struct soap*, net__IPv4ParametersType *, const char*, const char*); +SOAP_FMAC3 net__IPv4ParametersType * SOAP_FMAC4 soap_in_net__IPv4ParametersType(struct soap*, const char*, net__IPv4ParametersType *, const char*); +SOAP_FMAC5 net__IPv4ParametersType * SOAP_FMAC6 soap_new_net__IPv4ParametersType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__IPv4ParametersType(struct soap*, net__IPv4ParametersType*); +SOAP_FMAC3 net__IPv4ParametersType * SOAP_FMAC4 soap_instantiate_net__IPv4ParametersType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__IPv4ParametersType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_net__StaticIPv4ParametersType +#define SOAP_TYPE_net__StaticIPv4ParametersType (223) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__StaticIPv4ParametersType(struct soap*, const char*, int, const net__StaticIPv4ParametersType *, const char*); +SOAP_FMAC3 net__StaticIPv4ParametersType * SOAP_FMAC4 soap_get_net__StaticIPv4ParametersType(struct soap*, net__StaticIPv4ParametersType *, const char*, const char*); +SOAP_FMAC3 net__StaticIPv4ParametersType * SOAP_FMAC4 soap_in_net__StaticIPv4ParametersType(struct soap*, const char*, net__StaticIPv4ParametersType *, const char*); +SOAP_FMAC5 net__StaticIPv4ParametersType * SOAP_FMAC6 soap_new_net__StaticIPv4ParametersType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__StaticIPv4ParametersType(struct soap*, net__StaticIPv4ParametersType*); +SOAP_FMAC3 net__StaticIPv4ParametersType * SOAP_FMAC4 soap_instantiate_net__StaticIPv4ParametersType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__StaticIPv4ParametersType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__XProfileType +#define SOAP_TYPE_xcfg__XProfileType (222) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileType(struct soap*, const char*, int, const xcfg__XProfileType *, const char*); +SOAP_FMAC3 xcfg__XProfileType * SOAP_FMAC4 soap_get_xcfg__XProfileType(struct soap*, xcfg__XProfileType *, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileType * SOAP_FMAC4 soap_in_xcfg__XProfileType(struct soap*, const char*, xcfg__XProfileType *, const char*); +SOAP_FMAC5 xcfg__XProfileType * SOAP_FMAC6 soap_new_xcfg__XProfileType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileType(struct soap*, xcfg__XProfileType*); +SOAP_FMAC3 xcfg__XProfileType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType +#define SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType (221) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileEAPFAST_USCORETLSType(struct soap*, const char*, int, const xcfg__XProfileEAPFAST_USCORETLSType *, const char*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType * SOAP_FMAC4 soap_get_xcfg__XProfileEAPFAST_USCORETLSType(struct soap*, xcfg__XProfileEAPFAST_USCORETLSType *, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType * SOAP_FMAC4 soap_in_xcfg__XProfileEAPFAST_USCORETLSType(struct soap*, const char*, xcfg__XProfileEAPFAST_USCORETLSType *, const char*); +SOAP_FMAC5 xcfg__XProfileEAPFAST_USCORETLSType * SOAP_FMAC6 soap_new_xcfg__XProfileEAPFAST_USCORETLSType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileEAPFAST_USCORETLSType(struct soap*, xcfg__XProfileEAPFAST_USCORETLSType*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileEAPFAST_USCORETLSType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileEAPFAST_USCORETLSType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType +#define SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType (220) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, const char*, int, const xcfg__XProfileEAPFAST_USCOREGTCType *, const char*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType * SOAP_FMAC4 soap_get_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, xcfg__XProfileEAPFAST_USCOREGTCType *, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType * SOAP_FMAC4 soap_in_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, const char*, xcfg__XProfileEAPFAST_USCOREGTCType *, const char*); +SOAP_FMAC5 xcfg__XProfileEAPFAST_USCOREGTCType * SOAP_FMAC6 soap_new_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, xcfg__XProfileEAPFAST_USCOREGTCType*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type +#define SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type (219) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, const char*, int, const xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *, const char*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_get_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_in_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, const char*, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *, const char*); +SOAP_FMAC5 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type * SOAP_FMAC6 soap_new_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_instantiate_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType +#define SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType (218) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileEAP_USCOREGTCType(struct soap*, const char*, int, const xcfg__XProfileEAP_USCOREGTCType *, const char*); +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType * SOAP_FMAC4 soap_get_xcfg__XProfileEAP_USCOREGTCType(struct soap*, xcfg__XProfileEAP_USCOREGTCType *, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType * SOAP_FMAC4 soap_in_xcfg__XProfileEAP_USCOREGTCType(struct soap*, const char*, xcfg__XProfileEAP_USCOREGTCType *, const char*); +SOAP_FMAC5 xcfg__XProfileEAP_USCOREGTCType * SOAP_FMAC6 soap_new_xcfg__XProfileEAP_USCOREGTCType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileEAP_USCOREGTCType(struct soap*, xcfg__XProfileEAP_USCOREGTCType*); +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileEAP_USCOREGTCType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileEAP_USCOREGTCType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type +#define SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type (217) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, const char*, int, const xcfg__XProfilePEAP_USCOREMSCHAPv2Type *, const char*); +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_get_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *, const char*, const char*); +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_in_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, const char*, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *, const char*); +SOAP_FMAC5 xcfg__XProfilePEAP_USCOREMSCHAPv2Type * SOAP_FMAC6 soap_new_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfilePEAP_USCOREMSCHAPv2Type*); +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_instantiate_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type +#define SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type (216) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, const char*, int, const xcfg__XProfileTTLS_USCOREMSCHAPv2Type *, const char*); +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_get_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_in_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, const char*, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *, const char*); +SOAP_FMAC5 xcfg__XProfileTTLS_USCOREMSCHAPv2Type * SOAP_FMAC6 soap_new_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileTTLS_USCOREMSCHAPv2Type*); +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_instantiate_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__XProfileTLSType +#define SOAP_TYPE_xcfg__XProfileTLSType (215) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileTLSType(struct soap*, const char*, int, const xcfg__XProfileTLSType *, const char*); +SOAP_FMAC3 xcfg__XProfileTLSType * SOAP_FMAC4 soap_get_xcfg__XProfileTLSType(struct soap*, xcfg__XProfileTLSType *, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileTLSType * SOAP_FMAC4 soap_in_xcfg__XProfileTLSType(struct soap*, const char*, xcfg__XProfileTLSType *, const char*); +SOAP_FMAC5 xcfg__XProfileTLSType * SOAP_FMAC6 soap_new_xcfg__XProfileTLSType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileTLSType(struct soap*, xcfg__XProfileTLSType*); +SOAP_FMAC3 xcfg__XProfileTLSType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileTLSType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileTLSType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__ServerIdentityType +#define SOAP_TYPE_xcfg__ServerIdentityType (214) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__ServerIdentityType(struct soap*, const char*, int, const xcfg__ServerIdentityType *, const char*); +SOAP_FMAC3 xcfg__ServerIdentityType * SOAP_FMAC4 soap_get_xcfg__ServerIdentityType(struct soap*, xcfg__ServerIdentityType *, const char*, const char*); +SOAP_FMAC3 xcfg__ServerIdentityType * SOAP_FMAC4 soap_in_xcfg__ServerIdentityType(struct soap*, const char*, xcfg__ServerIdentityType *, const char*); +SOAP_FMAC5 xcfg__ServerIdentityType * SOAP_FMAC6 soap_new_xcfg__ServerIdentityType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__ServerIdentityType(struct soap*, xcfg__ServerIdentityType*); +SOAP_FMAC3 xcfg__ServerIdentityType * SOAP_FMAC4 soap_instantiate_xcfg__ServerIdentityType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__ServerIdentityType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__ManualPACType +#define SOAP_TYPE_xcfg__ManualPACType (213) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__ManualPACType(struct soap*, const char*, int, const xcfg__ManualPACType *, const char*); +SOAP_FMAC3 xcfg__ManualPACType * SOAP_FMAC4 soap_get_xcfg__ManualPACType(struct soap*, xcfg__ManualPACType *, const char*, const char*); +SOAP_FMAC3 xcfg__ManualPACType * SOAP_FMAC4 soap_in_xcfg__ManualPACType(struct soap*, const char*, xcfg__ManualPACType *, const char*); +SOAP_FMAC5 xcfg__ManualPACType * SOAP_FMAC6 soap_new_xcfg__ManualPACType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__ManualPACType(struct soap*, xcfg__ManualPACType*); +SOAP_FMAC3 xcfg__ManualPACType * SOAP_FMAC4 soap_instantiate_xcfg__ManualPACType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__ManualPACType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__CertificateNameType +#define SOAP_TYPE_xcfg__CertificateNameType (212) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__CertificateNameType(struct soap*, const char*, int, const xcfg__CertificateNameType *, const char*); +SOAP_FMAC3 xcfg__CertificateNameType * SOAP_FMAC4 soap_get_xcfg__CertificateNameType(struct soap*, xcfg__CertificateNameType *, const char*, const char*); +SOAP_FMAC3 xcfg__CertificateNameType * SOAP_FMAC4 soap_in_xcfg__CertificateNameType(struct soap*, const char*, xcfg__CertificateNameType *, const char*); +SOAP_FMAC5 xcfg__CertificateNameType * SOAP_FMAC6 soap_new_xcfg__CertificateNameType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__CertificateNameType(struct soap*, xcfg__CertificateNameType*); +SOAP_FMAC3 xcfg__CertificateNameType * SOAP_FMAC4 soap_instantiate_xcfg__CertificateNameType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__CertificateNameType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xcfg__UserCredentialsType +#define SOAP_TYPE_xcfg__UserCredentialsType (211) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__UserCredentialsType(struct soap*, const char*, int, const xcfg__UserCredentialsType *, const char*); +SOAP_FMAC3 xcfg__UserCredentialsType * SOAP_FMAC4 soap_get_xcfg__UserCredentialsType(struct soap*, xcfg__UserCredentialsType *, const char*, const char*); +SOAP_FMAC3 xcfg__UserCredentialsType * SOAP_FMAC4 soap_in_xcfg__UserCredentialsType(struct soap*, const char*, xcfg__UserCredentialsType *, const char*); +SOAP_FMAC5 xcfg__UserCredentialsType * SOAP_FMAC6 soap_new_xcfg__UserCredentialsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__UserCredentialsType(struct soap*, xcfg__UserCredentialsType*); +SOAP_FMAC3 xcfg__UserCredentialsType * SOAP_FMAC4 soap_instantiate_xcfg__UserCredentialsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__UserCredentialsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetAclEnabledStateResponse +#define SOAP_TYPE__sai__GetAclEnabledStateResponse (210) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetAclEnabledStateResponse(struct soap*, const char*, int, const _sai__GetAclEnabledStateResponse *, const char*); +SOAP_FMAC3 _sai__GetAclEnabledStateResponse * SOAP_FMAC4 soap_get__sai__GetAclEnabledStateResponse(struct soap*, _sai__GetAclEnabledStateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetAclEnabledStateResponse * SOAP_FMAC4 soap_in__sai__GetAclEnabledStateResponse(struct soap*, const char*, _sai__GetAclEnabledStateResponse *, const char*); +SOAP_FMAC5 _sai__GetAclEnabledStateResponse * SOAP_FMAC6 soap_new__sai__GetAclEnabledStateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetAclEnabledStateResponse(struct soap*, _sai__GetAclEnabledStateResponse*); +SOAP_FMAC3 _sai__GetAclEnabledStateResponse * SOAP_FMAC4 soap_instantiate__sai__GetAclEnabledStateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetAclEnabledStateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetAclEnabledState +#define SOAP_TYPE__sai__GetAclEnabledState (209) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetAclEnabledState(struct soap*, const char*, int, const _sai__GetAclEnabledState *, const char*); +SOAP_FMAC3 _sai__GetAclEnabledState * SOAP_FMAC4 soap_get__sai__GetAclEnabledState(struct soap*, _sai__GetAclEnabledState *, const char*, const char*); +SOAP_FMAC3 _sai__GetAclEnabledState * SOAP_FMAC4 soap_in__sai__GetAclEnabledState(struct soap*, const char*, _sai__GetAclEnabledState *, const char*); +SOAP_FMAC5 _sai__GetAclEnabledState * SOAP_FMAC6 soap_new__sai__GetAclEnabledState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetAclEnabledState(struct soap*, _sai__GetAclEnabledState*); +SOAP_FMAC3 _sai__GetAclEnabledState * SOAP_FMAC4 soap_instantiate__sai__GetAclEnabledState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetAclEnabledState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetAclEnabledStateResponse +#define SOAP_TYPE__sai__SetAclEnabledStateResponse (208) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAclEnabledStateResponse(struct soap*, const char*, int, const _sai__SetAclEnabledStateResponse *, const char*); +SOAP_FMAC3 _sai__SetAclEnabledStateResponse * SOAP_FMAC4 soap_get__sai__SetAclEnabledStateResponse(struct soap*, _sai__SetAclEnabledStateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetAclEnabledStateResponse * SOAP_FMAC4 soap_in__sai__SetAclEnabledStateResponse(struct soap*, const char*, _sai__SetAclEnabledStateResponse *, const char*); +SOAP_FMAC5 _sai__SetAclEnabledStateResponse * SOAP_FMAC6 soap_new__sai__SetAclEnabledStateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAclEnabledStateResponse(struct soap*, _sai__SetAclEnabledStateResponse*); +SOAP_FMAC3 _sai__SetAclEnabledStateResponse * SOAP_FMAC4 soap_instantiate__sai__SetAclEnabledStateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAclEnabledStateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetAclEnabledState +#define SOAP_TYPE__sai__SetAclEnabledState (207) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAclEnabledState(struct soap*, const char*, int, const _sai__SetAclEnabledState *, const char*); +SOAP_FMAC3 _sai__SetAclEnabledState * SOAP_FMAC4 soap_get__sai__SetAclEnabledState(struct soap*, _sai__SetAclEnabledState *, const char*, const char*); +SOAP_FMAC3 _sai__SetAclEnabledState * SOAP_FMAC4 soap_in__sai__SetAclEnabledState(struct soap*, const char*, _sai__SetAclEnabledState *, const char*); +SOAP_FMAC5 _sai__SetAclEnabledState * SOAP_FMAC6 soap_new__sai__SetAclEnabledState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAclEnabledState(struct soap*, _sai__SetAclEnabledState*); +SOAP_FMAC3 _sai__SetAclEnabledState * SOAP_FMAC4 soap_instantiate__sai__SetAclEnabledState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAclEnabledState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetConfigurationServerFQDNResponse +#define SOAP_TYPE__sai__GetConfigurationServerFQDNResponse (206) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetConfigurationServerFQDNResponse(struct soap*, const char*, int, const _sai__GetConfigurationServerFQDNResponse *, const char*); +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_get__sai__GetConfigurationServerFQDNResponse(struct soap*, _sai__GetConfigurationServerFQDNResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_in__sai__GetConfigurationServerFQDNResponse(struct soap*, const char*, _sai__GetConfigurationServerFQDNResponse *, const char*); +SOAP_FMAC5 _sai__GetConfigurationServerFQDNResponse * SOAP_FMAC6 soap_new__sai__GetConfigurationServerFQDNResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetConfigurationServerFQDNResponse(struct soap*, _sai__GetConfigurationServerFQDNResponse*); +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_instantiate__sai__GetConfigurationServerFQDNResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetConfigurationServerFQDNResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetConfigurationServerFQDN +#define SOAP_TYPE__sai__GetConfigurationServerFQDN (205) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetConfigurationServerFQDN(struct soap*, const char*, int, const _sai__GetConfigurationServerFQDN *, const char*); +SOAP_FMAC3 _sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_get__sai__GetConfigurationServerFQDN(struct soap*, _sai__GetConfigurationServerFQDN *, const char*, const char*); +SOAP_FMAC3 _sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_in__sai__GetConfigurationServerFQDN(struct soap*, const char*, _sai__GetConfigurationServerFQDN *, const char*); +SOAP_FMAC5 _sai__GetConfigurationServerFQDN * SOAP_FMAC6 soap_new__sai__GetConfigurationServerFQDN(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetConfigurationServerFQDN(struct soap*, _sai__GetConfigurationServerFQDN*); +SOAP_FMAC3 _sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_instantiate__sai__GetConfigurationServerFQDN(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetConfigurationServerFQDN(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetConfigurationServerFQDNResponse +#define SOAP_TYPE__sai__SetConfigurationServerFQDNResponse (204) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetConfigurationServerFQDNResponse(struct soap*, const char*, int, const _sai__SetConfigurationServerFQDNResponse *, const char*); +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_get__sai__SetConfigurationServerFQDNResponse(struct soap*, _sai__SetConfigurationServerFQDNResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_in__sai__SetConfigurationServerFQDNResponse(struct soap*, const char*, _sai__SetConfigurationServerFQDNResponse *, const char*); +SOAP_FMAC5 _sai__SetConfigurationServerFQDNResponse * SOAP_FMAC6 soap_new__sai__SetConfigurationServerFQDNResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetConfigurationServerFQDNResponse(struct soap*, _sai__SetConfigurationServerFQDNResponse*); +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_instantiate__sai__SetConfigurationServerFQDNResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetConfigurationServerFQDNResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetConfigurationServerFQDN +#define SOAP_TYPE__sai__SetConfigurationServerFQDN (203) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetConfigurationServerFQDN(struct soap*, const char*, int, const _sai__SetConfigurationServerFQDN *, const char*); +SOAP_FMAC3 _sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_get__sai__SetConfigurationServerFQDN(struct soap*, _sai__SetConfigurationServerFQDN *, const char*, const char*); +SOAP_FMAC3 _sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_in__sai__SetConfigurationServerFQDN(struct soap*, const char*, _sai__SetConfigurationServerFQDN *, const char*); +SOAP_FMAC5 _sai__SetConfigurationServerFQDN * SOAP_FMAC6 soap_new__sai__SetConfigurationServerFQDN(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetConfigurationServerFQDN(struct soap*, _sai__SetConfigurationServerFQDN*); +SOAP_FMAC3 _sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_instantiate__sai__SetConfigurationServerFQDN(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetConfigurationServerFQDN(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnableVpnRoutingResponse +#define SOAP_TYPE__sai__EnableVpnRoutingResponse (202) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnableVpnRoutingResponse(struct soap*, const char*, int, const _sai__EnableVpnRoutingResponse *, const char*); +SOAP_FMAC3 _sai__EnableVpnRoutingResponse * SOAP_FMAC4 soap_get__sai__EnableVpnRoutingResponse(struct soap*, _sai__EnableVpnRoutingResponse *, const char*, const char*); +SOAP_FMAC3 _sai__EnableVpnRoutingResponse * SOAP_FMAC4 soap_in__sai__EnableVpnRoutingResponse(struct soap*, const char*, _sai__EnableVpnRoutingResponse *, const char*); +SOAP_FMAC5 _sai__EnableVpnRoutingResponse * SOAP_FMAC6 soap_new__sai__EnableVpnRoutingResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnableVpnRoutingResponse(struct soap*, _sai__EnableVpnRoutingResponse*); +SOAP_FMAC3 _sai__EnableVpnRoutingResponse * SOAP_FMAC4 soap_instantiate__sai__EnableVpnRoutingResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnableVpnRoutingResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnableVpnRouting +#define SOAP_TYPE__sai__EnableVpnRouting (201) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnableVpnRouting(struct soap*, const char*, int, const _sai__EnableVpnRouting *, const char*); +SOAP_FMAC3 _sai__EnableVpnRouting * SOAP_FMAC4 soap_get__sai__EnableVpnRouting(struct soap*, _sai__EnableVpnRouting *, const char*, const char*); +SOAP_FMAC3 _sai__EnableVpnRouting * SOAP_FMAC4 soap_in__sai__EnableVpnRouting(struct soap*, const char*, _sai__EnableVpnRouting *, const char*); +SOAP_FMAC5 _sai__EnableVpnRouting * SOAP_FMAC6 soap_new__sai__EnableVpnRouting(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnableVpnRouting(struct soap*, _sai__EnableVpnRouting*); +SOAP_FMAC3 _sai__EnableVpnRouting * SOAP_FMAC4 soap_instantiate__sai__EnableVpnRouting(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnableVpnRouting(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTLSCredentialsResponse +#define SOAP_TYPE__sai__GetTLSCredentialsResponse (200) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTLSCredentialsResponse(struct soap*, const char*, int, const _sai__GetTLSCredentialsResponse *, const char*); +SOAP_FMAC3 _sai__GetTLSCredentialsResponse * SOAP_FMAC4 soap_get__sai__GetTLSCredentialsResponse(struct soap*, _sai__GetTLSCredentialsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetTLSCredentialsResponse * SOAP_FMAC4 soap_in__sai__GetTLSCredentialsResponse(struct soap*, const char*, _sai__GetTLSCredentialsResponse *, const char*); +SOAP_FMAC5 _sai__GetTLSCredentialsResponse * SOAP_FMAC6 soap_new__sai__GetTLSCredentialsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTLSCredentialsResponse(struct soap*, _sai__GetTLSCredentialsResponse*); +SOAP_FMAC3 _sai__GetTLSCredentialsResponse * SOAP_FMAC4 soap_instantiate__sai__GetTLSCredentialsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTLSCredentialsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTLSCredentials +#define SOAP_TYPE__sai__GetTLSCredentials (199) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTLSCredentials(struct soap*, const char*, int, const _sai__GetTLSCredentials *, const char*); +SOAP_FMAC3 _sai__GetTLSCredentials * SOAP_FMAC4 soap_get__sai__GetTLSCredentials(struct soap*, _sai__GetTLSCredentials *, const char*, const char*); +SOAP_FMAC3 _sai__GetTLSCredentials * SOAP_FMAC4 soap_in__sai__GetTLSCredentials(struct soap*, const char*, _sai__GetTLSCredentials *, const char*); +SOAP_FMAC5 _sai__GetTLSCredentials * SOAP_FMAC6 soap_new__sai__GetTLSCredentials(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTLSCredentials(struct soap*, _sai__GetTLSCredentials*); +SOAP_FMAC3 _sai__GetTLSCredentials * SOAP_FMAC4 soap_instantiate__sai__GetTLSCredentials(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTLSCredentials(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTLSCredentialsResponse +#define SOAP_TYPE__sai__SetTLSCredentialsResponse (198) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSCredentialsResponse(struct soap*, const char*, int, const _sai__SetTLSCredentialsResponse *, const char*); +SOAP_FMAC3 _sai__SetTLSCredentialsResponse * SOAP_FMAC4 soap_get__sai__SetTLSCredentialsResponse(struct soap*, _sai__SetTLSCredentialsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSCredentialsResponse * SOAP_FMAC4 soap_in__sai__SetTLSCredentialsResponse(struct soap*, const char*, _sai__SetTLSCredentialsResponse *, const char*); +SOAP_FMAC5 _sai__SetTLSCredentialsResponse * SOAP_FMAC6 soap_new__sai__SetTLSCredentialsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSCredentialsResponse(struct soap*, _sai__SetTLSCredentialsResponse*); +SOAP_FMAC3 _sai__SetTLSCredentialsResponse * SOAP_FMAC4 soap_instantiate__sai__SetTLSCredentialsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSCredentialsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTLSCredentials +#define SOAP_TYPE__sai__SetTLSCredentials (197) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSCredentials(struct soap*, const char*, int, const _sai__SetTLSCredentials *, const char*); +SOAP_FMAC3 _sai__SetTLSCredentials * SOAP_FMAC4 soap_get__sai__SetTLSCredentials(struct soap*, _sai__SetTLSCredentials *, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSCredentials * SOAP_FMAC4 soap_in__sai__SetTLSCredentials(struct soap*, const char*, _sai__SetTLSCredentials *, const char*); +SOAP_FMAC5 _sai__SetTLSCredentials * SOAP_FMAC6 soap_new__sai__SetTLSCredentials(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSCredentials(struct soap*, _sai__SetTLSCredentials*); +SOAP_FMAC3 _sai__SetTLSCredentials * SOAP_FMAC4 soap_instantiate__sai__SetTLSCredentials(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSCredentials(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreUpdateCertificateResponse +#define SOAP_TYPE__sai__CertStoreUpdateCertificateResponse (196) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreUpdateCertificateResponse(struct soap*, const char*, int, const _sai__CertStoreUpdateCertificateResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse * SOAP_FMAC4 soap_get__sai__CertStoreUpdateCertificateResponse(struct soap*, _sai__CertStoreUpdateCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse * SOAP_FMAC4 soap_in__sai__CertStoreUpdateCertificateResponse(struct soap*, const char*, _sai__CertStoreUpdateCertificateResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreUpdateCertificateResponse * SOAP_FMAC6 soap_new__sai__CertStoreUpdateCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreUpdateCertificateResponse(struct soap*, _sai__CertStoreUpdateCertificateResponse*); +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreUpdateCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreUpdateCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreUpdateCertificate +#define SOAP_TYPE__sai__CertStoreUpdateCertificate (195) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreUpdateCertificate(struct soap*, const char*, int, const _sai__CertStoreUpdateCertificate *, const char*); +SOAP_FMAC3 _sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_get__sai__CertStoreUpdateCertificate(struct soap*, _sai__CertStoreUpdateCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_in__sai__CertStoreUpdateCertificate(struct soap*, const char*, _sai__CertStoreUpdateCertificate *, const char*); +SOAP_FMAC5 _sai__CertStoreUpdateCertificate * SOAP_FMAC6 soap_new__sai__CertStoreUpdateCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreUpdateCertificate(struct soap*, _sai__CertStoreUpdateCertificate*); +SOAP_FMAC3 _sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_instantiate__sai__CertStoreUpdateCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreUpdateCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse +#define SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse (194) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetPKCS10RequestResponse(struct soap*, const char*, int, const _sai__CertStoreGetPKCS10RequestResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse * SOAP_FMAC4 soap_get__sai__CertStoreGetPKCS10RequestResponse(struct soap*, _sai__CertStoreGetPKCS10RequestResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse * SOAP_FMAC4 soap_in__sai__CertStoreGetPKCS10RequestResponse(struct soap*, const char*, _sai__CertStoreGetPKCS10RequestResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreGetPKCS10RequestResponse * SOAP_FMAC6 soap_new__sai__CertStoreGetPKCS10RequestResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetPKCS10RequestResponse(struct soap*, _sai__CertStoreGetPKCS10RequestResponse*); +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetPKCS10RequestResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetPKCS10RequestResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreGetPKCS10Request +#define SOAP_TYPE__sai__CertStoreGetPKCS10Request (193) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetPKCS10Request(struct soap*, const char*, int, const _sai__CertStoreGetPKCS10Request *, const char*); +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_get__sai__CertStoreGetPKCS10Request(struct soap*, _sai__CertStoreGetPKCS10Request *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_in__sai__CertStoreGetPKCS10Request(struct soap*, const char*, _sai__CertStoreGetPKCS10Request *, const char*); +SOAP_FMAC5 _sai__CertStoreGetPKCS10Request * SOAP_FMAC6 soap_new__sai__CertStoreGetPKCS10Request(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetPKCS10Request(struct soap*, _sai__CertStoreGetPKCS10Request*); +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetPKCS10Request(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetPKCS10Request(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreRemoveCertificateResponse +#define SOAP_TYPE__sai__CertStoreRemoveCertificateResponse (192) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreRemoveCertificateResponse(struct soap*, const char*, int, const _sai__CertStoreRemoveCertificateResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse * SOAP_FMAC4 soap_get__sai__CertStoreRemoveCertificateResponse(struct soap*, _sai__CertStoreRemoveCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse * SOAP_FMAC4 soap_in__sai__CertStoreRemoveCertificateResponse(struct soap*, const char*, _sai__CertStoreRemoveCertificateResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreRemoveCertificateResponse * SOAP_FMAC6 soap_new__sai__CertStoreRemoveCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreRemoveCertificateResponse(struct soap*, _sai__CertStoreRemoveCertificateResponse*); +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreRemoveCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreRemoveCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreRemoveCertificate +#define SOAP_TYPE__sai__CertStoreRemoveCertificate (191) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreRemoveCertificate(struct soap*, const char*, int, const _sai__CertStoreRemoveCertificate *, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_get__sai__CertStoreRemoveCertificate(struct soap*, _sai__CertStoreRemoveCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_in__sai__CertStoreRemoveCertificate(struct soap*, const char*, _sai__CertStoreRemoveCertificate *, const char*); +SOAP_FMAC5 _sai__CertStoreRemoveCertificate * SOAP_FMAC6 soap_new__sai__CertStoreRemoveCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreRemoveCertificate(struct soap*, _sai__CertStoreRemoveCertificate*); +SOAP_FMAC3 _sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_instantiate__sai__CertStoreRemoveCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreRemoveCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreGetCertificateResponse +#define SOAP_TYPE__sai__CertStoreGetCertificateResponse (190) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetCertificateResponse(struct soap*, const char*, int, const _sai__CertStoreGetCertificateResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse * SOAP_FMAC4 soap_get__sai__CertStoreGetCertificateResponse(struct soap*, _sai__CertStoreGetCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse * SOAP_FMAC4 soap_in__sai__CertStoreGetCertificateResponse(struct soap*, const char*, _sai__CertStoreGetCertificateResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreGetCertificateResponse * SOAP_FMAC6 soap_new__sai__CertStoreGetCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetCertificateResponse(struct soap*, _sai__CertStoreGetCertificateResponse*); +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreGetCertificate +#define SOAP_TYPE__sai__CertStoreGetCertificate (189) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetCertificate(struct soap*, const char*, int, const _sai__CertStoreGetCertificate *, const char*); +SOAP_FMAC3 _sai__CertStoreGetCertificate * SOAP_FMAC4 soap_get__sai__CertStoreGetCertificate(struct soap*, _sai__CertStoreGetCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetCertificate * SOAP_FMAC4 soap_in__sai__CertStoreGetCertificate(struct soap*, const char*, _sai__CertStoreGetCertificate *, const char*); +SOAP_FMAC5 _sai__CertStoreGetCertificate * SOAP_FMAC6 soap_new__sai__CertStoreGetCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetCertificate(struct soap*, _sai__CertStoreGetCertificate*); +SOAP_FMAC3 _sai__CertStoreGetCertificate * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse +#define SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse (188) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreEnumerateCertificatesResponse(struct soap*, const char*, int, const _sai__CertStoreEnumerateCertificatesResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse * SOAP_FMAC4 soap_get__sai__CertStoreEnumerateCertificatesResponse(struct soap*, _sai__CertStoreEnumerateCertificatesResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse * SOAP_FMAC4 soap_in__sai__CertStoreEnumerateCertificatesResponse(struct soap*, const char*, _sai__CertStoreEnumerateCertificatesResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreEnumerateCertificatesResponse * SOAP_FMAC6 soap_new__sai__CertStoreEnumerateCertificatesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreEnumerateCertificatesResponse(struct soap*, _sai__CertStoreEnumerateCertificatesResponse*); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreEnumerateCertificatesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreEnumerateCertificatesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreEnumerateCertificates +#define SOAP_TYPE__sai__CertStoreEnumerateCertificates (187) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreEnumerateCertificates(struct soap*, const char*, int, const _sai__CertStoreEnumerateCertificates *, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_get__sai__CertStoreEnumerateCertificates(struct soap*, _sai__CertStoreEnumerateCertificates *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_in__sai__CertStoreEnumerateCertificates(struct soap*, const char*, _sai__CertStoreEnumerateCertificates *, const char*); +SOAP_FMAC5 _sai__CertStoreEnumerateCertificates * SOAP_FMAC6 soap_new__sai__CertStoreEnumerateCertificates(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreEnumerateCertificates(struct soap*, _sai__CertStoreEnumerateCertificates*); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_instantiate__sai__CertStoreEnumerateCertificates(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreEnumerateCertificates(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreAddCertificateResponse +#define SOAP_TYPE__sai__CertStoreAddCertificateResponse (186) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreAddCertificateResponse(struct soap*, const char*, int, const _sai__CertStoreAddCertificateResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse * SOAP_FMAC4 soap_get__sai__CertStoreAddCertificateResponse(struct soap*, _sai__CertStoreAddCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse * SOAP_FMAC4 soap_in__sai__CertStoreAddCertificateResponse(struct soap*, const char*, _sai__CertStoreAddCertificateResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreAddCertificateResponse * SOAP_FMAC6 soap_new__sai__CertStoreAddCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreAddCertificateResponse(struct soap*, _sai__CertStoreAddCertificateResponse*); +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreAddCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreAddCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreAddCertificate +#define SOAP_TYPE__sai__CertStoreAddCertificate (185) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreAddCertificate(struct soap*, const char*, int, const _sai__CertStoreAddCertificate *, const char*); +SOAP_FMAC3 _sai__CertStoreAddCertificate * SOAP_FMAC4 soap_get__sai__CertStoreAddCertificate(struct soap*, _sai__CertStoreAddCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreAddCertificate * SOAP_FMAC4 soap_in__sai__CertStoreAddCertificate(struct soap*, const char*, _sai__CertStoreAddCertificate *, const char*); +SOAP_FMAC5 _sai__CertStoreAddCertificate * SOAP_FMAC6 soap_new__sai__CertStoreAddCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreAddCertificate(struct soap*, _sai__CertStoreAddCertificate*); +SOAP_FMAC3 _sai__CertStoreAddCertificate * SOAP_FMAC4 soap_instantiate__sai__CertStoreAddCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreAddCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreRemoveKeyResponse +#define SOAP_TYPE__sai__CertStoreRemoveKeyResponse (184) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreRemoveKeyResponse(struct soap*, const char*, int, const _sai__CertStoreRemoveKeyResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse * SOAP_FMAC4 soap_get__sai__CertStoreRemoveKeyResponse(struct soap*, _sai__CertStoreRemoveKeyResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse * SOAP_FMAC4 soap_in__sai__CertStoreRemoveKeyResponse(struct soap*, const char*, _sai__CertStoreRemoveKeyResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreRemoveKeyResponse * SOAP_FMAC6 soap_new__sai__CertStoreRemoveKeyResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreRemoveKeyResponse(struct soap*, _sai__CertStoreRemoveKeyResponse*); +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreRemoveKeyResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreRemoveKeyResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreRemoveKey +#define SOAP_TYPE__sai__CertStoreRemoveKey (183) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreRemoveKey(struct soap*, const char*, int, const _sai__CertStoreRemoveKey *, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveKey * SOAP_FMAC4 soap_get__sai__CertStoreRemoveKey(struct soap*, _sai__CertStoreRemoveKey *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveKey * SOAP_FMAC4 soap_in__sai__CertStoreRemoveKey(struct soap*, const char*, _sai__CertStoreRemoveKey *, const char*); +SOAP_FMAC5 _sai__CertStoreRemoveKey * SOAP_FMAC6 soap_new__sai__CertStoreRemoveKey(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreRemoveKey(struct soap*, _sai__CertStoreRemoveKey*); +SOAP_FMAC3 _sai__CertStoreRemoveKey * SOAP_FMAC4 soap_instantiate__sai__CertStoreRemoveKey(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreRemoveKey(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreGetKeyResponse +#define SOAP_TYPE__sai__CertStoreGetKeyResponse (182) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetKeyResponse(struct soap*, const char*, int, const _sai__CertStoreGetKeyResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreGetKeyResponse * SOAP_FMAC4 soap_get__sai__CertStoreGetKeyResponse(struct soap*, _sai__CertStoreGetKeyResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetKeyResponse * SOAP_FMAC4 soap_in__sai__CertStoreGetKeyResponse(struct soap*, const char*, _sai__CertStoreGetKeyResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreGetKeyResponse * SOAP_FMAC6 soap_new__sai__CertStoreGetKeyResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetKeyResponse(struct soap*, _sai__CertStoreGetKeyResponse*); +SOAP_FMAC3 _sai__CertStoreGetKeyResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetKeyResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetKeyResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreGetKey +#define SOAP_TYPE__sai__CertStoreGetKey (181) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetKey(struct soap*, const char*, int, const _sai__CertStoreGetKey *, const char*); +SOAP_FMAC3 _sai__CertStoreGetKey * SOAP_FMAC4 soap_get__sai__CertStoreGetKey(struct soap*, _sai__CertStoreGetKey *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetKey * SOAP_FMAC4 soap_in__sai__CertStoreGetKey(struct soap*, const char*, _sai__CertStoreGetKey *, const char*); +SOAP_FMAC5 _sai__CertStoreGetKey * SOAP_FMAC6 soap_new__sai__CertStoreGetKey(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetKey(struct soap*, _sai__CertStoreGetKey*); +SOAP_FMAC3 _sai__CertStoreGetKey * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetKey(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetKey(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreEnumerateKeysResponse +#define SOAP_TYPE__sai__CertStoreEnumerateKeysResponse (180) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreEnumerateKeysResponse(struct soap*, const char*, int, const _sai__CertStoreEnumerateKeysResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse * SOAP_FMAC4 soap_get__sai__CertStoreEnumerateKeysResponse(struct soap*, _sai__CertStoreEnumerateKeysResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse * SOAP_FMAC4 soap_in__sai__CertStoreEnumerateKeysResponse(struct soap*, const char*, _sai__CertStoreEnumerateKeysResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreEnumerateKeysResponse * SOAP_FMAC6 soap_new__sai__CertStoreEnumerateKeysResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreEnumerateKeysResponse(struct soap*, _sai__CertStoreEnumerateKeysResponse*); +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreEnumerateKeysResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreEnumerateKeysResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreEnumerateKeys +#define SOAP_TYPE__sai__CertStoreEnumerateKeys (179) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreEnumerateKeys(struct soap*, const char*, int, const _sai__CertStoreEnumerateKeys *, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_get__sai__CertStoreEnumerateKeys(struct soap*, _sai__CertStoreEnumerateKeys *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_in__sai__CertStoreEnumerateKeys(struct soap*, const char*, _sai__CertStoreEnumerateKeys *, const char*); +SOAP_FMAC5 _sai__CertStoreEnumerateKeys * SOAP_FMAC6 soap_new__sai__CertStoreEnumerateKeys(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreEnumerateKeys(struct soap*, _sai__CertStoreEnumerateKeys*); +SOAP_FMAC3 _sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_instantiate__sai__CertStoreEnumerateKeys(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreEnumerateKeys(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreAddKeyResponse +#define SOAP_TYPE__sai__CertStoreAddKeyResponse (178) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreAddKeyResponse(struct soap*, const char*, int, const _sai__CertStoreAddKeyResponse *, const char*); +SOAP_FMAC3 _sai__CertStoreAddKeyResponse * SOAP_FMAC4 soap_get__sai__CertStoreAddKeyResponse(struct soap*, _sai__CertStoreAddKeyResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreAddKeyResponse * SOAP_FMAC4 soap_in__sai__CertStoreAddKeyResponse(struct soap*, const char*, _sai__CertStoreAddKeyResponse *, const char*); +SOAP_FMAC5 _sai__CertStoreAddKeyResponse * SOAP_FMAC6 soap_new__sai__CertStoreAddKeyResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreAddKeyResponse(struct soap*, _sai__CertStoreAddKeyResponse*); +SOAP_FMAC3 _sai__CertStoreAddKeyResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreAddKeyResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreAddKeyResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CertStoreAddKey +#define SOAP_TYPE__sai__CertStoreAddKey (177) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreAddKey(struct soap*, const char*, int, const _sai__CertStoreAddKey *, const char*); +SOAP_FMAC3 _sai__CertStoreAddKey * SOAP_FMAC4 soap_get__sai__CertStoreAddKey(struct soap*, _sai__CertStoreAddKey *, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreAddKey * SOAP_FMAC4 soap_in__sai__CertStoreAddKey(struct soap*, const char*, _sai__CertStoreAddKey *, const char*); +SOAP_FMAC5 _sai__CertStoreAddKey * SOAP_FMAC6 soap_new__sai__CertStoreAddKey(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreAddKey(struct soap*, _sai__CertStoreAddKey*); +SOAP_FMAC3 _sai__CertStoreAddKey * SOAP_FMAC4 soap_instantiate__sai__CertStoreAddKey(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreAddKey(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetGlobalPowerPolicyResponse +#define SOAP_TYPE__sai__GetGlobalPowerPolicyResponse (176) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetGlobalPowerPolicyResponse(struct soap*, const char*, int, const _sai__GetGlobalPowerPolicyResponse *, const char*); +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_get__sai__GetGlobalPowerPolicyResponse(struct soap*, _sai__GetGlobalPowerPolicyResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_in__sai__GetGlobalPowerPolicyResponse(struct soap*, const char*, _sai__GetGlobalPowerPolicyResponse *, const char*); +SOAP_FMAC5 _sai__GetGlobalPowerPolicyResponse * SOAP_FMAC6 soap_new__sai__GetGlobalPowerPolicyResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetGlobalPowerPolicyResponse(struct soap*, _sai__GetGlobalPowerPolicyResponse*); +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_instantiate__sai__GetGlobalPowerPolicyResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetGlobalPowerPolicyResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetGlobalPowerPolicy +#define SOAP_TYPE__sai__GetGlobalPowerPolicy (175) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetGlobalPowerPolicy(struct soap*, const char*, int, const _sai__GetGlobalPowerPolicy *, const char*); +SOAP_FMAC3 _sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_get__sai__GetGlobalPowerPolicy(struct soap*, _sai__GetGlobalPowerPolicy *, const char*, const char*); +SOAP_FMAC3 _sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_in__sai__GetGlobalPowerPolicy(struct soap*, const char*, _sai__GetGlobalPowerPolicy *, const char*); +SOAP_FMAC5 _sai__GetGlobalPowerPolicy * SOAP_FMAC6 soap_new__sai__GetGlobalPowerPolicy(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetGlobalPowerPolicy(struct soap*, _sai__GetGlobalPowerPolicy*); +SOAP_FMAC3 _sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_instantiate__sai__GetGlobalPowerPolicy(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetGlobalPowerPolicy(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetGlobalPowerPolicyResponse +#define SOAP_TYPE__sai__SetGlobalPowerPolicyResponse (174) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetGlobalPowerPolicyResponse(struct soap*, const char*, int, const _sai__SetGlobalPowerPolicyResponse *, const char*); +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_get__sai__SetGlobalPowerPolicyResponse(struct soap*, _sai__SetGlobalPowerPolicyResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_in__sai__SetGlobalPowerPolicyResponse(struct soap*, const char*, _sai__SetGlobalPowerPolicyResponse *, const char*); +SOAP_FMAC5 _sai__SetGlobalPowerPolicyResponse * SOAP_FMAC6 soap_new__sai__SetGlobalPowerPolicyResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetGlobalPowerPolicyResponse(struct soap*, _sai__SetGlobalPowerPolicyResponse*); +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_instantiate__sai__SetGlobalPowerPolicyResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetGlobalPowerPolicyResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetGlobalPowerPolicy +#define SOAP_TYPE__sai__SetGlobalPowerPolicy (173) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetGlobalPowerPolicy(struct soap*, const char*, int, const _sai__SetGlobalPowerPolicy *, const char*); +SOAP_FMAC3 _sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_get__sai__SetGlobalPowerPolicy(struct soap*, _sai__SetGlobalPowerPolicy *, const char*, const char*); +SOAP_FMAC3 _sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_in__sai__SetGlobalPowerPolicy(struct soap*, const char*, _sai__SetGlobalPowerPolicy *, const char*); +SOAP_FMAC5 _sai__SetGlobalPowerPolicy * SOAP_FMAC6 soap_new__sai__SetGlobalPowerPolicy(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetGlobalPowerPolicy(struct soap*, _sai__SetGlobalPowerPolicy*); +SOAP_FMAC3 _sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_instantiate__sai__SetGlobalPowerPolicy(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetGlobalPowerPolicy(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetActivePowerPackageResponse +#define SOAP_TYPE__sai__SetActivePowerPackageResponse (172) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetActivePowerPackageResponse(struct soap*, const char*, int, const _sai__SetActivePowerPackageResponse *, const char*); +SOAP_FMAC3 _sai__SetActivePowerPackageResponse * SOAP_FMAC4 soap_get__sai__SetActivePowerPackageResponse(struct soap*, _sai__SetActivePowerPackageResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetActivePowerPackageResponse * SOAP_FMAC4 soap_in__sai__SetActivePowerPackageResponse(struct soap*, const char*, _sai__SetActivePowerPackageResponse *, const char*); +SOAP_FMAC5 _sai__SetActivePowerPackageResponse * SOAP_FMAC6 soap_new__sai__SetActivePowerPackageResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetActivePowerPackageResponse(struct soap*, _sai__SetActivePowerPackageResponse*); +SOAP_FMAC3 _sai__SetActivePowerPackageResponse * SOAP_FMAC4 soap_instantiate__sai__SetActivePowerPackageResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetActivePowerPackageResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetActivePowerPackage +#define SOAP_TYPE__sai__SetActivePowerPackage (171) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetActivePowerPackage(struct soap*, const char*, int, const _sai__SetActivePowerPackage *, const char*); +SOAP_FMAC3 _sai__SetActivePowerPackage * SOAP_FMAC4 soap_get__sai__SetActivePowerPackage(struct soap*, _sai__SetActivePowerPackage *, const char*, const char*); +SOAP_FMAC3 _sai__SetActivePowerPackage * SOAP_FMAC4 soap_in__sai__SetActivePowerPackage(struct soap*, const char*, _sai__SetActivePowerPackage *, const char*); +SOAP_FMAC5 _sai__SetActivePowerPackage * SOAP_FMAC6 soap_new__sai__SetActivePowerPackage(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetActivePowerPackage(struct soap*, _sai__SetActivePowerPackage*); +SOAP_FMAC3 _sai__SetActivePowerPackage * SOAP_FMAC4 soap_instantiate__sai__SetActivePowerPackage(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetActivePowerPackage(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetPowerPackageResponse +#define SOAP_TYPE__sai__GetPowerPackageResponse (170) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPowerPackageResponse(struct soap*, const char*, int, const _sai__GetPowerPackageResponse *, const char*); +SOAP_FMAC3 _sai__GetPowerPackageResponse * SOAP_FMAC4 soap_get__sai__GetPowerPackageResponse(struct soap*, _sai__GetPowerPackageResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetPowerPackageResponse * SOAP_FMAC4 soap_in__sai__GetPowerPackageResponse(struct soap*, const char*, _sai__GetPowerPackageResponse *, const char*); +SOAP_FMAC5 _sai__GetPowerPackageResponse * SOAP_FMAC6 soap_new__sai__GetPowerPackageResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPowerPackageResponse(struct soap*, _sai__GetPowerPackageResponse*); +SOAP_FMAC3 _sai__GetPowerPackageResponse * SOAP_FMAC4 soap_instantiate__sai__GetPowerPackageResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPowerPackageResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetPowerPackage +#define SOAP_TYPE__sai__GetPowerPackage (169) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPowerPackage(struct soap*, const char*, int, const _sai__GetPowerPackage *, const char*); +SOAP_FMAC3 _sai__GetPowerPackage * SOAP_FMAC4 soap_get__sai__GetPowerPackage(struct soap*, _sai__GetPowerPackage *, const char*, const char*); +SOAP_FMAC3 _sai__GetPowerPackage * SOAP_FMAC4 soap_in__sai__GetPowerPackage(struct soap*, const char*, _sai__GetPowerPackage *, const char*); +SOAP_FMAC5 _sai__GetPowerPackage * SOAP_FMAC6 soap_new__sai__GetPowerPackage(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPowerPackage(struct soap*, _sai__GetPowerPackage*); +SOAP_FMAC3 _sai__GetPowerPackage * SOAP_FMAC4 soap_instantiate__sai__GetPowerPackage(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPowerPackage(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetActivePowerPackageResponse +#define SOAP_TYPE__sai__GetActivePowerPackageResponse (168) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetActivePowerPackageResponse(struct soap*, const char*, int, const _sai__GetActivePowerPackageResponse *, const char*); +SOAP_FMAC3 _sai__GetActivePowerPackageResponse * SOAP_FMAC4 soap_get__sai__GetActivePowerPackageResponse(struct soap*, _sai__GetActivePowerPackageResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetActivePowerPackageResponse * SOAP_FMAC4 soap_in__sai__GetActivePowerPackageResponse(struct soap*, const char*, _sai__GetActivePowerPackageResponse *, const char*); +SOAP_FMAC5 _sai__GetActivePowerPackageResponse * SOAP_FMAC6 soap_new__sai__GetActivePowerPackageResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetActivePowerPackageResponse(struct soap*, _sai__GetActivePowerPackageResponse*); +SOAP_FMAC3 _sai__GetActivePowerPackageResponse * SOAP_FMAC4 soap_instantiate__sai__GetActivePowerPackageResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetActivePowerPackageResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetActivePowerPackage +#define SOAP_TYPE__sai__GetActivePowerPackage (167) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetActivePowerPackage(struct soap*, const char*, int, const _sai__GetActivePowerPackage *, const char*); +SOAP_FMAC3 _sai__GetActivePowerPackage * SOAP_FMAC4 soap_get__sai__GetActivePowerPackage(struct soap*, _sai__GetActivePowerPackage *, const char*, const char*); +SOAP_FMAC3 _sai__GetActivePowerPackage * SOAP_FMAC4 soap_in__sai__GetActivePowerPackage(struct soap*, const char*, _sai__GetActivePowerPackage *, const char*); +SOAP_FMAC5 _sai__GetActivePowerPackage * SOAP_FMAC6 soap_new__sai__GetActivePowerPackage(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetActivePowerPackage(struct soap*, _sai__GetActivePowerPackage*); +SOAP_FMAC3 _sai__GetActivePowerPackage * SOAP_FMAC4 soap_instantiate__sai__GetActivePowerPackage(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetActivePowerPackage(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnumeratePowerPackagesResponse +#define SOAP_TYPE__sai__EnumeratePowerPackagesResponse (166) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumeratePowerPackagesResponse(struct soap*, const char*, int, const _sai__EnumeratePowerPackagesResponse *, const char*); +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse * SOAP_FMAC4 soap_get__sai__EnumeratePowerPackagesResponse(struct soap*, _sai__EnumeratePowerPackagesResponse *, const char*, const char*); +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse * SOAP_FMAC4 soap_in__sai__EnumeratePowerPackagesResponse(struct soap*, const char*, _sai__EnumeratePowerPackagesResponse *, const char*); +SOAP_FMAC5 _sai__EnumeratePowerPackagesResponse * SOAP_FMAC6 soap_new__sai__EnumeratePowerPackagesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumeratePowerPackagesResponse(struct soap*, _sai__EnumeratePowerPackagesResponse*); +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse * SOAP_FMAC4 soap_instantiate__sai__EnumeratePowerPackagesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumeratePowerPackagesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnumeratePowerPackages +#define SOAP_TYPE__sai__EnumeratePowerPackages (165) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumeratePowerPackages(struct soap*, const char*, int, const _sai__EnumeratePowerPackages *, const char*); +SOAP_FMAC3 _sai__EnumeratePowerPackages * SOAP_FMAC4 soap_get__sai__EnumeratePowerPackages(struct soap*, _sai__EnumeratePowerPackages *, const char*, const char*); +SOAP_FMAC3 _sai__EnumeratePowerPackages * SOAP_FMAC4 soap_in__sai__EnumeratePowerPackages(struct soap*, const char*, _sai__EnumeratePowerPackages *, const char*); +SOAP_FMAC5 _sai__EnumeratePowerPackages * SOAP_FMAC6 soap_new__sai__EnumeratePowerPackages(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumeratePowerPackages(struct soap*, _sai__EnumeratePowerPackages*); +SOAP_FMAC3 _sai__EnumeratePowerPackages * SOAP_FMAC4 soap_instantiate__sai__EnumeratePowerPackages(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumeratePowerPackages(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetEnvironmentDetectionResponse +#define SOAP_TYPE__sai__GetEnvironmentDetectionResponse (164) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetEnvironmentDetectionResponse(struct soap*, const char*, int, const _sai__GetEnvironmentDetectionResponse *, const char*); +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse * SOAP_FMAC4 soap_get__sai__GetEnvironmentDetectionResponse(struct soap*, _sai__GetEnvironmentDetectionResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse * SOAP_FMAC4 soap_in__sai__GetEnvironmentDetectionResponse(struct soap*, const char*, _sai__GetEnvironmentDetectionResponse *, const char*); +SOAP_FMAC5 _sai__GetEnvironmentDetectionResponse * SOAP_FMAC6 soap_new__sai__GetEnvironmentDetectionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetEnvironmentDetectionResponse(struct soap*, _sai__GetEnvironmentDetectionResponse*); +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse * SOAP_FMAC4 soap_instantiate__sai__GetEnvironmentDetectionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetEnvironmentDetectionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetEnvironmentDetection +#define SOAP_TYPE__sai__GetEnvironmentDetection (163) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetEnvironmentDetection(struct soap*, const char*, int, const _sai__GetEnvironmentDetection *, const char*); +SOAP_FMAC3 _sai__GetEnvironmentDetection * SOAP_FMAC4 soap_get__sai__GetEnvironmentDetection(struct soap*, _sai__GetEnvironmentDetection *, const char*, const char*); +SOAP_FMAC3 _sai__GetEnvironmentDetection * SOAP_FMAC4 soap_in__sai__GetEnvironmentDetection(struct soap*, const char*, _sai__GetEnvironmentDetection *, const char*); +SOAP_FMAC5 _sai__GetEnvironmentDetection * SOAP_FMAC6 soap_new__sai__GetEnvironmentDetection(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetEnvironmentDetection(struct soap*, _sai__GetEnvironmentDetection*); +SOAP_FMAC3 _sai__GetEnvironmentDetection * SOAP_FMAC4 soap_instantiate__sai__GetEnvironmentDetection(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetEnvironmentDetection(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetEnvironmentDetectionResponse +#define SOAP_TYPE__sai__SetEnvironmentDetectionResponse (162) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetEnvironmentDetectionResponse(struct soap*, const char*, int, const _sai__SetEnvironmentDetectionResponse *, const char*); +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse * SOAP_FMAC4 soap_get__sai__SetEnvironmentDetectionResponse(struct soap*, _sai__SetEnvironmentDetectionResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse * SOAP_FMAC4 soap_in__sai__SetEnvironmentDetectionResponse(struct soap*, const char*, _sai__SetEnvironmentDetectionResponse *, const char*); +SOAP_FMAC5 _sai__SetEnvironmentDetectionResponse * SOAP_FMAC6 soap_new__sai__SetEnvironmentDetectionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetEnvironmentDetectionResponse(struct soap*, _sai__SetEnvironmentDetectionResponse*); +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse * SOAP_FMAC4 soap_instantiate__sai__SetEnvironmentDetectionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetEnvironmentDetectionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetEnvironmentDetection +#define SOAP_TYPE__sai__SetEnvironmentDetection (161) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetEnvironmentDetection(struct soap*, const char*, int, const _sai__SetEnvironmentDetection *, const char*); +SOAP_FMAC3 _sai__SetEnvironmentDetection * SOAP_FMAC4 soap_get__sai__SetEnvironmentDetection(struct soap*, _sai__SetEnvironmentDetection *, const char*, const char*); +SOAP_FMAC3 _sai__SetEnvironmentDetection * SOAP_FMAC4 soap_in__sai__SetEnvironmentDetection(struct soap*, const char*, _sai__SetEnvironmentDetection *, const char*); +SOAP_FMAC5 _sai__SetEnvironmentDetection * SOAP_FMAC6 soap_new__sai__SetEnvironmentDetection(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetEnvironmentDetection(struct soap*, _sai__SetEnvironmentDetection*); +SOAP_FMAC3 _sai__SetEnvironmentDetection * SOAP_FMAC4 soap_instantiate__sai__SetEnvironmentDetection(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetEnvironmentDetection(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetRealmAuthOptionsResponse +#define SOAP_TYPE__sai__SetRealmAuthOptionsResponse (160) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetRealmAuthOptionsResponse(struct soap*, const char*, int, const _sai__SetRealmAuthOptionsResponse *, const char*); +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse * SOAP_FMAC4 soap_get__sai__SetRealmAuthOptionsResponse(struct soap*, _sai__SetRealmAuthOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse * SOAP_FMAC4 soap_in__sai__SetRealmAuthOptionsResponse(struct soap*, const char*, _sai__SetRealmAuthOptionsResponse *, const char*); +SOAP_FMAC5 _sai__SetRealmAuthOptionsResponse * SOAP_FMAC6 soap_new__sai__SetRealmAuthOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetRealmAuthOptionsResponse(struct soap*, _sai__SetRealmAuthOptionsResponse*); +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__SetRealmAuthOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetRealmAuthOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetRealmAuthOptions +#define SOAP_TYPE__sai__SetRealmAuthOptions (159) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetRealmAuthOptions(struct soap*, const char*, int, const _sai__SetRealmAuthOptions *, const char*); +SOAP_FMAC3 _sai__SetRealmAuthOptions * SOAP_FMAC4 soap_get__sai__SetRealmAuthOptions(struct soap*, _sai__SetRealmAuthOptions *, const char*, const char*); +SOAP_FMAC3 _sai__SetRealmAuthOptions * SOAP_FMAC4 soap_in__sai__SetRealmAuthOptions(struct soap*, const char*, _sai__SetRealmAuthOptions *, const char*); +SOAP_FMAC5 _sai__SetRealmAuthOptions * SOAP_FMAC6 soap_new__sai__SetRealmAuthOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetRealmAuthOptions(struct soap*, _sai__SetRealmAuthOptions*); +SOAP_FMAC3 _sai__SetRealmAuthOptions * SOAP_FMAC4 soap_instantiate__sai__SetRealmAuthOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetRealmAuthOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetRealmAuthOptionsResponse +#define SOAP_TYPE__sai__GetRealmAuthOptionsResponse (158) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetRealmAuthOptionsResponse(struct soap*, const char*, int, const _sai__GetRealmAuthOptionsResponse *, const char*); +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse * SOAP_FMAC4 soap_get__sai__GetRealmAuthOptionsResponse(struct soap*, _sai__GetRealmAuthOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse * SOAP_FMAC4 soap_in__sai__GetRealmAuthOptionsResponse(struct soap*, const char*, _sai__GetRealmAuthOptionsResponse *, const char*); +SOAP_FMAC5 _sai__GetRealmAuthOptionsResponse * SOAP_FMAC6 soap_new__sai__GetRealmAuthOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetRealmAuthOptionsResponse(struct soap*, _sai__GetRealmAuthOptionsResponse*); +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__GetRealmAuthOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetRealmAuthOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetRealmAuthOptions +#define SOAP_TYPE__sai__GetRealmAuthOptions (157) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetRealmAuthOptions(struct soap*, const char*, int, const _sai__GetRealmAuthOptions *, const char*); +SOAP_FMAC3 _sai__GetRealmAuthOptions * SOAP_FMAC4 soap_get__sai__GetRealmAuthOptions(struct soap*, _sai__GetRealmAuthOptions *, const char*, const char*); +SOAP_FMAC3 _sai__GetRealmAuthOptions * SOAP_FMAC4 soap_in__sai__GetRealmAuthOptions(struct soap*, const char*, _sai__GetRealmAuthOptions *, const char*); +SOAP_FMAC5 _sai__GetRealmAuthOptions * SOAP_FMAC6 soap_new__sai__GetRealmAuthOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetRealmAuthOptions(struct soap*, _sai__GetRealmAuthOptions*); +SOAP_FMAC3 _sai__GetRealmAuthOptions * SOAP_FMAC4 soap_instantiate__sai__GetRealmAuthOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetRealmAuthOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__ExtendProvisioningPeriodResponse +#define SOAP_TYPE__sai__ExtendProvisioningPeriodResponse (156) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__ExtendProvisioningPeriodResponse(struct soap*, const char*, int, const _sai__ExtendProvisioningPeriodResponse *, const char*); +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse * SOAP_FMAC4 soap_get__sai__ExtendProvisioningPeriodResponse(struct soap*, _sai__ExtendProvisioningPeriodResponse *, const char*, const char*); +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse * SOAP_FMAC4 soap_in__sai__ExtendProvisioningPeriodResponse(struct soap*, const char*, _sai__ExtendProvisioningPeriodResponse *, const char*); +SOAP_FMAC5 _sai__ExtendProvisioningPeriodResponse * SOAP_FMAC6 soap_new__sai__ExtendProvisioningPeriodResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__ExtendProvisioningPeriodResponse(struct soap*, _sai__ExtendProvisioningPeriodResponse*); +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse * SOAP_FMAC4 soap_instantiate__sai__ExtendProvisioningPeriodResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__ExtendProvisioningPeriodResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__ExtendProvisioningPeriod +#define SOAP_TYPE__sai__ExtendProvisioningPeriod (155) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__ExtendProvisioningPeriod(struct soap*, const char*, int, const _sai__ExtendProvisioningPeriod *, const char*); +SOAP_FMAC3 _sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_get__sai__ExtendProvisioningPeriod(struct soap*, _sai__ExtendProvisioningPeriod *, const char*, const char*); +SOAP_FMAC3 _sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_in__sai__ExtendProvisioningPeriod(struct soap*, const char*, _sai__ExtendProvisioningPeriod *, const char*); +SOAP_FMAC5 _sai__ExtendProvisioningPeriod * SOAP_FMAC6 soap_new__sai__ExtendProvisioningPeriod(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__ExtendProvisioningPeriod(struct soap*, _sai__ExtendProvisioningPeriod*); +SOAP_FMAC3 _sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_instantiate__sai__ExtendProvisioningPeriod(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__ExtendProvisioningPeriod(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetProvisioningPIDResponse +#define SOAP_TYPE__sai__GetProvisioningPIDResponse (154) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningPIDResponse(struct soap*, const char*, int, const _sai__GetProvisioningPIDResponse *, const char*); +SOAP_FMAC3 _sai__GetProvisioningPIDResponse * SOAP_FMAC4 soap_get__sai__GetProvisioningPIDResponse(struct soap*, _sai__GetProvisioningPIDResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningPIDResponse * SOAP_FMAC4 soap_in__sai__GetProvisioningPIDResponse(struct soap*, const char*, _sai__GetProvisioningPIDResponse *, const char*); +SOAP_FMAC5 _sai__GetProvisioningPIDResponse * SOAP_FMAC6 soap_new__sai__GetProvisioningPIDResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningPIDResponse(struct soap*, _sai__GetProvisioningPIDResponse*); +SOAP_FMAC3 _sai__GetProvisioningPIDResponse * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningPIDResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningPIDResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetProvisioningPID +#define SOAP_TYPE__sai__GetProvisioningPID (153) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningPID(struct soap*, const char*, int, const _sai__GetProvisioningPID *, const char*); +SOAP_FMAC3 _sai__GetProvisioningPID * SOAP_FMAC4 soap_get__sai__GetProvisioningPID(struct soap*, _sai__GetProvisioningPID *, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningPID * SOAP_FMAC4 soap_in__sai__GetProvisioningPID(struct soap*, const char*, _sai__GetProvisioningPID *, const char*); +SOAP_FMAC5 _sai__GetProvisioningPID * SOAP_FMAC6 soap_new__sai__GetProvisioningPID(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningPID(struct soap*, _sai__GetProvisioningPID*); +SOAP_FMAC3 _sai__GetProvisioningPID * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningPID(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningPID(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetProvisioningAuditRecordResponse +#define SOAP_TYPE__sai__GetProvisioningAuditRecordResponse (152) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningAuditRecordResponse(struct soap*, const char*, int, const _sai__GetProvisioningAuditRecordResponse *, const char*); +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse * SOAP_FMAC4 soap_get__sai__GetProvisioningAuditRecordResponse(struct soap*, _sai__GetProvisioningAuditRecordResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse * SOAP_FMAC4 soap_in__sai__GetProvisioningAuditRecordResponse(struct soap*, const char*, _sai__GetProvisioningAuditRecordResponse *, const char*); +SOAP_FMAC5 _sai__GetProvisioningAuditRecordResponse * SOAP_FMAC6 soap_new__sai__GetProvisioningAuditRecordResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningAuditRecordResponse(struct soap*, _sai__GetProvisioningAuditRecordResponse*); +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningAuditRecordResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningAuditRecordResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetProvisioningAuditRecord +#define SOAP_TYPE__sai__GetProvisioningAuditRecord (151) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningAuditRecord(struct soap*, const char*, int, const _sai__GetProvisioningAuditRecord *, const char*); +SOAP_FMAC3 _sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_get__sai__GetProvisioningAuditRecord(struct soap*, _sai__GetProvisioningAuditRecord *, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_in__sai__GetProvisioningAuditRecord(struct soap*, const char*, _sai__GetProvisioningAuditRecord *, const char*); +SOAP_FMAC5 _sai__GetProvisioningAuditRecord * SOAP_FMAC6 soap_new__sai__GetProvisioningAuditRecord(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningAuditRecord(struct soap*, _sai__GetProvisioningAuditRecord*); +SOAP_FMAC3 _sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningAuditRecord(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningAuditRecord(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse +#define SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse (150) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetZeroTouchConfigurationModeResponse(struct soap*, const char*, int, const _sai__SetZeroTouchConfigurationModeResponse *, const char*); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_get__sai__SetZeroTouchConfigurationModeResponse(struct soap*, _sai__SetZeroTouchConfigurationModeResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_in__sai__SetZeroTouchConfigurationModeResponse(struct soap*, const char*, _sai__SetZeroTouchConfigurationModeResponse *, const char*); +SOAP_FMAC5 _sai__SetZeroTouchConfigurationModeResponse * SOAP_FMAC6 soap_new__sai__SetZeroTouchConfigurationModeResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetZeroTouchConfigurationModeResponse(struct soap*, _sai__SetZeroTouchConfigurationModeResponse*); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_instantiate__sai__SetZeroTouchConfigurationModeResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetZeroTouchConfigurationModeResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetZeroTouchConfigurationMode +#define SOAP_TYPE__sai__SetZeroTouchConfigurationMode (149) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetZeroTouchConfigurationMode(struct soap*, const char*, int, const _sai__SetZeroTouchConfigurationMode *, const char*); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_get__sai__SetZeroTouchConfigurationMode(struct soap*, _sai__SetZeroTouchConfigurationMode *, const char*, const char*); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_in__sai__SetZeroTouchConfigurationMode(struct soap*, const char*, _sai__SetZeroTouchConfigurationMode *, const char*); +SOAP_FMAC5 _sai__SetZeroTouchConfigurationMode * SOAP_FMAC6 soap_new__sai__SetZeroTouchConfigurationMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetZeroTouchConfigurationMode(struct soap*, _sai__SetZeroTouchConfigurationMode*); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_instantiate__sai__SetZeroTouchConfigurationMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetZeroTouchConfigurationMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse +#define SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse (148) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetZeroTouchConfigurationModeResponse(struct soap*, const char*, int, const _sai__GetZeroTouchConfigurationModeResponse *, const char*); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_get__sai__GetZeroTouchConfigurationModeResponse(struct soap*, _sai__GetZeroTouchConfigurationModeResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_in__sai__GetZeroTouchConfigurationModeResponse(struct soap*, const char*, _sai__GetZeroTouchConfigurationModeResponse *, const char*); +SOAP_FMAC5 _sai__GetZeroTouchConfigurationModeResponse * SOAP_FMAC6 soap_new__sai__GetZeroTouchConfigurationModeResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetZeroTouchConfigurationModeResponse(struct soap*, _sai__GetZeroTouchConfigurationModeResponse*); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_instantiate__sai__GetZeroTouchConfigurationModeResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetZeroTouchConfigurationModeResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetZeroTouchConfigurationMode +#define SOAP_TYPE__sai__GetZeroTouchConfigurationMode (147) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetZeroTouchConfigurationMode(struct soap*, const char*, int, const _sai__GetZeroTouchConfigurationMode *, const char*); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_get__sai__GetZeroTouchConfigurationMode(struct soap*, _sai__GetZeroTouchConfigurationMode *, const char*, const char*); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_in__sai__GetZeroTouchConfigurationMode(struct soap*, const char*, _sai__GetZeroTouchConfigurationMode *, const char*); +SOAP_FMAC5 _sai__GetZeroTouchConfigurationMode * SOAP_FMAC6 soap_new__sai__GetZeroTouchConfigurationMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetZeroTouchConfigurationMode(struct soap*, _sai__GetZeroTouchConfigurationMode*); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_instantiate__sai__GetZeroTouchConfigurationMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetZeroTouchConfigurationMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnableCertificateHashEntryResponse +#define SOAP_TYPE__sai__EnableCertificateHashEntryResponse (146) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnableCertificateHashEntryResponse(struct soap*, const char*, int, const _sai__EnableCertificateHashEntryResponse *, const char*); +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse * SOAP_FMAC4 soap_get__sai__EnableCertificateHashEntryResponse(struct soap*, _sai__EnableCertificateHashEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse * SOAP_FMAC4 soap_in__sai__EnableCertificateHashEntryResponse(struct soap*, const char*, _sai__EnableCertificateHashEntryResponse *, const char*); +SOAP_FMAC5 _sai__EnableCertificateHashEntryResponse * SOAP_FMAC6 soap_new__sai__EnableCertificateHashEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnableCertificateHashEntryResponse(struct soap*, _sai__EnableCertificateHashEntryResponse*); +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse * SOAP_FMAC4 soap_instantiate__sai__EnableCertificateHashEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnableCertificateHashEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnableCertificateHashEntry +#define SOAP_TYPE__sai__EnableCertificateHashEntry (145) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnableCertificateHashEntry(struct soap*, const char*, int, const _sai__EnableCertificateHashEntry *, const char*); +SOAP_FMAC3 _sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_get__sai__EnableCertificateHashEntry(struct soap*, _sai__EnableCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 _sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_in__sai__EnableCertificateHashEntry(struct soap*, const char*, _sai__EnableCertificateHashEntry *, const char*); +SOAP_FMAC5 _sai__EnableCertificateHashEntry * SOAP_FMAC6 soap_new__sai__EnableCertificateHashEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnableCertificateHashEntry(struct soap*, _sai__EnableCertificateHashEntry*); +SOAP_FMAC3 _sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_instantiate__sai__EnableCertificateHashEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnableCertificateHashEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__DeleteCertificateHashEntryResponse +#define SOAP_TYPE__sai__DeleteCertificateHashEntryResponse (144) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__DeleteCertificateHashEntryResponse(struct soap*, const char*, int, const _sai__DeleteCertificateHashEntryResponse *, const char*); +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse * SOAP_FMAC4 soap_get__sai__DeleteCertificateHashEntryResponse(struct soap*, _sai__DeleteCertificateHashEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse * SOAP_FMAC4 soap_in__sai__DeleteCertificateHashEntryResponse(struct soap*, const char*, _sai__DeleteCertificateHashEntryResponse *, const char*); +SOAP_FMAC5 _sai__DeleteCertificateHashEntryResponse * SOAP_FMAC6 soap_new__sai__DeleteCertificateHashEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__DeleteCertificateHashEntryResponse(struct soap*, _sai__DeleteCertificateHashEntryResponse*); +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse * SOAP_FMAC4 soap_instantiate__sai__DeleteCertificateHashEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__DeleteCertificateHashEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__DeleteCertificateHashEntry +#define SOAP_TYPE__sai__DeleteCertificateHashEntry (143) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__DeleteCertificateHashEntry(struct soap*, const char*, int, const _sai__DeleteCertificateHashEntry *, const char*); +SOAP_FMAC3 _sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_get__sai__DeleteCertificateHashEntry(struct soap*, _sai__DeleteCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 _sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_in__sai__DeleteCertificateHashEntry(struct soap*, const char*, _sai__DeleteCertificateHashEntry *, const char*); +SOAP_FMAC5 _sai__DeleteCertificateHashEntry * SOAP_FMAC6 soap_new__sai__DeleteCertificateHashEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__DeleteCertificateHashEntry(struct soap*, _sai__DeleteCertificateHashEntry*); +SOAP_FMAC3 _sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_instantiate__sai__DeleteCertificateHashEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__DeleteCertificateHashEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__AddCertificateHashEntryResponse +#define SOAP_TYPE__sai__AddCertificateHashEntryResponse (142) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddCertificateHashEntryResponse(struct soap*, const char*, int, const _sai__AddCertificateHashEntryResponse *, const char*); +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse * SOAP_FMAC4 soap_get__sai__AddCertificateHashEntryResponse(struct soap*, _sai__AddCertificateHashEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse * SOAP_FMAC4 soap_in__sai__AddCertificateHashEntryResponse(struct soap*, const char*, _sai__AddCertificateHashEntryResponse *, const char*); +SOAP_FMAC5 _sai__AddCertificateHashEntryResponse * SOAP_FMAC6 soap_new__sai__AddCertificateHashEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddCertificateHashEntryResponse(struct soap*, _sai__AddCertificateHashEntryResponse*); +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse * SOAP_FMAC4 soap_instantiate__sai__AddCertificateHashEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddCertificateHashEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__AddCertificateHashEntry +#define SOAP_TYPE__sai__AddCertificateHashEntry (141) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddCertificateHashEntry(struct soap*, const char*, int, const _sai__AddCertificateHashEntry *, const char*); +SOAP_FMAC3 _sai__AddCertificateHashEntry * SOAP_FMAC4 soap_get__sai__AddCertificateHashEntry(struct soap*, _sai__AddCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 _sai__AddCertificateHashEntry * SOAP_FMAC4 soap_in__sai__AddCertificateHashEntry(struct soap*, const char*, _sai__AddCertificateHashEntry *, const char*); +SOAP_FMAC5 _sai__AddCertificateHashEntry * SOAP_FMAC6 soap_new__sai__AddCertificateHashEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddCertificateHashEntry(struct soap*, _sai__AddCertificateHashEntry*); +SOAP_FMAC3 _sai__AddCertificateHashEntry * SOAP_FMAC4 soap_instantiate__sai__AddCertificateHashEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddCertificateHashEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetCertificateHashEntryResponse +#define SOAP_TYPE__sai__GetCertificateHashEntryResponse (140) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCertificateHashEntryResponse(struct soap*, const char*, int, const _sai__GetCertificateHashEntryResponse *, const char*); +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse * SOAP_FMAC4 soap_get__sai__GetCertificateHashEntryResponse(struct soap*, _sai__GetCertificateHashEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse * SOAP_FMAC4 soap_in__sai__GetCertificateHashEntryResponse(struct soap*, const char*, _sai__GetCertificateHashEntryResponse *, const char*); +SOAP_FMAC5 _sai__GetCertificateHashEntryResponse * SOAP_FMAC6 soap_new__sai__GetCertificateHashEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCertificateHashEntryResponse(struct soap*, _sai__GetCertificateHashEntryResponse*); +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse * SOAP_FMAC4 soap_instantiate__sai__GetCertificateHashEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCertificateHashEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetCertificateHashEntry +#define SOAP_TYPE__sai__GetCertificateHashEntry (139) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCertificateHashEntry(struct soap*, const char*, int, const _sai__GetCertificateHashEntry *, const char*); +SOAP_FMAC3 _sai__GetCertificateHashEntry * SOAP_FMAC4 soap_get__sai__GetCertificateHashEntry(struct soap*, _sai__GetCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 _sai__GetCertificateHashEntry * SOAP_FMAC4 soap_in__sai__GetCertificateHashEntry(struct soap*, const char*, _sai__GetCertificateHashEntry *, const char*); +SOAP_FMAC5 _sai__GetCertificateHashEntry * SOAP_FMAC6 soap_new__sai__GetCertificateHashEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCertificateHashEntry(struct soap*, _sai__GetCertificateHashEntry*); +SOAP_FMAC3 _sai__GetCertificateHashEntry * SOAP_FMAC4 soap_instantiate__sai__GetCertificateHashEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCertificateHashEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse +#define SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse (138) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateCertificateHashEntriesResponse(struct soap*, const char*, int, const _sai__EnumerateCertificateHashEntriesResponse *, const char*); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse * SOAP_FMAC4 soap_get__sai__EnumerateCertificateHashEntriesResponse(struct soap*, _sai__EnumerateCertificateHashEntriesResponse *, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse * SOAP_FMAC4 soap_in__sai__EnumerateCertificateHashEntriesResponse(struct soap*, const char*, _sai__EnumerateCertificateHashEntriesResponse *, const char*); +SOAP_FMAC5 _sai__EnumerateCertificateHashEntriesResponse * SOAP_FMAC6 soap_new__sai__EnumerateCertificateHashEntriesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateCertificateHashEntriesResponse(struct soap*, _sai__EnumerateCertificateHashEntriesResponse*); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse * SOAP_FMAC4 soap_instantiate__sai__EnumerateCertificateHashEntriesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateCertificateHashEntriesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnumerateCertificateHashEntries +#define SOAP_TYPE__sai__EnumerateCertificateHashEntries (137) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateCertificateHashEntries(struct soap*, const char*, int, const _sai__EnumerateCertificateHashEntries *, const char*); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_get__sai__EnumerateCertificateHashEntries(struct soap*, _sai__EnumerateCertificateHashEntries *, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_in__sai__EnumerateCertificateHashEntries(struct soap*, const char*, _sai__EnumerateCertificateHashEntries *, const char*); +SOAP_FMAC5 _sai__EnumerateCertificateHashEntries * SOAP_FMAC6 soap_new__sai__EnumerateCertificateHashEntries(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateCertificateHashEntries(struct soap*, _sai__EnumerateCertificateHashEntries*); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_instantiate__sai__EnumerateCertificateHashEntries(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateCertificateHashEntries(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetProvisioningServerOTPResponse +#define SOAP_TYPE__sai__GetProvisioningServerOTPResponse (136) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningServerOTPResponse(struct soap*, const char*, int, const _sai__GetProvisioningServerOTPResponse *, const char*); +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse * SOAP_FMAC4 soap_get__sai__GetProvisioningServerOTPResponse(struct soap*, _sai__GetProvisioningServerOTPResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse * SOAP_FMAC4 soap_in__sai__GetProvisioningServerOTPResponse(struct soap*, const char*, _sai__GetProvisioningServerOTPResponse *, const char*); +SOAP_FMAC5 _sai__GetProvisioningServerOTPResponse * SOAP_FMAC6 soap_new__sai__GetProvisioningServerOTPResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningServerOTPResponse(struct soap*, _sai__GetProvisioningServerOTPResponse*); +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningServerOTPResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningServerOTPResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetProvisioningServerOTP +#define SOAP_TYPE__sai__GetProvisioningServerOTP (135) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningServerOTP(struct soap*, const char*, int, const _sai__GetProvisioningServerOTP *, const char*); +SOAP_FMAC3 _sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_get__sai__GetProvisioningServerOTP(struct soap*, _sai__GetProvisioningServerOTP *, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_in__sai__GetProvisioningServerOTP(struct soap*, const char*, _sai__GetProvisioningServerOTP *, const char*); +SOAP_FMAC5 _sai__GetProvisioningServerOTP * SOAP_FMAC6 soap_new__sai__GetProvisioningServerOTP(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningServerOTP(struct soap*, _sai__GetProvisioningServerOTP*); +SOAP_FMAC3 _sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningServerOTP(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningServerOTP(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetProvisioningServerOTPResponse +#define SOAP_TYPE__sai__SetProvisioningServerOTPResponse (134) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetProvisioningServerOTPResponse(struct soap*, const char*, int, const _sai__SetProvisioningServerOTPResponse *, const char*); +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse * SOAP_FMAC4 soap_get__sai__SetProvisioningServerOTPResponse(struct soap*, _sai__SetProvisioningServerOTPResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse * SOAP_FMAC4 soap_in__sai__SetProvisioningServerOTPResponse(struct soap*, const char*, _sai__SetProvisioningServerOTPResponse *, const char*); +SOAP_FMAC5 _sai__SetProvisioningServerOTPResponse * SOAP_FMAC6 soap_new__sai__SetProvisioningServerOTPResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetProvisioningServerOTPResponse(struct soap*, _sai__SetProvisioningServerOTPResponse*); +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse * SOAP_FMAC4 soap_instantiate__sai__SetProvisioningServerOTPResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetProvisioningServerOTPResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetProvisioningServerOTP +#define SOAP_TYPE__sai__SetProvisioningServerOTP (133) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetProvisioningServerOTP(struct soap*, const char*, int, const _sai__SetProvisioningServerOTP *, const char*); +SOAP_FMAC3 _sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_get__sai__SetProvisioningServerOTP(struct soap*, _sai__SetProvisioningServerOTP *, const char*, const char*); +SOAP_FMAC3 _sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_in__sai__SetProvisioningServerOTP(struct soap*, const char*, _sai__SetProvisioningServerOTP *, const char*); +SOAP_FMAC5 _sai__SetProvisioningServerOTP * SOAP_FMAC6 soap_new__sai__SetProvisioningServerOTP(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetProvisioningServerOTP(struct soap*, _sai__SetProvisioningServerOTP*); +SOAP_FMAC3 _sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_instantiate__sai__SetProvisioningServerOTP(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetProvisioningServerOTP(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetMEBxPasswordResponse +#define SOAP_TYPE__sai__SetMEBxPasswordResponse (132) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetMEBxPasswordResponse(struct soap*, const char*, int, const _sai__SetMEBxPasswordResponse *, const char*); +SOAP_FMAC3 _sai__SetMEBxPasswordResponse * SOAP_FMAC4 soap_get__sai__SetMEBxPasswordResponse(struct soap*, _sai__SetMEBxPasswordResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetMEBxPasswordResponse * SOAP_FMAC4 soap_in__sai__SetMEBxPasswordResponse(struct soap*, const char*, _sai__SetMEBxPasswordResponse *, const char*); +SOAP_FMAC5 _sai__SetMEBxPasswordResponse * SOAP_FMAC6 soap_new__sai__SetMEBxPasswordResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetMEBxPasswordResponse(struct soap*, _sai__SetMEBxPasswordResponse*); +SOAP_FMAC3 _sai__SetMEBxPasswordResponse * SOAP_FMAC4 soap_instantiate__sai__SetMEBxPasswordResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetMEBxPasswordResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetMEBxPassword +#define SOAP_TYPE__sai__SetMEBxPassword (131) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetMEBxPassword(struct soap*, const char*, int, const _sai__SetMEBxPassword *, const char*); +SOAP_FMAC3 _sai__SetMEBxPassword * SOAP_FMAC4 soap_get__sai__SetMEBxPassword(struct soap*, _sai__SetMEBxPassword *, const char*, const char*); +SOAP_FMAC3 _sai__SetMEBxPassword * SOAP_FMAC4 soap_in__sai__SetMEBxPassword(struct soap*, const char*, _sai__SetMEBxPassword *, const char*); +SOAP_FMAC5 _sai__SetMEBxPassword * SOAP_FMAC6 soap_new__sai__SetMEBxPassword(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetMEBxPassword(struct soap*, _sai__SetMEBxPassword*); +SOAP_FMAC3 _sai__SetMEBxPassword * SOAP_FMAC4 soap_instantiate__sai__SetMEBxPassword(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetMEBxPassword(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__PartialUnprovisionResponse +#define SOAP_TYPE__sai__PartialUnprovisionResponse (130) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__PartialUnprovisionResponse(struct soap*, const char*, int, const _sai__PartialUnprovisionResponse *, const char*); +SOAP_FMAC3 _sai__PartialUnprovisionResponse * SOAP_FMAC4 soap_get__sai__PartialUnprovisionResponse(struct soap*, _sai__PartialUnprovisionResponse *, const char*, const char*); +SOAP_FMAC3 _sai__PartialUnprovisionResponse * SOAP_FMAC4 soap_in__sai__PartialUnprovisionResponse(struct soap*, const char*, _sai__PartialUnprovisionResponse *, const char*); +SOAP_FMAC5 _sai__PartialUnprovisionResponse * SOAP_FMAC6 soap_new__sai__PartialUnprovisionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__PartialUnprovisionResponse(struct soap*, _sai__PartialUnprovisionResponse*); +SOAP_FMAC3 _sai__PartialUnprovisionResponse * SOAP_FMAC4 soap_instantiate__sai__PartialUnprovisionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__PartialUnprovisionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__PartialUnprovision +#define SOAP_TYPE__sai__PartialUnprovision (129) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__PartialUnprovision(struct soap*, const char*, int, const _sai__PartialUnprovision *, const char*); +SOAP_FMAC3 _sai__PartialUnprovision * SOAP_FMAC4 soap_get__sai__PartialUnprovision(struct soap*, _sai__PartialUnprovision *, const char*, const char*); +SOAP_FMAC3 _sai__PartialUnprovision * SOAP_FMAC4 soap_in__sai__PartialUnprovision(struct soap*, const char*, _sai__PartialUnprovision *, const char*); +SOAP_FMAC5 _sai__PartialUnprovision * SOAP_FMAC6 soap_new__sai__PartialUnprovision(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__PartialUnprovision(struct soap*, _sai__PartialUnprovision*); +SOAP_FMAC3 _sai__PartialUnprovision * SOAP_FMAC4 soap_instantiate__sai__PartialUnprovision(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__PartialUnprovision(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTLSPSKResponse +#define SOAP_TYPE__sai__SetTLSPSKResponse (128) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSPSKResponse(struct soap*, const char*, int, const _sai__SetTLSPSKResponse *, const char*); +SOAP_FMAC3 _sai__SetTLSPSKResponse * SOAP_FMAC4 soap_get__sai__SetTLSPSKResponse(struct soap*, _sai__SetTLSPSKResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSPSKResponse * SOAP_FMAC4 soap_in__sai__SetTLSPSKResponse(struct soap*, const char*, _sai__SetTLSPSKResponse *, const char*); +SOAP_FMAC5 _sai__SetTLSPSKResponse * SOAP_FMAC6 soap_new__sai__SetTLSPSKResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSPSKResponse(struct soap*, _sai__SetTLSPSKResponse*); +SOAP_FMAC3 _sai__SetTLSPSKResponse * SOAP_FMAC4 soap_instantiate__sai__SetTLSPSKResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSPSKResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTLSPSK +#define SOAP_TYPE__sai__SetTLSPSK (127) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSPSK(struct soap*, const char*, int, const _sai__SetTLSPSK *, const char*); +SOAP_FMAC3 _sai__SetTLSPSK * SOAP_FMAC4 soap_get__sai__SetTLSPSK(struct soap*, _sai__SetTLSPSK *, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSPSK * SOAP_FMAC4 soap_in__sai__SetTLSPSK(struct soap*, const char*, _sai__SetTLSPSK *, const char*); +SOAP_FMAC5 _sai__SetTLSPSK * SOAP_FMAC6 soap_new__sai__SetTLSPSK(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSPSK(struct soap*, _sai__SetTLSPSK*); +SOAP_FMAC3 _sai__SetTLSPSK * SOAP_FMAC4 soap_instantiate__sai__SetTLSPSK(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSPSK(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetPowerSavingOptionsResponse +#define SOAP_TYPE__sai__GetPowerSavingOptionsResponse (126) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPowerSavingOptionsResponse(struct soap*, const char*, int, const _sai__GetPowerSavingOptionsResponse *, const char*); +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse * SOAP_FMAC4 soap_get__sai__GetPowerSavingOptionsResponse(struct soap*, _sai__GetPowerSavingOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse * SOAP_FMAC4 soap_in__sai__GetPowerSavingOptionsResponse(struct soap*, const char*, _sai__GetPowerSavingOptionsResponse *, const char*); +SOAP_FMAC5 _sai__GetPowerSavingOptionsResponse * SOAP_FMAC6 soap_new__sai__GetPowerSavingOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPowerSavingOptionsResponse(struct soap*, _sai__GetPowerSavingOptionsResponse*); +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__GetPowerSavingOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPowerSavingOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetPowerSavingOptions +#define SOAP_TYPE__sai__GetPowerSavingOptions (125) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPowerSavingOptions(struct soap*, const char*, int, const _sai__GetPowerSavingOptions *, const char*); +SOAP_FMAC3 _sai__GetPowerSavingOptions * SOAP_FMAC4 soap_get__sai__GetPowerSavingOptions(struct soap*, _sai__GetPowerSavingOptions *, const char*, const char*); +SOAP_FMAC3 _sai__GetPowerSavingOptions * SOAP_FMAC4 soap_in__sai__GetPowerSavingOptions(struct soap*, const char*, _sai__GetPowerSavingOptions *, const char*); +SOAP_FMAC5 _sai__GetPowerSavingOptions * SOAP_FMAC6 soap_new__sai__GetPowerSavingOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPowerSavingOptions(struct soap*, _sai__GetPowerSavingOptions*); +SOAP_FMAC3 _sai__GetPowerSavingOptions * SOAP_FMAC4 soap_instantiate__sai__GetPowerSavingOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPowerSavingOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetPowerSavingOptionsResponse +#define SOAP_TYPE__sai__SetPowerSavingOptionsResponse (124) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetPowerSavingOptionsResponse(struct soap*, const char*, int, const _sai__SetPowerSavingOptionsResponse *, const char*); +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse * SOAP_FMAC4 soap_get__sai__SetPowerSavingOptionsResponse(struct soap*, _sai__SetPowerSavingOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse * SOAP_FMAC4 soap_in__sai__SetPowerSavingOptionsResponse(struct soap*, const char*, _sai__SetPowerSavingOptionsResponse *, const char*); +SOAP_FMAC5 _sai__SetPowerSavingOptionsResponse * SOAP_FMAC6 soap_new__sai__SetPowerSavingOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetPowerSavingOptionsResponse(struct soap*, _sai__SetPowerSavingOptionsResponse*); +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__SetPowerSavingOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetPowerSavingOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetPowerSavingOptions +#define SOAP_TYPE__sai__SetPowerSavingOptions (123) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetPowerSavingOptions(struct soap*, const char*, int, const _sai__SetPowerSavingOptions *, const char*); +SOAP_FMAC3 _sai__SetPowerSavingOptions * SOAP_FMAC4 soap_get__sai__SetPowerSavingOptions(struct soap*, _sai__SetPowerSavingOptions *, const char*, const char*); +SOAP_FMAC3 _sai__SetPowerSavingOptions * SOAP_FMAC4 soap_in__sai__SetPowerSavingOptions(struct soap*, const char*, _sai__SetPowerSavingOptions *, const char*); +SOAP_FMAC5 _sai__SetPowerSavingOptions * SOAP_FMAC6 soap_new__sai__SetPowerSavingOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetPowerSavingOptions(struct soap*, _sai__SetPowerSavingOptions*); +SOAP_FMAC3 _sai__SetPowerSavingOptions * SOAP_FMAC4 soap_instantiate__sai__SetPowerSavingOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetPowerSavingOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetPkiCapabilitiesResponse +#define SOAP_TYPE__sai__GetPkiCapabilitiesResponse (122) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPkiCapabilitiesResponse(struct soap*, const char*, int, const _sai__GetPkiCapabilitiesResponse *, const char*); +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse * SOAP_FMAC4 soap_get__sai__GetPkiCapabilitiesResponse(struct soap*, _sai__GetPkiCapabilitiesResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse * SOAP_FMAC4 soap_in__sai__GetPkiCapabilitiesResponse(struct soap*, const char*, _sai__GetPkiCapabilitiesResponse *, const char*); +SOAP_FMAC5 _sai__GetPkiCapabilitiesResponse * SOAP_FMAC6 soap_new__sai__GetPkiCapabilitiesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPkiCapabilitiesResponse(struct soap*, _sai__GetPkiCapabilitiesResponse*); +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__sai__GetPkiCapabilitiesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPkiCapabilitiesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetPkiCapabilities +#define SOAP_TYPE__sai__GetPkiCapabilities (121) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPkiCapabilities(struct soap*, const char*, int, const _sai__GetPkiCapabilities *, const char*); +SOAP_FMAC3 _sai__GetPkiCapabilities * SOAP_FMAC4 soap_get__sai__GetPkiCapabilities(struct soap*, _sai__GetPkiCapabilities *, const char*, const char*); +SOAP_FMAC3 _sai__GetPkiCapabilities * SOAP_FMAC4 soap_in__sai__GetPkiCapabilities(struct soap*, const char*, _sai__GetPkiCapabilities *, const char*); +SOAP_FMAC5 _sai__GetPkiCapabilities * SOAP_FMAC6 soap_new__sai__GetPkiCapabilities(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPkiCapabilities(struct soap*, _sai__GetPkiCapabilities*); +SOAP_FMAC3 _sai__GetPkiCapabilities * SOAP_FMAC4 soap_instantiate__sai__GetPkiCapabilities(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPkiCapabilities(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetServerCertificateReqResponse +#define SOAP_TYPE__sai__GetServerCertificateReqResponse (120) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetServerCertificateReqResponse(struct soap*, const char*, int, const _sai__GetServerCertificateReqResponse *, const char*); +SOAP_FMAC3 _sai__GetServerCertificateReqResponse * SOAP_FMAC4 soap_get__sai__GetServerCertificateReqResponse(struct soap*, _sai__GetServerCertificateReqResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetServerCertificateReqResponse * SOAP_FMAC4 soap_in__sai__GetServerCertificateReqResponse(struct soap*, const char*, _sai__GetServerCertificateReqResponse *, const char*); +SOAP_FMAC5 _sai__GetServerCertificateReqResponse * SOAP_FMAC6 soap_new__sai__GetServerCertificateReqResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetServerCertificateReqResponse(struct soap*, _sai__GetServerCertificateReqResponse*); +SOAP_FMAC3 _sai__GetServerCertificateReqResponse * SOAP_FMAC4 soap_instantiate__sai__GetServerCertificateReqResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetServerCertificateReqResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetServerCertificateReq +#define SOAP_TYPE__sai__GetServerCertificateReq (119) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetServerCertificateReq(struct soap*, const char*, int, const _sai__GetServerCertificateReq *, const char*); +SOAP_FMAC3 _sai__GetServerCertificateReq * SOAP_FMAC4 soap_get__sai__GetServerCertificateReq(struct soap*, _sai__GetServerCertificateReq *, const char*, const char*); +SOAP_FMAC3 _sai__GetServerCertificateReq * SOAP_FMAC4 soap_in__sai__GetServerCertificateReq(struct soap*, const char*, _sai__GetServerCertificateReq *, const char*); +SOAP_FMAC5 _sai__GetServerCertificateReq * SOAP_FMAC6 soap_new__sai__GetServerCertificateReq(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetServerCertificateReq(struct soap*, _sai__GetServerCertificateReq*); +SOAP_FMAC3 _sai__GetServerCertificateReq * SOAP_FMAC4 soap_instantiate__sai__GetServerCertificateReq(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetServerCertificateReq(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetCRLResponse +#define SOAP_TYPE__sai__GetCRLResponse (118) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCRLResponse(struct soap*, const char*, int, const _sai__GetCRLResponse *, const char*); +SOAP_FMAC3 _sai__GetCRLResponse * SOAP_FMAC4 soap_get__sai__GetCRLResponse(struct soap*, _sai__GetCRLResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetCRLResponse * SOAP_FMAC4 soap_in__sai__GetCRLResponse(struct soap*, const char*, _sai__GetCRLResponse *, const char*); +SOAP_FMAC5 _sai__GetCRLResponse * SOAP_FMAC6 soap_new__sai__GetCRLResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCRLResponse(struct soap*, _sai__GetCRLResponse*); +SOAP_FMAC3 _sai__GetCRLResponse * SOAP_FMAC4 soap_instantiate__sai__GetCRLResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCRLResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetCRL +#define SOAP_TYPE__sai__GetCRL (117) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCRL(struct soap*, const char*, int, const _sai__GetCRL *, const char*); +SOAP_FMAC3 _sai__GetCRL * SOAP_FMAC4 soap_get__sai__GetCRL(struct soap*, _sai__GetCRL *, const char*, const char*); +SOAP_FMAC3 _sai__GetCRL * SOAP_FMAC4 soap_in__sai__GetCRL(struct soap*, const char*, _sai__GetCRL *, const char*); +SOAP_FMAC5 _sai__GetCRL * SOAP_FMAC6 soap_new__sai__GetCRL(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCRL(struct soap*, _sai__GetCRL*); +SOAP_FMAC3 _sai__GetCRL * SOAP_FMAC4 soap_instantiate__sai__GetCRL(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCRL(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetCRLResponse +#define SOAP_TYPE__sai__SetCRLResponse (116) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetCRLResponse(struct soap*, const char*, int, const _sai__SetCRLResponse *, const char*); +SOAP_FMAC3 _sai__SetCRLResponse * SOAP_FMAC4 soap_get__sai__SetCRLResponse(struct soap*, _sai__SetCRLResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetCRLResponse * SOAP_FMAC4 soap_in__sai__SetCRLResponse(struct soap*, const char*, _sai__SetCRLResponse *, const char*); +SOAP_FMAC5 _sai__SetCRLResponse * SOAP_FMAC6 soap_new__sai__SetCRLResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetCRLResponse(struct soap*, _sai__SetCRLResponse*); +SOAP_FMAC3 _sai__SetCRLResponse * SOAP_FMAC4 soap_instantiate__sai__SetCRLResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetCRLResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetCRL +#define SOAP_TYPE__sai__SetCRL (115) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetCRL(struct soap*, const char*, int, const _sai__SetCRL *, const char*); +SOAP_FMAC3 _sai__SetCRL * SOAP_FMAC4 soap_get__sai__SetCRL(struct soap*, _sai__SetCRL *, const char*, const char*); +SOAP_FMAC3 _sai__SetCRL * SOAP_FMAC4 soap_in__sai__SetCRL(struct soap*, const char*, _sai__SetCRL *, const char*); +SOAP_FMAC5 _sai__SetCRL * SOAP_FMAC6 soap_new__sai__SetCRL(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetCRL(struct soap*, _sai__SetCRL*); +SOAP_FMAC3 _sai__SetCRL * SOAP_FMAC4 soap_instantiate__sai__SetCRL(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetCRL(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTrustedFqdnCNResponse +#define SOAP_TYPE__sai__GetTrustedFqdnCNResponse (114) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTrustedFqdnCNResponse(struct soap*, const char*, int, const _sai__GetTrustedFqdnCNResponse *, const char*); +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse * SOAP_FMAC4 soap_get__sai__GetTrustedFqdnCNResponse(struct soap*, _sai__GetTrustedFqdnCNResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse * SOAP_FMAC4 soap_in__sai__GetTrustedFqdnCNResponse(struct soap*, const char*, _sai__GetTrustedFqdnCNResponse *, const char*); +SOAP_FMAC5 _sai__GetTrustedFqdnCNResponse * SOAP_FMAC6 soap_new__sai__GetTrustedFqdnCNResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTrustedFqdnCNResponse(struct soap*, _sai__GetTrustedFqdnCNResponse*); +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse * SOAP_FMAC4 soap_instantiate__sai__GetTrustedFqdnCNResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTrustedFqdnCNResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTrustedFqdnCN +#define SOAP_TYPE__sai__GetTrustedFqdnCN (113) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTrustedFqdnCN(struct soap*, const char*, int, const _sai__GetTrustedFqdnCN *, const char*); +SOAP_FMAC3 _sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_get__sai__GetTrustedFqdnCN(struct soap*, _sai__GetTrustedFqdnCN *, const char*, const char*); +SOAP_FMAC3 _sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_in__sai__GetTrustedFqdnCN(struct soap*, const char*, _sai__GetTrustedFqdnCN *, const char*); +SOAP_FMAC5 _sai__GetTrustedFqdnCN * SOAP_FMAC6 soap_new__sai__GetTrustedFqdnCN(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTrustedFqdnCN(struct soap*, _sai__GetTrustedFqdnCN*); +SOAP_FMAC3 _sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_instantiate__sai__GetTrustedFqdnCN(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTrustedFqdnCN(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTrustedFqdnCNResponse +#define SOAP_TYPE__sai__SetTrustedFqdnCNResponse (112) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTrustedFqdnCNResponse(struct soap*, const char*, int, const _sai__SetTrustedFqdnCNResponse *, const char*); +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse * SOAP_FMAC4 soap_get__sai__SetTrustedFqdnCNResponse(struct soap*, _sai__SetTrustedFqdnCNResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse * SOAP_FMAC4 soap_in__sai__SetTrustedFqdnCNResponse(struct soap*, const char*, _sai__SetTrustedFqdnCNResponse *, const char*); +SOAP_FMAC5 _sai__SetTrustedFqdnCNResponse * SOAP_FMAC6 soap_new__sai__SetTrustedFqdnCNResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTrustedFqdnCNResponse(struct soap*, _sai__SetTrustedFqdnCNResponse*); +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse * SOAP_FMAC4 soap_instantiate__sai__SetTrustedFqdnCNResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTrustedFqdnCNResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTrustedFqdnCN +#define SOAP_TYPE__sai__SetTrustedFqdnCN (111) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTrustedFqdnCN(struct soap*, const char*, int, const _sai__SetTrustedFqdnCN *, const char*); +SOAP_FMAC3 _sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_get__sai__SetTrustedFqdnCN(struct soap*, _sai__SetTrustedFqdnCN *, const char*, const char*); +SOAP_FMAC3 _sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_in__sai__SetTrustedFqdnCN(struct soap*, const char*, _sai__SetTrustedFqdnCN *, const char*); +SOAP_FMAC5 _sai__SetTrustedFqdnCN * SOAP_FMAC6 soap_new__sai__SetTrustedFqdnCN(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTrustedFqdnCN(struct soap*, _sai__SetTrustedFqdnCN*); +SOAP_FMAC3 _sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_instantiate__sai__SetTrustedFqdnCN(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTrustedFqdnCN(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse +#define SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse (110) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateTrustedRootCertificatesResponse(struct soap*, const char*, int, const _sai__EnumerateTrustedRootCertificatesResponse *, const char*); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse * SOAP_FMAC4 soap_get__sai__EnumerateTrustedRootCertificatesResponse(struct soap*, _sai__EnumerateTrustedRootCertificatesResponse *, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse * SOAP_FMAC4 soap_in__sai__EnumerateTrustedRootCertificatesResponse(struct soap*, const char*, _sai__EnumerateTrustedRootCertificatesResponse *, const char*); +SOAP_FMAC5 _sai__EnumerateTrustedRootCertificatesResponse * SOAP_FMAC6 soap_new__sai__EnumerateTrustedRootCertificatesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateTrustedRootCertificatesResponse(struct soap*, _sai__EnumerateTrustedRootCertificatesResponse*); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse * SOAP_FMAC4 soap_instantiate__sai__EnumerateTrustedRootCertificatesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateTrustedRootCertificatesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnumerateTrustedRootCertificates +#define SOAP_TYPE__sai__EnumerateTrustedRootCertificates (109) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateTrustedRootCertificates(struct soap*, const char*, int, const _sai__EnumerateTrustedRootCertificates *, const char*); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_get__sai__EnumerateTrustedRootCertificates(struct soap*, _sai__EnumerateTrustedRootCertificates *, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_in__sai__EnumerateTrustedRootCertificates(struct soap*, const char*, _sai__EnumerateTrustedRootCertificates *, const char*); +SOAP_FMAC5 _sai__EnumerateTrustedRootCertificates * SOAP_FMAC6 soap_new__sai__EnumerateTrustedRootCertificates(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateTrustedRootCertificates(struct soap*, _sai__EnumerateTrustedRootCertificates*); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_instantiate__sai__EnumerateTrustedRootCertificates(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateTrustedRootCertificates(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse +#define SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse (108) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__DeleteTrustedRootCertificateResponse(struct soap*, const char*, int, const _sai__DeleteTrustedRootCertificateResponse *, const char*); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse * SOAP_FMAC4 soap_get__sai__DeleteTrustedRootCertificateResponse(struct soap*, _sai__DeleteTrustedRootCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse * SOAP_FMAC4 soap_in__sai__DeleteTrustedRootCertificateResponse(struct soap*, const char*, _sai__DeleteTrustedRootCertificateResponse *, const char*); +SOAP_FMAC5 _sai__DeleteTrustedRootCertificateResponse * SOAP_FMAC6 soap_new__sai__DeleteTrustedRootCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__DeleteTrustedRootCertificateResponse(struct soap*, _sai__DeleteTrustedRootCertificateResponse*); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__DeleteTrustedRootCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__DeleteTrustedRootCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__DeleteTrustedRootCertificate +#define SOAP_TYPE__sai__DeleteTrustedRootCertificate (107) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__DeleteTrustedRootCertificate(struct soap*, const char*, int, const _sai__DeleteTrustedRootCertificate *, const char*); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_get__sai__DeleteTrustedRootCertificate(struct soap*, _sai__DeleteTrustedRootCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_in__sai__DeleteTrustedRootCertificate(struct soap*, const char*, _sai__DeleteTrustedRootCertificate *, const char*); +SOAP_FMAC5 _sai__DeleteTrustedRootCertificate * SOAP_FMAC6 soap_new__sai__DeleteTrustedRootCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__DeleteTrustedRootCertificate(struct soap*, _sai__DeleteTrustedRootCertificate*); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_instantiate__sai__DeleteTrustedRootCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__DeleteTrustedRootCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTrustedRootCertificateResponse +#define SOAP_TYPE__sai__GetTrustedRootCertificateResponse (106) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTrustedRootCertificateResponse(struct soap*, const char*, int, const _sai__GetTrustedRootCertificateResponse *, const char*); +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse * SOAP_FMAC4 soap_get__sai__GetTrustedRootCertificateResponse(struct soap*, _sai__GetTrustedRootCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse * SOAP_FMAC4 soap_in__sai__GetTrustedRootCertificateResponse(struct soap*, const char*, _sai__GetTrustedRootCertificateResponse *, const char*); +SOAP_FMAC5 _sai__GetTrustedRootCertificateResponse * SOAP_FMAC6 soap_new__sai__GetTrustedRootCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTrustedRootCertificateResponse(struct soap*, _sai__GetTrustedRootCertificateResponse*); +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__GetTrustedRootCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTrustedRootCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTrustedRootCertificate +#define SOAP_TYPE__sai__GetTrustedRootCertificate (105) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTrustedRootCertificate(struct soap*, const char*, int, const _sai__GetTrustedRootCertificate *, const char*); +SOAP_FMAC3 _sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_get__sai__GetTrustedRootCertificate(struct soap*, _sai__GetTrustedRootCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_in__sai__GetTrustedRootCertificate(struct soap*, const char*, _sai__GetTrustedRootCertificate *, const char*); +SOAP_FMAC5 _sai__GetTrustedRootCertificate * SOAP_FMAC6 soap_new__sai__GetTrustedRootCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTrustedRootCertificate(struct soap*, _sai__GetTrustedRootCertificate*); +SOAP_FMAC3 _sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_instantiate__sai__GetTrustedRootCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTrustedRootCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__AddTrustedRootCertificateResponse +#define SOAP_TYPE__sai__AddTrustedRootCertificateResponse (104) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddTrustedRootCertificateResponse(struct soap*, const char*, int, const _sai__AddTrustedRootCertificateResponse *, const char*); +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse * SOAP_FMAC4 soap_get__sai__AddTrustedRootCertificateResponse(struct soap*, _sai__AddTrustedRootCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse * SOAP_FMAC4 soap_in__sai__AddTrustedRootCertificateResponse(struct soap*, const char*, _sai__AddTrustedRootCertificateResponse *, const char*); +SOAP_FMAC5 _sai__AddTrustedRootCertificateResponse * SOAP_FMAC6 soap_new__sai__AddTrustedRootCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddTrustedRootCertificateResponse(struct soap*, _sai__AddTrustedRootCertificateResponse*); +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__AddTrustedRootCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddTrustedRootCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__AddTrustedRootCertificate +#define SOAP_TYPE__sai__AddTrustedRootCertificate (103) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddTrustedRootCertificate(struct soap*, const char*, int, const _sai__AddTrustedRootCertificate *, const char*); +SOAP_FMAC3 _sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_get__sai__AddTrustedRootCertificate(struct soap*, _sai__AddTrustedRootCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_in__sai__AddTrustedRootCertificate(struct soap*, const char*, _sai__AddTrustedRootCertificate *, const char*); +SOAP_FMAC5 _sai__AddTrustedRootCertificate * SOAP_FMAC6 soap_new__sai__AddTrustedRootCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddTrustedRootCertificate(struct soap*, _sai__AddTrustedRootCertificate*); +SOAP_FMAC3 _sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_instantiate__sai__AddTrustedRootCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddTrustedRootCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTlsOptionsResponse +#define SOAP_TYPE__sai__GetTlsOptionsResponse (102) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTlsOptionsResponse(struct soap*, const char*, int, const _sai__GetTlsOptionsResponse *, const char*); +SOAP_FMAC3 _sai__GetTlsOptionsResponse * SOAP_FMAC4 soap_get__sai__GetTlsOptionsResponse(struct soap*, _sai__GetTlsOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetTlsOptionsResponse * SOAP_FMAC4 soap_in__sai__GetTlsOptionsResponse(struct soap*, const char*, _sai__GetTlsOptionsResponse *, const char*); +SOAP_FMAC5 _sai__GetTlsOptionsResponse * SOAP_FMAC6 soap_new__sai__GetTlsOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTlsOptionsResponse(struct soap*, _sai__GetTlsOptionsResponse*); +SOAP_FMAC3 _sai__GetTlsOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__GetTlsOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTlsOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTlsOptions +#define SOAP_TYPE__sai__GetTlsOptions (101) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTlsOptions(struct soap*, const char*, int, const _sai__GetTlsOptions *, const char*); +SOAP_FMAC3 _sai__GetTlsOptions * SOAP_FMAC4 soap_get__sai__GetTlsOptions(struct soap*, _sai__GetTlsOptions *, const char*, const char*); +SOAP_FMAC3 _sai__GetTlsOptions * SOAP_FMAC4 soap_in__sai__GetTlsOptions(struct soap*, const char*, _sai__GetTlsOptions *, const char*); +SOAP_FMAC5 _sai__GetTlsOptions * SOAP_FMAC6 soap_new__sai__GetTlsOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTlsOptions(struct soap*, _sai__GetTlsOptions*); +SOAP_FMAC3 _sai__GetTlsOptions * SOAP_FMAC4 soap_instantiate__sai__GetTlsOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTlsOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTlsOptionsResponse +#define SOAP_TYPE__sai__SetTlsOptionsResponse (100) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTlsOptionsResponse(struct soap*, const char*, int, const _sai__SetTlsOptionsResponse *, const char*); +SOAP_FMAC3 _sai__SetTlsOptionsResponse * SOAP_FMAC4 soap_get__sai__SetTlsOptionsResponse(struct soap*, _sai__SetTlsOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetTlsOptionsResponse * SOAP_FMAC4 soap_in__sai__SetTlsOptionsResponse(struct soap*, const char*, _sai__SetTlsOptionsResponse *, const char*); +SOAP_FMAC5 _sai__SetTlsOptionsResponse * SOAP_FMAC6 soap_new__sai__SetTlsOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTlsOptionsResponse(struct soap*, _sai__SetTlsOptionsResponse*); +SOAP_FMAC3 _sai__SetTlsOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__SetTlsOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTlsOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTlsOptions +#define SOAP_TYPE__sai__SetTlsOptions (99) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTlsOptions(struct soap*, const char*, int, const _sai__SetTlsOptions *, const char*); +SOAP_FMAC3 _sai__SetTlsOptions * SOAP_FMAC4 soap_get__sai__SetTlsOptions(struct soap*, _sai__SetTlsOptions *, const char*, const char*); +SOAP_FMAC3 _sai__SetTlsOptions * SOAP_FMAC4 soap_in__sai__SetTlsOptions(struct soap*, const char*, _sai__SetTlsOptions *, const char*); +SOAP_FMAC5 _sai__SetTlsOptions * SOAP_FMAC6 soap_new__sai__SetTlsOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTlsOptions(struct soap*, _sai__SetTlsOptions*); +SOAP_FMAC3 _sai__SetTlsOptions * SOAP_FMAC4 soap_instantiate__sai__SetTlsOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTlsOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetEnabledInterfacesResponse +#define SOAP_TYPE__sai__GetEnabledInterfacesResponse (98) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetEnabledInterfacesResponse(struct soap*, const char*, int, const _sai__GetEnabledInterfacesResponse *, const char*); +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_get__sai__GetEnabledInterfacesResponse(struct soap*, _sai__GetEnabledInterfacesResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_in__sai__GetEnabledInterfacesResponse(struct soap*, const char*, _sai__GetEnabledInterfacesResponse *, const char*); +SOAP_FMAC5 _sai__GetEnabledInterfacesResponse * SOAP_FMAC6 soap_new__sai__GetEnabledInterfacesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetEnabledInterfacesResponse(struct soap*, _sai__GetEnabledInterfacesResponse*); +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_instantiate__sai__GetEnabledInterfacesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetEnabledInterfacesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetEnabledInterfaces +#define SOAP_TYPE__sai__GetEnabledInterfaces (97) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetEnabledInterfaces(struct soap*, const char*, int, const _sai__GetEnabledInterfaces *, const char*); +SOAP_FMAC3 _sai__GetEnabledInterfaces * SOAP_FMAC4 soap_get__sai__GetEnabledInterfaces(struct soap*, _sai__GetEnabledInterfaces *, const char*, const char*); +SOAP_FMAC3 _sai__GetEnabledInterfaces * SOAP_FMAC4 soap_in__sai__GetEnabledInterfaces(struct soap*, const char*, _sai__GetEnabledInterfaces *, const char*); +SOAP_FMAC5 _sai__GetEnabledInterfaces * SOAP_FMAC6 soap_new__sai__GetEnabledInterfaces(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetEnabledInterfaces(struct soap*, _sai__GetEnabledInterfaces*); +SOAP_FMAC3 _sai__GetEnabledInterfaces * SOAP_FMAC4 soap_instantiate__sai__GetEnabledInterfaces(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetEnabledInterfaces(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetEnabledInterfacesResponse +#define SOAP_TYPE__sai__SetEnabledInterfacesResponse (96) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetEnabledInterfacesResponse(struct soap*, const char*, int, const _sai__SetEnabledInterfacesResponse *, const char*); +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse * SOAP_FMAC4 soap_get__sai__SetEnabledInterfacesResponse(struct soap*, _sai__SetEnabledInterfacesResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse * SOAP_FMAC4 soap_in__sai__SetEnabledInterfacesResponse(struct soap*, const char*, _sai__SetEnabledInterfacesResponse *, const char*); +SOAP_FMAC5 _sai__SetEnabledInterfacesResponse * SOAP_FMAC6 soap_new__sai__SetEnabledInterfacesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetEnabledInterfacesResponse(struct soap*, _sai__SetEnabledInterfacesResponse*); +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse * SOAP_FMAC4 soap_instantiate__sai__SetEnabledInterfacesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetEnabledInterfacesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetEnabledInterfaces +#define SOAP_TYPE__sai__SetEnabledInterfaces (95) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetEnabledInterfaces(struct soap*, const char*, int, const _sai__SetEnabledInterfaces *, const char*); +SOAP_FMAC3 _sai__SetEnabledInterfaces * SOAP_FMAC4 soap_get__sai__SetEnabledInterfaces(struct soap*, _sai__SetEnabledInterfaces *, const char*, const char*); +SOAP_FMAC3 _sai__SetEnabledInterfaces * SOAP_FMAC4 soap_in__sai__SetEnabledInterfaces(struct soap*, const char*, _sai__SetEnabledInterfaces *, const char*); +SOAP_FMAC5 _sai__SetEnabledInterfaces * SOAP_FMAC6 soap_new__sai__SetEnabledInterfaces(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetEnabledInterfaces(struct soap*, _sai__SetEnabledInterfaces*); +SOAP_FMAC3 _sai__SetEnabledInterfaces * SOAP_FMAC4 soap_instantiate__sai__SetEnabledInterfaces(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetEnabledInterfaces(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetKerberosOptionsResponse +#define SOAP_TYPE__sai__GetKerberosOptionsResponse (94) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetKerberosOptionsResponse(struct soap*, const char*, int, const _sai__GetKerberosOptionsResponse *, const char*); +SOAP_FMAC3 _sai__GetKerberosOptionsResponse * SOAP_FMAC4 soap_get__sai__GetKerberosOptionsResponse(struct soap*, _sai__GetKerberosOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetKerberosOptionsResponse * SOAP_FMAC4 soap_in__sai__GetKerberosOptionsResponse(struct soap*, const char*, _sai__GetKerberosOptionsResponse *, const char*); +SOAP_FMAC5 _sai__GetKerberosOptionsResponse * SOAP_FMAC6 soap_new__sai__GetKerberosOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetKerberosOptionsResponse(struct soap*, _sai__GetKerberosOptionsResponse*); +SOAP_FMAC3 _sai__GetKerberosOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__GetKerberosOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetKerberosOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetKerberosOptions +#define SOAP_TYPE__sai__GetKerberosOptions (93) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetKerberosOptions(struct soap*, const char*, int, const _sai__GetKerberosOptions *, const char*); +SOAP_FMAC3 _sai__GetKerberosOptions * SOAP_FMAC4 soap_get__sai__GetKerberosOptions(struct soap*, _sai__GetKerberosOptions *, const char*, const char*); +SOAP_FMAC3 _sai__GetKerberosOptions * SOAP_FMAC4 soap_in__sai__GetKerberosOptions(struct soap*, const char*, _sai__GetKerberosOptions *, const char*); +SOAP_FMAC5 _sai__GetKerberosOptions * SOAP_FMAC6 soap_new__sai__GetKerberosOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetKerberosOptions(struct soap*, _sai__GetKerberosOptions*); +SOAP_FMAC3 _sai__GetKerberosOptions * SOAP_FMAC4 soap_instantiate__sai__GetKerberosOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetKerberosOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetKerberosOptionsResponse +#define SOAP_TYPE__sai__SetKerberosOptionsResponse (92) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetKerberosOptionsResponse(struct soap*, const char*, int, const _sai__SetKerberosOptionsResponse *, const char*); +SOAP_FMAC3 _sai__SetKerberosOptionsResponse * SOAP_FMAC4 soap_get__sai__SetKerberosOptionsResponse(struct soap*, _sai__SetKerberosOptionsResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetKerberosOptionsResponse * SOAP_FMAC4 soap_in__sai__SetKerberosOptionsResponse(struct soap*, const char*, _sai__SetKerberosOptionsResponse *, const char*); +SOAP_FMAC5 _sai__SetKerberosOptionsResponse * SOAP_FMAC6 soap_new__sai__SetKerberosOptionsResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetKerberosOptionsResponse(struct soap*, _sai__SetKerberosOptionsResponse*); +SOAP_FMAC3 _sai__SetKerberosOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__SetKerberosOptionsResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetKerberosOptionsResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetKerberosOptions +#define SOAP_TYPE__sai__SetKerberosOptions (91) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetKerberosOptions(struct soap*, const char*, int, const _sai__SetKerberosOptions *, const char*); +SOAP_FMAC3 _sai__SetKerberosOptions * SOAP_FMAC4 soap_get__sai__SetKerberosOptions(struct soap*, _sai__SetKerberosOptions *, const char*, const char*); +SOAP_FMAC3 _sai__SetKerberosOptions * SOAP_FMAC4 soap_in__sai__SetKerberosOptions(struct soap*, const char*, _sai__SetKerberosOptions *, const char*); +SOAP_FMAC5 _sai__SetKerberosOptions * SOAP_FMAC6 soap_new__sai__SetKerberosOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetKerberosOptions(struct soap*, _sai__SetKerberosOptions*); +SOAP_FMAC3 _sai__SetKerberosOptions * SOAP_FMAC4 soap_instantiate__sai__SetKerberosOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetKerberosOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetDigestRealmResponse +#define SOAP_TYPE__sai__GetDigestRealmResponse (90) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetDigestRealmResponse(struct soap*, const char*, int, const _sai__GetDigestRealmResponse *, const char*); +SOAP_FMAC3 _sai__GetDigestRealmResponse * SOAP_FMAC4 soap_get__sai__GetDigestRealmResponse(struct soap*, _sai__GetDigestRealmResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetDigestRealmResponse * SOAP_FMAC4 soap_in__sai__GetDigestRealmResponse(struct soap*, const char*, _sai__GetDigestRealmResponse *, const char*); +SOAP_FMAC5 _sai__GetDigestRealmResponse * SOAP_FMAC6 soap_new__sai__GetDigestRealmResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetDigestRealmResponse(struct soap*, _sai__GetDigestRealmResponse*); +SOAP_FMAC3 _sai__GetDigestRealmResponse * SOAP_FMAC4 soap_instantiate__sai__GetDigestRealmResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetDigestRealmResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetDigestRealm +#define SOAP_TYPE__sai__GetDigestRealm (89) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetDigestRealm(struct soap*, const char*, int, const _sai__GetDigestRealm *, const char*); +SOAP_FMAC3 _sai__GetDigestRealm * SOAP_FMAC4 soap_get__sai__GetDigestRealm(struct soap*, _sai__GetDigestRealm *, const char*, const char*); +SOAP_FMAC3 _sai__GetDigestRealm * SOAP_FMAC4 soap_in__sai__GetDigestRealm(struct soap*, const char*, _sai__GetDigestRealm *, const char*); +SOAP_FMAC5 _sai__GetDigestRealm * SOAP_FMAC6 soap_new__sai__GetDigestRealm(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetDigestRealm(struct soap*, _sai__GetDigestRealm*); +SOAP_FMAC3 _sai__GetDigestRealm * SOAP_FMAC4 soap_instantiate__sai__GetDigestRealm(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetDigestRealm(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetAdminAclEntryExResponse +#define SOAP_TYPE__sai__SetAdminAclEntryExResponse (88) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAdminAclEntryExResponse(struct soap*, const char*, int, const _sai__SetAdminAclEntryExResponse *, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse * SOAP_FMAC4 soap_get__sai__SetAdminAclEntryExResponse(struct soap*, _sai__SetAdminAclEntryExResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse * SOAP_FMAC4 soap_in__sai__SetAdminAclEntryExResponse(struct soap*, const char*, _sai__SetAdminAclEntryExResponse *, const char*); +SOAP_FMAC5 _sai__SetAdminAclEntryExResponse * SOAP_FMAC6 soap_new__sai__SetAdminAclEntryExResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAdminAclEntryExResponse(struct soap*, _sai__SetAdminAclEntryExResponse*); +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse * SOAP_FMAC4 soap_instantiate__sai__SetAdminAclEntryExResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAdminAclEntryExResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetAdminAclEntryEx +#define SOAP_TYPE__sai__SetAdminAclEntryEx (87) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAdminAclEntryEx(struct soap*, const char*, int, const _sai__SetAdminAclEntryEx *, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_get__sai__SetAdminAclEntryEx(struct soap*, _sai__SetAdminAclEntryEx *, const char*, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_in__sai__SetAdminAclEntryEx(struct soap*, const char*, _sai__SetAdminAclEntryEx *, const char*); +SOAP_FMAC5 _sai__SetAdminAclEntryEx * SOAP_FMAC6 soap_new__sai__SetAdminAclEntryEx(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAdminAclEntryEx(struct soap*, _sai__SetAdminAclEntryEx*); +SOAP_FMAC3 _sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_instantiate__sai__SetAdminAclEntryEx(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAdminAclEntryEx(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__UpdateUserAclEntryExResponse +#define SOAP_TYPE__sai__UpdateUserAclEntryExResponse (86) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateUserAclEntryExResponse(struct soap*, const char*, int, const _sai__UpdateUserAclEntryExResponse *, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse * SOAP_FMAC4 soap_get__sai__UpdateUserAclEntryExResponse(struct soap*, _sai__UpdateUserAclEntryExResponse *, const char*, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse * SOAP_FMAC4 soap_in__sai__UpdateUserAclEntryExResponse(struct soap*, const char*, _sai__UpdateUserAclEntryExResponse *, const char*); +SOAP_FMAC5 _sai__UpdateUserAclEntryExResponse * SOAP_FMAC6 soap_new__sai__UpdateUserAclEntryExResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateUserAclEntryExResponse(struct soap*, _sai__UpdateUserAclEntryExResponse*); +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse * SOAP_FMAC4 soap_instantiate__sai__UpdateUserAclEntryExResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateUserAclEntryExResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__UpdateUserAclEntryEx +#define SOAP_TYPE__sai__UpdateUserAclEntryEx (85) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateUserAclEntryEx(struct soap*, const char*, int, const _sai__UpdateUserAclEntryEx *, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_get__sai__UpdateUserAclEntryEx(struct soap*, _sai__UpdateUserAclEntryEx *, const char*, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_in__sai__UpdateUserAclEntryEx(struct soap*, const char*, _sai__UpdateUserAclEntryEx *, const char*); +SOAP_FMAC5 _sai__UpdateUserAclEntryEx * SOAP_FMAC6 soap_new__sai__UpdateUserAclEntryEx(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateUserAclEntryEx(struct soap*, _sai__UpdateUserAclEntryEx*); +SOAP_FMAC3 _sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_instantiate__sai__UpdateUserAclEntryEx(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateUserAclEntryEx(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetUserAclEntryExResponse +#define SOAP_TYPE__sai__GetUserAclEntryExResponse (84) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetUserAclEntryExResponse(struct soap*, const char*, int, const _sai__GetUserAclEntryExResponse *, const char*); +SOAP_FMAC3 _sai__GetUserAclEntryExResponse * SOAP_FMAC4 soap_get__sai__GetUserAclEntryExResponse(struct soap*, _sai__GetUserAclEntryExResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetUserAclEntryExResponse * SOAP_FMAC4 soap_in__sai__GetUserAclEntryExResponse(struct soap*, const char*, _sai__GetUserAclEntryExResponse *, const char*); +SOAP_FMAC5 _sai__GetUserAclEntryExResponse * SOAP_FMAC6 soap_new__sai__GetUserAclEntryExResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetUserAclEntryExResponse(struct soap*, _sai__GetUserAclEntryExResponse*); +SOAP_FMAC3 _sai__GetUserAclEntryExResponse * SOAP_FMAC4 soap_instantiate__sai__GetUserAclEntryExResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetUserAclEntryExResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetUserAclEntryEx +#define SOAP_TYPE__sai__GetUserAclEntryEx (83) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetUserAclEntryEx(struct soap*, const char*, int, const _sai__GetUserAclEntryEx *, const char*); +SOAP_FMAC3 _sai__GetUserAclEntryEx * SOAP_FMAC4 soap_get__sai__GetUserAclEntryEx(struct soap*, _sai__GetUserAclEntryEx *, const char*, const char*); +SOAP_FMAC3 _sai__GetUserAclEntryEx * SOAP_FMAC4 soap_in__sai__GetUserAclEntryEx(struct soap*, const char*, _sai__GetUserAclEntryEx *, const char*); +SOAP_FMAC5 _sai__GetUserAclEntryEx * SOAP_FMAC6 soap_new__sai__GetUserAclEntryEx(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetUserAclEntryEx(struct soap*, _sai__GetUserAclEntryEx*); +SOAP_FMAC3 _sai__GetUserAclEntryEx * SOAP_FMAC4 soap_instantiate__sai__GetUserAclEntryEx(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetUserAclEntryEx(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__AddUserAclEntryExResponse +#define SOAP_TYPE__sai__AddUserAclEntryExResponse (82) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddUserAclEntryExResponse(struct soap*, const char*, int, const _sai__AddUserAclEntryExResponse *, const char*); +SOAP_FMAC3 _sai__AddUserAclEntryExResponse * SOAP_FMAC4 soap_get__sai__AddUserAclEntryExResponse(struct soap*, _sai__AddUserAclEntryExResponse *, const char*, const char*); +SOAP_FMAC3 _sai__AddUserAclEntryExResponse * SOAP_FMAC4 soap_in__sai__AddUserAclEntryExResponse(struct soap*, const char*, _sai__AddUserAclEntryExResponse *, const char*); +SOAP_FMAC5 _sai__AddUserAclEntryExResponse * SOAP_FMAC6 soap_new__sai__AddUserAclEntryExResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddUserAclEntryExResponse(struct soap*, _sai__AddUserAclEntryExResponse*); +SOAP_FMAC3 _sai__AddUserAclEntryExResponse * SOAP_FMAC4 soap_instantiate__sai__AddUserAclEntryExResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddUserAclEntryExResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__AddUserAclEntryEx +#define SOAP_TYPE__sai__AddUserAclEntryEx (81) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddUserAclEntryEx(struct soap*, const char*, int, const _sai__AddUserAclEntryEx *, const char*); +SOAP_FMAC3 _sai__AddUserAclEntryEx * SOAP_FMAC4 soap_get__sai__AddUserAclEntryEx(struct soap*, _sai__AddUserAclEntryEx *, const char*, const char*); +SOAP_FMAC3 _sai__AddUserAclEntryEx * SOAP_FMAC4 soap_in__sai__AddUserAclEntryEx(struct soap*, const char*, _sai__AddUserAclEntryEx *, const char*); +SOAP_FMAC5 _sai__AddUserAclEntryEx * SOAP_FMAC6 soap_new__sai__AddUserAclEntryEx(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddUserAclEntryEx(struct soap*, _sai__AddUserAclEntryEx*); +SOAP_FMAC3 _sai__AddUserAclEntryEx * SOAP_FMAC4 soap_instantiate__sai__AddUserAclEntryEx(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddUserAclEntryEx(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetCoreVersionResponse +#define SOAP_TYPE__sai__GetCoreVersionResponse (80) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCoreVersionResponse(struct soap*, const char*, int, const _sai__GetCoreVersionResponse *, const char*); +SOAP_FMAC3 _sai__GetCoreVersionResponse * SOAP_FMAC4 soap_get__sai__GetCoreVersionResponse(struct soap*, _sai__GetCoreVersionResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetCoreVersionResponse * SOAP_FMAC4 soap_in__sai__GetCoreVersionResponse(struct soap*, const char*, _sai__GetCoreVersionResponse *, const char*); +SOAP_FMAC5 _sai__GetCoreVersionResponse * SOAP_FMAC6 soap_new__sai__GetCoreVersionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCoreVersionResponse(struct soap*, _sai__GetCoreVersionResponse*); +SOAP_FMAC3 _sai__GetCoreVersionResponse * SOAP_FMAC4 soap_instantiate__sai__GetCoreVersionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCoreVersionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetCoreVersion +#define SOAP_TYPE__sai__GetCoreVersion (79) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCoreVersion(struct soap*, const char*, int, const _sai__GetCoreVersion *, const char*); +SOAP_FMAC3 _sai__GetCoreVersion * SOAP_FMAC4 soap_get__sai__GetCoreVersion(struct soap*, _sai__GetCoreVersion *, const char*, const char*); +SOAP_FMAC3 _sai__GetCoreVersion * SOAP_FMAC4 soap_in__sai__GetCoreVersion(struct soap*, const char*, _sai__GetCoreVersion *, const char*); +SOAP_FMAC5 _sai__GetCoreVersion * SOAP_FMAC6 soap_new__sai__GetCoreVersion(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCoreVersion(struct soap*, _sai__GetCoreVersion*); +SOAP_FMAC3 _sai__GetCoreVersion * SOAP_FMAC4 soap_instantiate__sai__GetCoreVersion(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCoreVersion(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse +#define SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse (78) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__ResetFlashWearOutProtectionResponse(struct soap*, const char*, int, const _sai__ResetFlashWearOutProtectionResponse *, const char*); +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse * SOAP_FMAC4 soap_get__sai__ResetFlashWearOutProtectionResponse(struct soap*, _sai__ResetFlashWearOutProtectionResponse *, const char*, const char*); +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse * SOAP_FMAC4 soap_in__sai__ResetFlashWearOutProtectionResponse(struct soap*, const char*, _sai__ResetFlashWearOutProtectionResponse *, const char*); +SOAP_FMAC5 _sai__ResetFlashWearOutProtectionResponse * SOAP_FMAC6 soap_new__sai__ResetFlashWearOutProtectionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__ResetFlashWearOutProtectionResponse(struct soap*, _sai__ResetFlashWearOutProtectionResponse*); +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse * SOAP_FMAC4 soap_instantiate__sai__ResetFlashWearOutProtectionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__ResetFlashWearOutProtectionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__ResetFlashWearOutProtection +#define SOAP_TYPE__sai__ResetFlashWearOutProtection (77) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__ResetFlashWearOutProtection(struct soap*, const char*, int, const _sai__ResetFlashWearOutProtection *, const char*); +SOAP_FMAC3 _sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_get__sai__ResetFlashWearOutProtection(struct soap*, _sai__ResetFlashWearOutProtection *, const char*, const char*); +SOAP_FMAC3 _sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_in__sai__ResetFlashWearOutProtection(struct soap*, const char*, _sai__ResetFlashWearOutProtection *, const char*); +SOAP_FMAC5 _sai__ResetFlashWearOutProtection * SOAP_FMAC6 soap_new__sai__ResetFlashWearOutProtection(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__ResetFlashWearOutProtection(struct soap*, _sai__ResetFlashWearOutProtection*); +SOAP_FMAC3 _sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_instantiate__sai__ResetFlashWearOutProtection(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__ResetFlashWearOutProtection(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CommitChangesResponse +#define SOAP_TYPE__sai__CommitChangesResponse (76) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CommitChangesResponse(struct soap*, const char*, int, const _sai__CommitChangesResponse *, const char*); +SOAP_FMAC3 _sai__CommitChangesResponse * SOAP_FMAC4 soap_get__sai__CommitChangesResponse(struct soap*, _sai__CommitChangesResponse *, const char*, const char*); +SOAP_FMAC3 _sai__CommitChangesResponse * SOAP_FMAC4 soap_in__sai__CommitChangesResponse(struct soap*, const char*, _sai__CommitChangesResponse *, const char*); +SOAP_FMAC5 _sai__CommitChangesResponse * SOAP_FMAC6 soap_new__sai__CommitChangesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CommitChangesResponse(struct soap*, _sai__CommitChangesResponse*); +SOAP_FMAC3 _sai__CommitChangesResponse * SOAP_FMAC4 soap_instantiate__sai__CommitChangesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CommitChangesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__CommitChanges +#define SOAP_TYPE__sai__CommitChanges (75) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CommitChanges(struct soap*, const char*, int, const _sai__CommitChanges *, const char*); +SOAP_FMAC3 _sai__CommitChanges * SOAP_FMAC4 soap_get__sai__CommitChanges(struct soap*, _sai__CommitChanges *, const char*, const char*); +SOAP_FMAC3 _sai__CommitChanges * SOAP_FMAC4 soap_in__sai__CommitChanges(struct soap*, const char*, _sai__CommitChanges *, const char*); +SOAP_FMAC5 _sai__CommitChanges * SOAP_FMAC6 soap_new__sai__CommitChanges(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CommitChanges(struct soap*, _sai__CommitChanges*); +SOAP_FMAC3 _sai__CommitChanges * SOAP_FMAC4 soap_instantiate__sai__CommitChanges(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CommitChanges(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__UnprovisionResponse +#define SOAP_TYPE__sai__UnprovisionResponse (74) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UnprovisionResponse(struct soap*, const char*, int, const _sai__UnprovisionResponse *, const char*); +SOAP_FMAC3 _sai__UnprovisionResponse * SOAP_FMAC4 soap_get__sai__UnprovisionResponse(struct soap*, _sai__UnprovisionResponse *, const char*, const char*); +SOAP_FMAC3 _sai__UnprovisionResponse * SOAP_FMAC4 soap_in__sai__UnprovisionResponse(struct soap*, const char*, _sai__UnprovisionResponse *, const char*); +SOAP_FMAC5 _sai__UnprovisionResponse * SOAP_FMAC6 soap_new__sai__UnprovisionResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UnprovisionResponse(struct soap*, _sai__UnprovisionResponse*); +SOAP_FMAC3 _sai__UnprovisionResponse * SOAP_FMAC4 soap_instantiate__sai__UnprovisionResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UnprovisionResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__Unprovision +#define SOAP_TYPE__sai__Unprovision (73) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__Unprovision(struct soap*, const char*, int, const _sai__Unprovision *, const char*); +SOAP_FMAC3 _sai__Unprovision * SOAP_FMAC4 soap_get__sai__Unprovision(struct soap*, _sai__Unprovision *, const char*, const char*); +SOAP_FMAC3 _sai__Unprovision * SOAP_FMAC4 soap_in__sai__Unprovision(struct soap*, const char*, _sai__Unprovision *, const char*); +SOAP_FMAC5 _sai__Unprovision * SOAP_FMAC6 soap_new__sai__Unprovision(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__Unprovision(struct soap*, _sai__Unprovision*); +SOAP_FMAC3 _sai__Unprovision * SOAP_FMAC4 soap_instantiate__sai__Unprovision(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__Unprovision(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetProvisioningModeResponse +#define SOAP_TYPE__sai__SetProvisioningModeResponse (72) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetProvisioningModeResponse(struct soap*, const char*, int, const _sai__SetProvisioningModeResponse *, const char*); +SOAP_FMAC3 _sai__SetProvisioningModeResponse * SOAP_FMAC4 soap_get__sai__SetProvisioningModeResponse(struct soap*, _sai__SetProvisioningModeResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetProvisioningModeResponse * SOAP_FMAC4 soap_in__sai__SetProvisioningModeResponse(struct soap*, const char*, _sai__SetProvisioningModeResponse *, const char*); +SOAP_FMAC5 _sai__SetProvisioningModeResponse * SOAP_FMAC6 soap_new__sai__SetProvisioningModeResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetProvisioningModeResponse(struct soap*, _sai__SetProvisioningModeResponse*); +SOAP_FMAC3 _sai__SetProvisioningModeResponse * SOAP_FMAC4 soap_instantiate__sai__SetProvisioningModeResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetProvisioningModeResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetProvisioningMode +#define SOAP_TYPE__sai__SetProvisioningMode (71) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetProvisioningMode(struct soap*, const char*, int, const _sai__SetProvisioningMode *, const char*); +SOAP_FMAC3 _sai__SetProvisioningMode * SOAP_FMAC4 soap_get__sai__SetProvisioningMode(struct soap*, _sai__SetProvisioningMode *, const char*, const char*); +SOAP_FMAC3 _sai__SetProvisioningMode * SOAP_FMAC4 soap_in__sai__SetProvisioningMode(struct soap*, const char*, _sai__SetProvisioningMode *, const char*); +SOAP_FMAC5 _sai__SetProvisioningMode * SOAP_FMAC6 soap_new__sai__SetProvisioningMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetProvisioningMode(struct soap*, _sai__SetProvisioningMode*); +SOAP_FMAC3 _sai__SetProvisioningMode * SOAP_FMAC4 soap_instantiate__sai__SetProvisioningMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetProvisioningMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetProvisioningModeResponse +#define SOAP_TYPE__sai__GetProvisioningModeResponse (70) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningModeResponse(struct soap*, const char*, int, const _sai__GetProvisioningModeResponse *, const char*); +SOAP_FMAC3 _sai__GetProvisioningModeResponse * SOAP_FMAC4 soap_get__sai__GetProvisioningModeResponse(struct soap*, _sai__GetProvisioningModeResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningModeResponse * SOAP_FMAC4 soap_in__sai__GetProvisioningModeResponse(struct soap*, const char*, _sai__GetProvisioningModeResponse *, const char*); +SOAP_FMAC5 _sai__GetProvisioningModeResponse * SOAP_FMAC6 soap_new__sai__GetProvisioningModeResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningModeResponse(struct soap*, _sai__GetProvisioningModeResponse*); +SOAP_FMAC3 _sai__GetProvisioningModeResponse * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningModeResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningModeResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetProvisioningMode +#define SOAP_TYPE__sai__GetProvisioningMode (69) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningMode(struct soap*, const char*, int, const _sai__GetProvisioningMode *, const char*); +SOAP_FMAC3 _sai__GetProvisioningMode * SOAP_FMAC4 soap_get__sai__GetProvisioningMode(struct soap*, _sai__GetProvisioningMode *, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningMode * SOAP_FMAC4 soap_in__sai__GetProvisioningMode(struct soap*, const char*, _sai__GetProvisioningMode *, const char*); +SOAP_FMAC5 _sai__GetProvisioningMode * SOAP_FMAC6 soap_new__sai__GetProvisioningMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningMode(struct soap*, _sai__GetProvisioningMode*); +SOAP_FMAC3 _sai__GetProvisioningMode * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__UpdateCoreFromUrlResponse +#define SOAP_TYPE__sai__UpdateCoreFromUrlResponse (68) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateCoreFromUrlResponse(struct soap*, const char*, int, const _sai__UpdateCoreFromUrlResponse *, const char*); +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse * SOAP_FMAC4 soap_get__sai__UpdateCoreFromUrlResponse(struct soap*, _sai__UpdateCoreFromUrlResponse *, const char*, const char*); +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse * SOAP_FMAC4 soap_in__sai__UpdateCoreFromUrlResponse(struct soap*, const char*, _sai__UpdateCoreFromUrlResponse *, const char*); +SOAP_FMAC5 _sai__UpdateCoreFromUrlResponse * SOAP_FMAC6 soap_new__sai__UpdateCoreFromUrlResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateCoreFromUrlResponse(struct soap*, _sai__UpdateCoreFromUrlResponse*); +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse * SOAP_FMAC4 soap_instantiate__sai__UpdateCoreFromUrlResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateCoreFromUrlResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__UpdateCoreFromUrl +#define SOAP_TYPE__sai__UpdateCoreFromUrl (67) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateCoreFromUrl(struct soap*, const char*, int, const _sai__UpdateCoreFromUrl *, const char*); +SOAP_FMAC3 _sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_get__sai__UpdateCoreFromUrl(struct soap*, _sai__UpdateCoreFromUrl *, const char*, const char*); +SOAP_FMAC3 _sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_in__sai__UpdateCoreFromUrl(struct soap*, const char*, _sai__UpdateCoreFromUrl *, const char*); +SOAP_FMAC5 _sai__UpdateCoreFromUrl * SOAP_FMAC6 soap_new__sai__UpdateCoreFromUrl(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateCoreFromUrl(struct soap*, _sai__UpdateCoreFromUrl*); +SOAP_FMAC3 _sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_instantiate__sai__UpdateCoreFromUrl(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateCoreFromUrl(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTLSCertificateResponse +#define SOAP_TYPE__sai__GetTLSCertificateResponse (66) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTLSCertificateResponse(struct soap*, const char*, int, const _sai__GetTLSCertificateResponse *, const char*); +SOAP_FMAC3 _sai__GetTLSCertificateResponse * SOAP_FMAC4 soap_get__sai__GetTLSCertificateResponse(struct soap*, _sai__GetTLSCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetTLSCertificateResponse * SOAP_FMAC4 soap_in__sai__GetTLSCertificateResponse(struct soap*, const char*, _sai__GetTLSCertificateResponse *, const char*); +SOAP_FMAC5 _sai__GetTLSCertificateResponse * SOAP_FMAC6 soap_new__sai__GetTLSCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTLSCertificateResponse(struct soap*, _sai__GetTLSCertificateResponse*); +SOAP_FMAC3 _sai__GetTLSCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__GetTLSCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTLSCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetTLSCertificate +#define SOAP_TYPE__sai__GetTLSCertificate (65) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTLSCertificate(struct soap*, const char*, int, const _sai__GetTLSCertificate *, const char*); +SOAP_FMAC3 _sai__GetTLSCertificate * SOAP_FMAC4 soap_get__sai__GetTLSCertificate(struct soap*, _sai__GetTLSCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__GetTLSCertificate * SOAP_FMAC4 soap_in__sai__GetTLSCertificate(struct soap*, const char*, _sai__GetTLSCertificate *, const char*); +SOAP_FMAC5 _sai__GetTLSCertificate * SOAP_FMAC6 soap_new__sai__GetTLSCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTLSCertificate(struct soap*, _sai__GetTLSCertificate*); +SOAP_FMAC3 _sai__GetTLSCertificate * SOAP_FMAC4 soap_instantiate__sai__GetTLSCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTLSCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTLSCertificateResponse +#define SOAP_TYPE__sai__SetTLSCertificateResponse (64) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSCertificateResponse(struct soap*, const char*, int, const _sai__SetTLSCertificateResponse *, const char*); +SOAP_FMAC3 _sai__SetTLSCertificateResponse * SOAP_FMAC4 soap_get__sai__SetTLSCertificateResponse(struct soap*, _sai__SetTLSCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSCertificateResponse * SOAP_FMAC4 soap_in__sai__SetTLSCertificateResponse(struct soap*, const char*, _sai__SetTLSCertificateResponse *, const char*); +SOAP_FMAC5 _sai__SetTLSCertificateResponse * SOAP_FMAC6 soap_new__sai__SetTLSCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSCertificateResponse(struct soap*, _sai__SetTLSCertificateResponse*); +SOAP_FMAC3 _sai__SetTLSCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__SetTLSCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTLSCertificate +#define SOAP_TYPE__sai__SetTLSCertificate (63) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSCertificate(struct soap*, const char*, int, const _sai__SetTLSCertificate *, const char*); +SOAP_FMAC3 _sai__SetTLSCertificate * SOAP_FMAC4 soap_get__sai__SetTLSCertificate(struct soap*, _sai__SetTLSCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSCertificate * SOAP_FMAC4 soap_in__sai__SetTLSCertificate(struct soap*, const char*, _sai__SetTLSCertificate *, const char*); +SOAP_FMAC5 _sai__SetTLSCertificate * SOAP_FMAC6 soap_new__sai__SetTLSCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSCertificate(struct soap*, _sai__SetTLSCertificate*); +SOAP_FMAC3 _sai__SetTLSCertificate * SOAP_FMAC4 soap_instantiate__sai__SetTLSCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetRngKeyResponse +#define SOAP_TYPE__sai__SetRngKeyResponse (62) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetRngKeyResponse(struct soap*, const char*, int, const _sai__SetRngKeyResponse *, const char*); +SOAP_FMAC3 _sai__SetRngKeyResponse * SOAP_FMAC4 soap_get__sai__SetRngKeyResponse(struct soap*, _sai__SetRngKeyResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetRngKeyResponse * SOAP_FMAC4 soap_in__sai__SetRngKeyResponse(struct soap*, const char*, _sai__SetRngKeyResponse *, const char*); +SOAP_FMAC5 _sai__SetRngKeyResponse * SOAP_FMAC6 soap_new__sai__SetRngKeyResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetRngKeyResponse(struct soap*, _sai__SetRngKeyResponse*); +SOAP_FMAC3 _sai__SetRngKeyResponse * SOAP_FMAC4 soap_instantiate__sai__SetRngKeyResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetRngKeyResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetRngKey +#define SOAP_TYPE__sai__SetRngKey (61) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetRngKey(struct soap*, const char*, int, const _sai__SetRngKey *, const char*); +SOAP_FMAC3 _sai__SetRngKey * SOAP_FMAC4 soap_get__sai__SetRngKey(struct soap*, _sai__SetRngKey *, const char*, const char*); +SOAP_FMAC3 _sai__SetRngKey * SOAP_FMAC4 soap_in__sai__SetRngKey(struct soap*, const char*, _sai__SetRngKey *, const char*); +SOAP_FMAC5 _sai__SetRngKey * SOAP_FMAC6 soap_new__sai__SetRngKey(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetRngKey(struct soap*, _sai__SetRngKey*); +SOAP_FMAC3 _sai__SetRngKey * SOAP_FMAC4 soap_instantiate__sai__SetRngKey(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetRngKey(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse +#define SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse (60) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSKeyAndCertificateResponse(struct soap*, const char*, int, const _sai__SetTLSKeyAndCertificateResponse *, const char*); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse * SOAP_FMAC4 soap_get__sai__SetTLSKeyAndCertificateResponse(struct soap*, _sai__SetTLSKeyAndCertificateResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse * SOAP_FMAC4 soap_in__sai__SetTLSKeyAndCertificateResponse(struct soap*, const char*, _sai__SetTLSKeyAndCertificateResponse *, const char*); +SOAP_FMAC5 _sai__SetTLSKeyAndCertificateResponse * SOAP_FMAC6 soap_new__sai__SetTLSKeyAndCertificateResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSKeyAndCertificateResponse(struct soap*, _sai__SetTLSKeyAndCertificateResponse*); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__SetTLSKeyAndCertificateResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSKeyAndCertificateResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTLSKeyAndCertificate +#define SOAP_TYPE__sai__SetTLSKeyAndCertificate (59) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSKeyAndCertificate(struct soap*, const char*, int, const _sai__SetTLSKeyAndCertificate *, const char*); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_get__sai__SetTLSKeyAndCertificate(struct soap*, _sai__SetTLSKeyAndCertificate *, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_in__sai__SetTLSKeyAndCertificate(struct soap*, const char*, _sai__SetTLSKeyAndCertificate *, const char*); +SOAP_FMAC5 _sai__SetTLSKeyAndCertificate * SOAP_FMAC6 soap_new__sai__SetTLSKeyAndCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSKeyAndCertificate(struct soap*, _sai__SetTLSKeyAndCertificate*); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_instantiate__sai__SetTLSKeyAndCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSKeyAndCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTlsEnabledResponse +#define SOAP_TYPE__sai__SetTlsEnabledResponse (58) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTlsEnabledResponse(struct soap*, const char*, int, const _sai__SetTlsEnabledResponse *, const char*); +SOAP_FMAC3 _sai__SetTlsEnabledResponse * SOAP_FMAC4 soap_get__sai__SetTlsEnabledResponse(struct soap*, _sai__SetTlsEnabledResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetTlsEnabledResponse * SOAP_FMAC4 soap_in__sai__SetTlsEnabledResponse(struct soap*, const char*, _sai__SetTlsEnabledResponse *, const char*); +SOAP_FMAC5 _sai__SetTlsEnabledResponse * SOAP_FMAC6 soap_new__sai__SetTlsEnabledResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTlsEnabledResponse(struct soap*, _sai__SetTlsEnabledResponse*); +SOAP_FMAC3 _sai__SetTlsEnabledResponse * SOAP_FMAC4 soap_instantiate__sai__SetTlsEnabledResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTlsEnabledResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetTlsEnabled +#define SOAP_TYPE__sai__SetTlsEnabled (57) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTlsEnabled(struct soap*, const char*, int, const _sai__SetTlsEnabled *, const char*); +SOAP_FMAC3 _sai__SetTlsEnabled * SOAP_FMAC4 soap_get__sai__SetTlsEnabled(struct soap*, _sai__SetTlsEnabled *, const char*, const char*); +SOAP_FMAC3 _sai__SetTlsEnabled * SOAP_FMAC4 soap_in__sai__SetTlsEnabled(struct soap*, const char*, _sai__SetTlsEnabled *, const char*); +SOAP_FMAC5 _sai__SetTlsEnabled * SOAP_FMAC6 soap_new__sai__SetTlsEnabled(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTlsEnabled(struct soap*, _sai__SetTlsEnabled*); +SOAP_FMAC3 _sai__SetTlsEnabled * SOAP_FMAC4 soap_instantiate__sai__SetTlsEnabled(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTlsEnabled(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__RemoveUserAclEntryResponse +#define SOAP_TYPE__sai__RemoveUserAclEntryResponse (56) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__RemoveUserAclEntryResponse(struct soap*, const char*, int, const _sai__RemoveUserAclEntryResponse *, const char*); +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse * SOAP_FMAC4 soap_get__sai__RemoveUserAclEntryResponse(struct soap*, _sai__RemoveUserAclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse * SOAP_FMAC4 soap_in__sai__RemoveUserAclEntryResponse(struct soap*, const char*, _sai__RemoveUserAclEntryResponse *, const char*); +SOAP_FMAC5 _sai__RemoveUserAclEntryResponse * SOAP_FMAC6 soap_new__sai__RemoveUserAclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__RemoveUserAclEntryResponse(struct soap*, _sai__RemoveUserAclEntryResponse*); +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__RemoveUserAclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__RemoveUserAclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__RemoveUserAclEntry +#define SOAP_TYPE__sai__RemoveUserAclEntry (55) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__RemoveUserAclEntry(struct soap*, const char*, int, const _sai__RemoveUserAclEntry *, const char*); +SOAP_FMAC3 _sai__RemoveUserAclEntry * SOAP_FMAC4 soap_get__sai__RemoveUserAclEntry(struct soap*, _sai__RemoveUserAclEntry *, const char*, const char*); +SOAP_FMAC3 _sai__RemoveUserAclEntry * SOAP_FMAC4 soap_in__sai__RemoveUserAclEntry(struct soap*, const char*, _sai__RemoveUserAclEntry *, const char*); +SOAP_FMAC5 _sai__RemoveUserAclEntry * SOAP_FMAC6 soap_new__sai__RemoveUserAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__RemoveUserAclEntry(struct soap*, _sai__RemoveUserAclEntry*); +SOAP_FMAC3 _sai__RemoveUserAclEntry * SOAP_FMAC4 soap_instantiate__sai__RemoveUserAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__RemoveUserAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__UpdateUserAclEntryResponse +#define SOAP_TYPE__sai__UpdateUserAclEntryResponse (54) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateUserAclEntryResponse(struct soap*, const char*, int, const _sai__UpdateUserAclEntryResponse *, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse * SOAP_FMAC4 soap_get__sai__UpdateUserAclEntryResponse(struct soap*, _sai__UpdateUserAclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse * SOAP_FMAC4 soap_in__sai__UpdateUserAclEntryResponse(struct soap*, const char*, _sai__UpdateUserAclEntryResponse *, const char*); +SOAP_FMAC5 _sai__UpdateUserAclEntryResponse * SOAP_FMAC6 soap_new__sai__UpdateUserAclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateUserAclEntryResponse(struct soap*, _sai__UpdateUserAclEntryResponse*); +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__UpdateUserAclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateUserAclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__UpdateUserAclEntry +#define SOAP_TYPE__sai__UpdateUserAclEntry (53) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateUserAclEntry(struct soap*, const char*, int, const _sai__UpdateUserAclEntry *, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntry * SOAP_FMAC4 soap_get__sai__UpdateUserAclEntry(struct soap*, _sai__UpdateUserAclEntry *, const char*, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntry * SOAP_FMAC4 soap_in__sai__UpdateUserAclEntry(struct soap*, const char*, _sai__UpdateUserAclEntry *, const char*); +SOAP_FMAC5 _sai__UpdateUserAclEntry * SOAP_FMAC6 soap_new__sai__UpdateUserAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateUserAclEntry(struct soap*, _sai__UpdateUserAclEntry*); +SOAP_FMAC3 _sai__UpdateUserAclEntry * SOAP_FMAC4 soap_instantiate__sai__UpdateUserAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateUserAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetAdminAclEntryResponse +#define SOAP_TYPE__sai__GetAdminAclEntryResponse (52) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetAdminAclEntryResponse(struct soap*, const char*, int, const _sai__GetAdminAclEntryResponse *, const char*); +SOAP_FMAC3 _sai__GetAdminAclEntryResponse * SOAP_FMAC4 soap_get__sai__GetAdminAclEntryResponse(struct soap*, _sai__GetAdminAclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetAdminAclEntryResponse * SOAP_FMAC4 soap_in__sai__GetAdminAclEntryResponse(struct soap*, const char*, _sai__GetAdminAclEntryResponse *, const char*); +SOAP_FMAC5 _sai__GetAdminAclEntryResponse * SOAP_FMAC6 soap_new__sai__GetAdminAclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetAdminAclEntryResponse(struct soap*, _sai__GetAdminAclEntryResponse*); +SOAP_FMAC3 _sai__GetAdminAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__GetAdminAclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetAdminAclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetAdminAclEntry +#define SOAP_TYPE__sai__GetAdminAclEntry (51) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetAdminAclEntry(struct soap*, const char*, int, const _sai__GetAdminAclEntry *, const char*); +SOAP_FMAC3 _sai__GetAdminAclEntry * SOAP_FMAC4 soap_get__sai__GetAdminAclEntry(struct soap*, _sai__GetAdminAclEntry *, const char*, const char*); +SOAP_FMAC3 _sai__GetAdminAclEntry * SOAP_FMAC4 soap_in__sai__GetAdminAclEntry(struct soap*, const char*, _sai__GetAdminAclEntry *, const char*); +SOAP_FMAC5 _sai__GetAdminAclEntry * SOAP_FMAC6 soap_new__sai__GetAdminAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetAdminAclEntry(struct soap*, _sai__GetAdminAclEntry*); +SOAP_FMAC3 _sai__GetAdminAclEntry * SOAP_FMAC4 soap_instantiate__sai__GetAdminAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetAdminAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetUserAclEntryResponse +#define SOAP_TYPE__sai__GetUserAclEntryResponse (50) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetUserAclEntryResponse(struct soap*, const char*, int, const _sai__GetUserAclEntryResponse *, const char*); +SOAP_FMAC3 _sai__GetUserAclEntryResponse * SOAP_FMAC4 soap_get__sai__GetUserAclEntryResponse(struct soap*, _sai__GetUserAclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__GetUserAclEntryResponse * SOAP_FMAC4 soap_in__sai__GetUserAclEntryResponse(struct soap*, const char*, _sai__GetUserAclEntryResponse *, const char*); +SOAP_FMAC5 _sai__GetUserAclEntryResponse * SOAP_FMAC6 soap_new__sai__GetUserAclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetUserAclEntryResponse(struct soap*, _sai__GetUserAclEntryResponse*); +SOAP_FMAC3 _sai__GetUserAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__GetUserAclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetUserAclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__GetUserAclEntry +#define SOAP_TYPE__sai__GetUserAclEntry (49) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetUserAclEntry(struct soap*, const char*, int, const _sai__GetUserAclEntry *, const char*); +SOAP_FMAC3 _sai__GetUserAclEntry * SOAP_FMAC4 soap_get__sai__GetUserAclEntry(struct soap*, _sai__GetUserAclEntry *, const char*, const char*); +SOAP_FMAC3 _sai__GetUserAclEntry * SOAP_FMAC4 soap_in__sai__GetUserAclEntry(struct soap*, const char*, _sai__GetUserAclEntry *, const char*); +SOAP_FMAC5 _sai__GetUserAclEntry * SOAP_FMAC6 soap_new__sai__GetUserAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetUserAclEntry(struct soap*, _sai__GetUserAclEntry*); +SOAP_FMAC3 _sai__GetUserAclEntry * SOAP_FMAC4 soap_instantiate__sai__GetUserAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetUserAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnumerateUserAclEntriesResponse +#define SOAP_TYPE__sai__EnumerateUserAclEntriesResponse (48) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateUserAclEntriesResponse(struct soap*, const char*, int, const _sai__EnumerateUserAclEntriesResponse *, const char*); +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse * SOAP_FMAC4 soap_get__sai__EnumerateUserAclEntriesResponse(struct soap*, _sai__EnumerateUserAclEntriesResponse *, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse * SOAP_FMAC4 soap_in__sai__EnumerateUserAclEntriesResponse(struct soap*, const char*, _sai__EnumerateUserAclEntriesResponse *, const char*); +SOAP_FMAC5 _sai__EnumerateUserAclEntriesResponse * SOAP_FMAC6 soap_new__sai__EnumerateUserAclEntriesResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateUserAclEntriesResponse(struct soap*, _sai__EnumerateUserAclEntriesResponse*); +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse * SOAP_FMAC4 soap_instantiate__sai__EnumerateUserAclEntriesResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateUserAclEntriesResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__EnumerateUserAclEntries +#define SOAP_TYPE__sai__EnumerateUserAclEntries (47) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateUserAclEntries(struct soap*, const char*, int, const _sai__EnumerateUserAclEntries *, const char*); +SOAP_FMAC3 _sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_get__sai__EnumerateUserAclEntries(struct soap*, _sai__EnumerateUserAclEntries *, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_in__sai__EnumerateUserAclEntries(struct soap*, const char*, _sai__EnumerateUserAclEntries *, const char*); +SOAP_FMAC5 _sai__EnumerateUserAclEntries * SOAP_FMAC6 soap_new__sai__EnumerateUserAclEntries(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateUserAclEntries(struct soap*, _sai__EnumerateUserAclEntries*); +SOAP_FMAC3 _sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_instantiate__sai__EnumerateUserAclEntries(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateUserAclEntries(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetAdminAclEntryResponse +#define SOAP_TYPE__sai__SetAdminAclEntryResponse (46) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAdminAclEntryResponse(struct soap*, const char*, int, const _sai__SetAdminAclEntryResponse *, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntryResponse * SOAP_FMAC4 soap_get__sai__SetAdminAclEntryResponse(struct soap*, _sai__SetAdminAclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntryResponse * SOAP_FMAC4 soap_in__sai__SetAdminAclEntryResponse(struct soap*, const char*, _sai__SetAdminAclEntryResponse *, const char*); +SOAP_FMAC5 _sai__SetAdminAclEntryResponse * SOAP_FMAC6 soap_new__sai__SetAdminAclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAdminAclEntryResponse(struct soap*, _sai__SetAdminAclEntryResponse*); +SOAP_FMAC3 _sai__SetAdminAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__SetAdminAclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAdminAclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__SetAdminAclEntry +#define SOAP_TYPE__sai__SetAdminAclEntry (45) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAdminAclEntry(struct soap*, const char*, int, const _sai__SetAdminAclEntry *, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntry * SOAP_FMAC4 soap_get__sai__SetAdminAclEntry(struct soap*, _sai__SetAdminAclEntry *, const char*, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntry * SOAP_FMAC4 soap_in__sai__SetAdminAclEntry(struct soap*, const char*, _sai__SetAdminAclEntry *, const char*); +SOAP_FMAC5 _sai__SetAdminAclEntry * SOAP_FMAC6 soap_new__sai__SetAdminAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAdminAclEntry(struct soap*, _sai__SetAdminAclEntry*); +SOAP_FMAC3 _sai__SetAdminAclEntry * SOAP_FMAC4 soap_instantiate__sai__SetAdminAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAdminAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__AddUserAclEntryResponse +#define SOAP_TYPE__sai__AddUserAclEntryResponse (44) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddUserAclEntryResponse(struct soap*, const char*, int, const _sai__AddUserAclEntryResponse *, const char*); +SOAP_FMAC3 _sai__AddUserAclEntryResponse * SOAP_FMAC4 soap_get__sai__AddUserAclEntryResponse(struct soap*, _sai__AddUserAclEntryResponse *, const char*, const char*); +SOAP_FMAC3 _sai__AddUserAclEntryResponse * SOAP_FMAC4 soap_in__sai__AddUserAclEntryResponse(struct soap*, const char*, _sai__AddUserAclEntryResponse *, const char*); +SOAP_FMAC5 _sai__AddUserAclEntryResponse * SOAP_FMAC6 soap_new__sai__AddUserAclEntryResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddUserAclEntryResponse(struct soap*, _sai__AddUserAclEntryResponse*); +SOAP_FMAC3 _sai__AddUserAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__AddUserAclEntryResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddUserAclEntryResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__sai__AddUserAclEntry +#define SOAP_TYPE__sai__AddUserAclEntry (43) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddUserAclEntry(struct soap*, const char*, int, const _sai__AddUserAclEntry *, const char*); +SOAP_FMAC3 _sai__AddUserAclEntry * SOAP_FMAC4 soap_get__sai__AddUserAclEntry(struct soap*, _sai__AddUserAclEntry *, const char*, const char*); +SOAP_FMAC3 _sai__AddUserAclEntry * SOAP_FMAC4 soap_in__sai__AddUserAclEntry(struct soap*, const char*, _sai__AddUserAclEntry *, const char*); +SOAP_FMAC5 _sai__AddUserAclEntry * SOAP_FMAC6 soap_new__sai__AddUserAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddUserAclEntry(struct soap*, _sai__AddUserAclEntry*); +SOAP_FMAC3 _sai__AddUserAclEntry * SOAP_FMAC4 soap_instantiate__sai__AddUserAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddUserAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__GlobalPowerPolicyType +#define SOAP_TYPE_sai__GlobalPowerPolicyType (42) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__GlobalPowerPolicyType(struct soap*, const char*, int, const sai__GlobalPowerPolicyType *, const char*); +SOAP_FMAC3 sai__GlobalPowerPolicyType * SOAP_FMAC4 soap_get_sai__GlobalPowerPolicyType(struct soap*, sai__GlobalPowerPolicyType *, const char*, const char*); +SOAP_FMAC3 sai__GlobalPowerPolicyType * SOAP_FMAC4 soap_in_sai__GlobalPowerPolicyType(struct soap*, const char*, sai__GlobalPowerPolicyType *, const char*); +SOAP_FMAC5 sai__GlobalPowerPolicyType * SOAP_FMAC6 soap_new_sai__GlobalPowerPolicyType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__GlobalPowerPolicyType(struct soap*, sai__GlobalPowerPolicyType*); +SOAP_FMAC3 sai__GlobalPowerPolicyType * SOAP_FMAC4 soap_instantiate_sai__GlobalPowerPolicyType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__GlobalPowerPolicyType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__EnvironmentDetectionType +#define SOAP_TYPE_sai__EnvironmentDetectionType (41) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__EnvironmentDetectionType(struct soap*, const char*, int, const sai__EnvironmentDetectionType *, const char*); +SOAP_FMAC3 sai__EnvironmentDetectionType * SOAP_FMAC4 soap_get_sai__EnvironmentDetectionType(struct soap*, sai__EnvironmentDetectionType *, const char*, const char*); +SOAP_FMAC3 sai__EnvironmentDetectionType * SOAP_FMAC4 soap_in_sai__EnvironmentDetectionType(struct soap*, const char*, sai__EnvironmentDetectionType *, const char*); +SOAP_FMAC5 sai__EnvironmentDetectionType * SOAP_FMAC6 soap_new_sai__EnvironmentDetectionType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__EnvironmentDetectionType(struct soap*, sai__EnvironmentDetectionType*); +SOAP_FMAC3 sai__EnvironmentDetectionType * SOAP_FMAC4 soap_instantiate_sai__EnvironmentDetectionType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__EnvironmentDetectionType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__EnvironmentDetectionDomainType +#define SOAP_TYPE_sai__EnvironmentDetectionDomainType (40) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__EnvironmentDetectionDomainType(struct soap*, const char*, int, const sai__EnvironmentDetectionDomainType *, const char*); +SOAP_FMAC3 sai__EnvironmentDetectionDomainType * SOAP_FMAC4 soap_get_sai__EnvironmentDetectionDomainType(struct soap*, sai__EnvironmentDetectionDomainType *, const char*, const char*); +SOAP_FMAC3 sai__EnvironmentDetectionDomainType * SOAP_FMAC4 soap_in_sai__EnvironmentDetectionDomainType(struct soap*, const char*, sai__EnvironmentDetectionDomainType *, const char*); +SOAP_FMAC5 sai__EnvironmentDetectionDomainType * SOAP_FMAC6 soap_new_sai__EnvironmentDetectionDomainType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__EnvironmentDetectionDomainType(struct soap*, sai__EnvironmentDetectionDomainType*); +SOAP_FMAC3 sai__EnvironmentDetectionDomainType * SOAP_FMAC4 soap_instantiate_sai__EnvironmentDetectionDomainType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__EnvironmentDetectionDomainType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__ProvisioningAuditRecordType +#define SOAP_TYPE_sai__ProvisioningAuditRecordType (39) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__ProvisioningAuditRecordType(struct soap*, const char*, int, const sai__ProvisioningAuditRecordType *, const char*); +SOAP_FMAC3 sai__ProvisioningAuditRecordType * SOAP_FMAC4 soap_get_sai__ProvisioningAuditRecordType(struct soap*, sai__ProvisioningAuditRecordType *, const char*, const char*); +SOAP_FMAC3 sai__ProvisioningAuditRecordType * SOAP_FMAC4 soap_in_sai__ProvisioningAuditRecordType(struct soap*, const char*, sai__ProvisioningAuditRecordType *, const char*); +SOAP_FMAC5 sai__ProvisioningAuditRecordType * SOAP_FMAC6 soap_new_sai__ProvisioningAuditRecordType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__ProvisioningAuditRecordType(struct soap*, sai__ProvisioningAuditRecordType*); +SOAP_FMAC3 sai__ProvisioningAuditRecordType * SOAP_FMAC4 soap_instantiate_sai__ProvisioningAuditRecordType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__ProvisioningAuditRecordType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__CertHashEntryType +#define SOAP_TYPE_sai__CertHashEntryType (38) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CertHashEntryType(struct soap*, const char*, int, const sai__CertHashEntryType *, const char*); +SOAP_FMAC3 sai__CertHashEntryType * SOAP_FMAC4 soap_get_sai__CertHashEntryType(struct soap*, sai__CertHashEntryType *, const char*, const char*); +SOAP_FMAC3 sai__CertHashEntryType * SOAP_FMAC4 soap_in_sai__CertHashEntryType(struct soap*, const char*, sai__CertHashEntryType *, const char*); +SOAP_FMAC5 sai__CertHashEntryType * SOAP_FMAC6 soap_new_sai__CertHashEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__CertHashEntryType(struct soap*, sai__CertHashEntryType*); +SOAP_FMAC3 sai__CertHashEntryType * SOAP_FMAC4 soap_instantiate_sai__CertHashEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__CertHashEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__PkiCapsType +#define SOAP_TYPE_sai__PkiCapsType (37) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__PkiCapsType(struct soap*, const char*, int, const sai__PkiCapsType *, const char*); +SOAP_FMAC3 sai__PkiCapsType * SOAP_FMAC4 soap_get_sai__PkiCapsType(struct soap*, sai__PkiCapsType *, const char*, const char*); +SOAP_FMAC3 sai__PkiCapsType * SOAP_FMAC4 soap_in_sai__PkiCapsType(struct soap*, const char*, sai__PkiCapsType *, const char*); +SOAP_FMAC5 sai__PkiCapsType * SOAP_FMAC6 soap_new_sai__PkiCapsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__PkiCapsType(struct soap*, sai__PkiCapsType*); +SOAP_FMAC3 sai__PkiCapsType * SOAP_FMAC4 soap_instantiate_sai__PkiCapsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__PkiCapsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__CrlType +#define SOAP_TYPE_sai__CrlType (36) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CrlType(struct soap*, const char*, int, const sai__CrlType *, const char*); +SOAP_FMAC3 sai__CrlType * SOAP_FMAC4 soap_get_sai__CrlType(struct soap*, sai__CrlType *, const char*, const char*); +SOAP_FMAC3 sai__CrlType * SOAP_FMAC4 soap_in_sai__CrlType(struct soap*, const char*, sai__CrlType *, const char*); +SOAP_FMAC5 sai__CrlType * SOAP_FMAC6 soap_new_sai__CrlType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__CrlType(struct soap*, sai__CrlType*); +SOAP_FMAC3 sai__CrlType * SOAP_FMAC4 soap_instantiate_sai__CrlType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__CrlType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__CertificateType +#define SOAP_TYPE_sai__CertificateType (35) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CertificateType(struct soap*, const char*, int, const sai__CertificateType *, const char*); +SOAP_FMAC3 sai__CertificateType * SOAP_FMAC4 soap_get_sai__CertificateType(struct soap*, sai__CertificateType *, const char*, const char*); +SOAP_FMAC3 sai__CertificateType * SOAP_FMAC4 soap_in_sai__CertificateType(struct soap*, const char*, sai__CertificateType *, const char*); +SOAP_FMAC5 sai__CertificateType * SOAP_FMAC6 soap_new_sai__CertificateType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__CertificateType(struct soap*, sai__CertificateType*); +SOAP_FMAC3 sai__CertificateType * SOAP_FMAC4 soap_instantiate_sai__CertificateType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__CertificateType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__TlsOptionsType +#define SOAP_TYPE_sai__TlsOptionsType (34) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__TlsOptionsType(struct soap*, const char*, int, const sai__TlsOptionsType *, const char*); +SOAP_FMAC3 sai__TlsOptionsType * SOAP_FMAC4 soap_get_sai__TlsOptionsType(struct soap*, sai__TlsOptionsType *, const char*, const char*); +SOAP_FMAC3 sai__TlsOptionsType * SOAP_FMAC4 soap_in_sai__TlsOptionsType(struct soap*, const char*, sai__TlsOptionsType *, const char*); +SOAP_FMAC5 sai__TlsOptionsType * SOAP_FMAC6 soap_new_sai__TlsOptionsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__TlsOptionsType(struct soap*, sai__TlsOptionsType*); +SOAP_FMAC3 sai__TlsOptionsType * SOAP_FMAC4 soap_instantiate_sai__TlsOptionsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__TlsOptionsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__KerberosOptionsType +#define SOAP_TYPE_sai__KerberosOptionsType (33) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__KerberosOptionsType(struct soap*, const char*, int, const sai__KerberosOptionsType *, const char*); +SOAP_FMAC3 sai__KerberosOptionsType * SOAP_FMAC4 soap_get_sai__KerberosOptionsType(struct soap*, sai__KerberosOptionsType *, const char*, const char*); +SOAP_FMAC3 sai__KerberosOptionsType * SOAP_FMAC4 soap_in_sai__KerberosOptionsType(struct soap*, const char*, sai__KerberosOptionsType *, const char*); +SOAP_FMAC5 sai__KerberosOptionsType * SOAP_FMAC6 soap_new_sai__KerberosOptionsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__KerberosOptionsType(struct soap*, sai__KerberosOptionsType*); +SOAP_FMAC3 sai__KerberosOptionsType * SOAP_FMAC4 soap_instantiate_sai__KerberosOptionsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__KerberosOptionsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__KerberosSpnType +#define SOAP_TYPE_sai__KerberosSpnType (32) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__KerberosSpnType(struct soap*, const char*, int, const sai__KerberosSpnType *, const char*); +SOAP_FMAC3 sai__KerberosSpnType * SOAP_FMAC4 soap_get_sai__KerberosSpnType(struct soap*, sai__KerberosSpnType *, const char*, const char*); +SOAP_FMAC3 sai__KerberosSpnType * SOAP_FMAC4 soap_in_sai__KerberosSpnType(struct soap*, const char*, sai__KerberosSpnType *, const char*); +SOAP_FMAC5 sai__KerberosSpnType * SOAP_FMAC6 soap_new_sai__KerberosSpnType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__KerberosSpnType(struct soap*, sai__KerberosSpnType*); +SOAP_FMAC3 sai__KerberosSpnType * SOAP_FMAC4 soap_instantiate_sai__KerberosSpnType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__KerberosSpnType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__AdminAclEntryExType +#define SOAP_TYPE_sai__AdminAclEntryExType (31) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AdminAclEntryExType(struct soap*, const char*, int, const sai__AdminAclEntryExType *, const char*); +SOAP_FMAC3 sai__AdminAclEntryExType * SOAP_FMAC4 soap_get_sai__AdminAclEntryExType(struct soap*, sai__AdminAclEntryExType *, const char*, const char*); +SOAP_FMAC3 sai__AdminAclEntryExType * SOAP_FMAC4 soap_in_sai__AdminAclEntryExType(struct soap*, const char*, sai__AdminAclEntryExType *, const char*); +SOAP_FMAC5 sai__AdminAclEntryExType * SOAP_FMAC6 soap_new_sai__AdminAclEntryExType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AdminAclEntryExType(struct soap*, sai__AdminAclEntryExType*); +SOAP_FMAC3 sai__AdminAclEntryExType * SOAP_FMAC4 soap_instantiate_sai__AdminAclEntryExType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AdminAclEntryExType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__UserAclEntryExType +#define SOAP_TYPE_sai__UserAclEntryExType (30) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclEntryExType(struct soap*, const char*, int, const sai__UserAclEntryExType *, const char*); +SOAP_FMAC3 sai__UserAclEntryExType * SOAP_FMAC4 soap_get_sai__UserAclEntryExType(struct soap*, sai__UserAclEntryExType *, const char*, const char*); +SOAP_FMAC3 sai__UserAclEntryExType * SOAP_FMAC4 soap_in_sai__UserAclEntryExType(struct soap*, const char*, sai__UserAclEntryExType *, const char*); +SOAP_FMAC5 sai__UserAclEntryExType * SOAP_FMAC6 soap_new_sai__UserAclEntryExType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserAclEntryExType(struct soap*, sai__UserAclEntryExType*); +SOAP_FMAC3 sai__UserAclEntryExType * SOAP_FMAC4 soap_instantiate_sai__UserAclEntryExType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserAclEntryExType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__UserEntryKerberosType +#define SOAP_TYPE_sai__UserEntryKerberosType (29) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserEntryKerberosType(struct soap*, const char*, int, const sai__UserEntryKerberosType *, const char*); +SOAP_FMAC3 sai__UserEntryKerberosType * SOAP_FMAC4 soap_get_sai__UserEntryKerberosType(struct soap*, sai__UserEntryKerberosType *, const char*, const char*); +SOAP_FMAC3 sai__UserEntryKerberosType * SOAP_FMAC4 soap_in_sai__UserEntryKerberosType(struct soap*, const char*, sai__UserEntryKerberosType *, const char*); +SOAP_FMAC5 sai__UserEntryKerberosType * SOAP_FMAC6 soap_new_sai__UserEntryKerberosType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserEntryKerberosType(struct soap*, sai__UserEntryKerberosType*); +SOAP_FMAC3 sai__UserEntryKerberosType * SOAP_FMAC4 soap_instantiate_sai__UserEntryKerberosType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserEntryKerberosType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__UserEntryDigestType +#define SOAP_TYPE_sai__UserEntryDigestType (28) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserEntryDigestType(struct soap*, const char*, int, const sai__UserEntryDigestType *, const char*); +SOAP_FMAC3 sai__UserEntryDigestType * SOAP_FMAC4 soap_get_sai__UserEntryDigestType(struct soap*, sai__UserEntryDigestType *, const char*, const char*); +SOAP_FMAC3 sai__UserEntryDigestType * SOAP_FMAC4 soap_in_sai__UserEntryDigestType(struct soap*, const char*, sai__UserEntryDigestType *, const char*); +SOAP_FMAC5 sai__UserEntryDigestType * SOAP_FMAC6 soap_new_sai__UserEntryDigestType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserEntryDigestType(struct soap*, sai__UserEntryDigestType*); +SOAP_FMAC3 sai__UserEntryDigestType * SOAP_FMAC4 soap_instantiate_sai__UserEntryDigestType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserEntryDigestType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__AmtVersion +#define SOAP_TYPE_sai__AmtVersion (27) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AmtVersion(struct soap*, const char*, int, const sai__AmtVersion *, const char*); +SOAP_FMAC3 sai__AmtVersion * SOAP_FMAC4 soap_get_sai__AmtVersion(struct soap*, sai__AmtVersion *, const char*, const char*); +SOAP_FMAC3 sai__AmtVersion * SOAP_FMAC4 soap_in_sai__AmtVersion(struct soap*, const char*, sai__AmtVersion *, const char*); +SOAP_FMAC5 sai__AmtVersion * SOAP_FMAC6 soap_new_sai__AmtVersion(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AmtVersion(struct soap*, sai__AmtVersion*); +SOAP_FMAC3 sai__AmtVersion * SOAP_FMAC4 soap_instantiate_sai__AmtVersion(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AmtVersion(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__UpdateCoreUrlKeyType +#define SOAP_TYPE_sai__UpdateCoreUrlKeyType (26) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UpdateCoreUrlKeyType(struct soap*, const char*, int, const sai__UpdateCoreUrlKeyType *, const char*); +SOAP_FMAC3 sai__UpdateCoreUrlKeyType * SOAP_FMAC4 soap_get_sai__UpdateCoreUrlKeyType(struct soap*, sai__UpdateCoreUrlKeyType *, const char*, const char*); +SOAP_FMAC3 sai__UpdateCoreUrlKeyType * SOAP_FMAC4 soap_in_sai__UpdateCoreUrlKeyType(struct soap*, const char*, sai__UpdateCoreUrlKeyType *, const char*); +SOAP_FMAC5 sai__UpdateCoreUrlKeyType * SOAP_FMAC6 soap_new_sai__UpdateCoreUrlKeyType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UpdateCoreUrlKeyType(struct soap*, sai__UpdateCoreUrlKeyType*); +SOAP_FMAC3 sai__UpdateCoreUrlKeyType * SOAP_FMAC4 soap_instantiate_sai__UpdateCoreUrlKeyType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UpdateCoreUrlKeyType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__CertificateChainType +#define SOAP_TYPE_sai__CertificateChainType (25) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CertificateChainType(struct soap*, const char*, int, const sai__CertificateChainType *, const char*); +SOAP_FMAC3 sai__CertificateChainType * SOAP_FMAC4 soap_get_sai__CertificateChainType(struct soap*, sai__CertificateChainType *, const char*, const char*); +SOAP_FMAC3 sai__CertificateChainType * SOAP_FMAC4 soap_in_sai__CertificateChainType(struct soap*, const char*, sai__CertificateChainType *, const char*); +SOAP_FMAC5 sai__CertificateChainType * SOAP_FMAC6 soap_new_sai__CertificateChainType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__CertificateChainType(struct soap*, sai__CertificateChainType*); +SOAP_FMAC3 sai__CertificateChainType * SOAP_FMAC4 soap_instantiate_sai__CertificateChainType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__CertificateChainType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__RngKeyType +#define SOAP_TYPE_sai__RngKeyType (24) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RngKeyType(struct soap*, const char*, int, const sai__RngKeyType *, const char*); +SOAP_FMAC3 sai__RngKeyType * SOAP_FMAC4 soap_get_sai__RngKeyType(struct soap*, sai__RngKeyType *, const char*, const char*); +SOAP_FMAC3 sai__RngKeyType * SOAP_FMAC4 soap_in_sai__RngKeyType(struct soap*, const char*, sai__RngKeyType *, const char*); +SOAP_FMAC5 sai__RngKeyType * SOAP_FMAC6 soap_new_sai__RngKeyType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__RngKeyType(struct soap*, sai__RngKeyType*); +SOAP_FMAC3 sai__RngKeyType * SOAP_FMAC4 soap_instantiate_sai__RngKeyType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__RngKeyType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__RsaKeyType +#define SOAP_TYPE_sai__RsaKeyType (23) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RsaKeyType(struct soap*, const char*, int, const sai__RsaKeyType *, const char*); +SOAP_FMAC3 sai__RsaKeyType * SOAP_FMAC4 soap_get_sai__RsaKeyType(struct soap*, sai__RsaKeyType *, const char*, const char*); +SOAP_FMAC3 sai__RsaKeyType * SOAP_FMAC4 soap_in_sai__RsaKeyType(struct soap*, const char*, sai__RsaKeyType *, const char*); +SOAP_FMAC5 sai__RsaKeyType * SOAP_FMAC6 soap_new_sai__RsaKeyType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__RsaKeyType(struct soap*, sai__RsaKeyType*); +SOAP_FMAC3 sai__RsaKeyType * SOAP_FMAC4 soap_instantiate_sai__RsaKeyType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__RsaKeyType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__UserAclRealmListType +#define SOAP_TYPE_sai__UserAclRealmListType (22) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclRealmListType(struct soap*, const char*, int, const sai__UserAclRealmListType *, const char*); +SOAP_FMAC3 sai__UserAclRealmListType * SOAP_FMAC4 soap_get_sai__UserAclRealmListType(struct soap*, sai__UserAclRealmListType *, const char*, const char*); +SOAP_FMAC3 sai__UserAclRealmListType * SOAP_FMAC4 soap_in_sai__UserAclRealmListType(struct soap*, const char*, sai__UserAclRealmListType *, const char*); +SOAP_FMAC5 sai__UserAclRealmListType * SOAP_FMAC6 soap_new_sai__UserAclRealmListType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserAclRealmListType(struct soap*, sai__UserAclRealmListType*); +SOAP_FMAC3 sai__UserAclRealmListType * SOAP_FMAC4 soap_instantiate_sai__UserAclRealmListType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserAclRealmListType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__UserAclEntryHandleListType +#define SOAP_TYPE_sai__UserAclEntryHandleListType (21) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclEntryHandleListType(struct soap*, const char*, int, const sai__UserAclEntryHandleListType *, const char*); +SOAP_FMAC3 sai__UserAclEntryHandleListType * SOAP_FMAC4 soap_get_sai__UserAclEntryHandleListType(struct soap*, sai__UserAclEntryHandleListType *, const char*, const char*); +SOAP_FMAC3 sai__UserAclEntryHandleListType * SOAP_FMAC4 soap_in_sai__UserAclEntryHandleListType(struct soap*, const char*, sai__UserAclEntryHandleListType *, const char*); +SOAP_FMAC5 sai__UserAclEntryHandleListType * SOAP_FMAC6 soap_new_sai__UserAclEntryHandleListType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserAclEntryHandleListType(struct soap*, sai__UserAclEntryHandleListType*); +SOAP_FMAC3 sai__UserAclEntryHandleListType * SOAP_FMAC4 soap_instantiate_sai__UserAclEntryHandleListType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserAclEntryHandleListType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__AdminAclEntryType +#define SOAP_TYPE_sai__AdminAclEntryType (20) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AdminAclEntryType(struct soap*, const char*, int, const sai__AdminAclEntryType *, const char*); +SOAP_FMAC3 sai__AdminAclEntryType * SOAP_FMAC4 soap_get_sai__AdminAclEntryType(struct soap*, sai__AdminAclEntryType *, const char*, const char*); +SOAP_FMAC3 sai__AdminAclEntryType * SOAP_FMAC4 soap_in_sai__AdminAclEntryType(struct soap*, const char*, sai__AdminAclEntryType *, const char*); +SOAP_FMAC5 sai__AdminAclEntryType * SOAP_FMAC6 soap_new_sai__AdminAclEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AdminAclEntryType(struct soap*, sai__AdminAclEntryType*); +SOAP_FMAC3 sai__AdminAclEntryType * SOAP_FMAC4 soap_instantiate_sai__AdminAclEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AdminAclEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_sai__UserAclEntryType +#define SOAP_TYPE_sai__UserAclEntryType (19) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclEntryType(struct soap*, const char*, int, const sai__UserAclEntryType *, const char*); +SOAP_FMAC3 sai__UserAclEntryType * SOAP_FMAC4 soap_get_sai__UserAclEntryType(struct soap*, sai__UserAclEntryType *, const char*, const char*); +SOAP_FMAC3 sai__UserAclEntryType * SOAP_FMAC4 soap_in_sai__UserAclEntryType(struct soap*, const char*, sai__UserAclEntryType *, const char*); +SOAP_FMAC5 sai__UserAclEntryType * SOAP_FMAC6 soap_new_sai__UserAclEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserAclEntryType(struct soap*, sai__UserAclEntryType*); +SOAP_FMAC3 sai__UserAclEntryType * SOAP_FMAC4 soap_instantiate_sai__UserAclEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserAclEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cstr__KeyPairType +#define SOAP_TYPE_cstr__KeyPairType (18) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cstr__KeyPairType(struct soap*, const char*, int, const cstr__KeyPairType *, const char*); +SOAP_FMAC3 cstr__KeyPairType * SOAP_FMAC4 soap_get_cstr__KeyPairType(struct soap*, cstr__KeyPairType *, const char*, const char*); +SOAP_FMAC3 cstr__KeyPairType * SOAP_FMAC4 soap_in_cstr__KeyPairType(struct soap*, const char*, cstr__KeyPairType *, const char*); +SOAP_FMAC5 cstr__KeyPairType * SOAP_FMAC6 soap_new_cstr__KeyPairType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cstr__KeyPairType(struct soap*, cstr__KeyPairType*); +SOAP_FMAC3 cstr__KeyPairType * SOAP_FMAC4 soap_instantiate_cstr__KeyPairType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cstr__KeyPairType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cstr__RSAKeyPairType +#define SOAP_TYPE_cstr__RSAKeyPairType (17) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cstr__RSAKeyPairType(struct soap*, const char*, int, const cstr__RSAKeyPairType *, const char*); +SOAP_FMAC3 cstr__RSAKeyPairType * SOAP_FMAC4 soap_get_cstr__RSAKeyPairType(struct soap*, cstr__RSAKeyPairType *, const char*, const char*); +SOAP_FMAC3 cstr__RSAKeyPairType * SOAP_FMAC4 soap_in_cstr__RSAKeyPairType(struct soap*, const char*, cstr__RSAKeyPairType *, const char*); +SOAP_FMAC5 cstr__RSAKeyPairType * SOAP_FMAC6 soap_new_cstr__RSAKeyPairType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cstr__RSAKeyPairType(struct soap*, cstr__RSAKeyPairType*); +SOAP_FMAC3 cstr__RSAKeyPairType * SOAP_FMAC4 soap_instantiate_cstr__RSAKeyPairType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cstr__RSAKeyPairType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cmn__NodeAddressType +#define SOAP_TYPE_cmn__NodeAddressType (16) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__NodeAddressType(struct soap*, const char*, int, const cmn__NodeAddressType *, const char*); +SOAP_FMAC3 cmn__NodeAddressType * SOAP_FMAC4 soap_get_cmn__NodeAddressType(struct soap*, cmn__NodeAddressType *, const char*, const char*); +SOAP_FMAC3 cmn__NodeAddressType * SOAP_FMAC4 soap_in_cmn__NodeAddressType(struct soap*, const char*, cmn__NodeAddressType *, const char*); +SOAP_FMAC5 cmn__NodeAddressType * SOAP_FMAC6 soap_new_cmn__NodeAddressType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__NodeAddressType(struct soap*, cmn__NodeAddressType*); +SOAP_FMAC3 cmn__NodeAddressType * SOAP_FMAC4 soap_instantiate_cmn__NodeAddressType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__NodeAddressType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_cmn__URLType +#define SOAP_TYPE_cmn__URLType (15) +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__URLType(struct soap*, const char*, int, const cmn__URLType *, const char*); +SOAP_FMAC3 cmn__URLType * SOAP_FMAC4 soap_get_cmn__URLType(struct soap*, cmn__URLType *, const char*, const char*); +SOAP_FMAC3 cmn__URLType * SOAP_FMAC4 soap_in_cmn__URLType(struct soap*, const char*, cmn__URLType *, const char*); +SOAP_FMAC5 cmn__URLType * SOAP_FMAC6 soap_new_cmn__URLType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__URLType(struct soap*, cmn__URLType*); +SOAP_FMAC3 cmn__URLType * SOAP_FMAC4 soap_instantiate_cmn__URLType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__URLType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xsd__base64Binary +#define SOAP_TYPE_xsd__base64Binary (9) +#endif +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__base64Binary(struct soap*, const char*, int, const xsd__base64Binary *, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_xsd__base64Binary(struct soap*, xsd__base64Binary *, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_xsd__base64Binary(struct soap*, const char*, xsd__base64Binary *, const char*); +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_xsd__base64Binary(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xsd__base64Binary(struct soap*, xsd__base64Binary*); +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_xsd__base64Binary(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xsd__base64Binary(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_xsd__anyURI +#define SOAP_TYPE_xsd__anyURI (8) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_xsd__anyURI(struct soap*, std::string const*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_xsd__anyURI(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__anyURI(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__anyURI(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_xsd__anyURI(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_xsd__anyURI(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_xsd__anyURI(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xsd__anyURI(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_xsd__anyURI(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xsd__anyURI(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__string +#define SOAP_TYPE_std__string (7) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__string(struct soap*, const std::string *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__string(struct soap*, std::string *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_std__string(struct soap*, const std::string *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__string(struct soap*, const char*, int, const std::string*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_std__string(struct soap*, std::string *, const char*, const char*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_in_std__string(struct soap*, const char*, std::string*, const char*); +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_std__string(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__string(struct soap*, std::string*); +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_std__string(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__string(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef WITH_NOGLOBAL + +#ifndef SOAP_TYPE_SOAP_ENV__Fault +#define SOAP_TYPE_SOAP_ENV__Fault (1673) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap*, const struct SOAP_ENV__Fault *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap*, struct SOAP_ENV__Fault *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Fault(struct soap*, const struct SOAP_ENV__Fault *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Fault(struct soap*, const char*, int, const struct SOAP_ENV__Fault *, const char*); +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_get_SOAP_ENV__Fault(struct soap*, struct SOAP_ENV__Fault *, const char*, const char*); +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_in_SOAP_ENV__Fault(struct soap*, const char*, struct SOAP_ENV__Fault *, const char*); +SOAP_FMAC5 struct SOAP_ENV__Fault * SOAP_FMAC6 soap_new_SOAP_ENV__Fault(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Fault(struct soap*, struct SOAP_ENV__Fault*); +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Fault(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Fault(struct soap*, int, int, void*, size_t, const void*, size_t); + +#endif + +#ifndef WITH_NOGLOBAL + +#ifndef SOAP_TYPE_SOAP_ENV__Reason +#define SOAP_TYPE_SOAP_ENV__Reason (1672) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap*, const struct SOAP_ENV__Reason *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Reason(struct soap*, const struct SOAP_ENV__Reason *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Reason(struct soap*, const char*, int, const struct SOAP_ENV__Reason *, const char*); +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_get_SOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *, const char*, const char*); +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_in_SOAP_ENV__Reason(struct soap*, const char*, struct SOAP_ENV__Reason *, const char*); +SOAP_FMAC5 struct SOAP_ENV__Reason * SOAP_FMAC6 soap_new_SOAP_ENV__Reason(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason*); +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Reason(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Reason(struct soap*, int, int, void*, size_t, const void*, size_t); + +#endif + +#ifndef WITH_NOGLOBAL + +#ifndef SOAP_TYPE_SOAP_ENV__Detail +#define SOAP_TYPE_SOAP_ENV__Detail (1671) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap*, const struct SOAP_ENV__Detail *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Detail(struct soap*, const struct SOAP_ENV__Detail *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Detail(struct soap*, const char*, int, const struct SOAP_ENV__Detail *, const char*); +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_get_SOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *, const char*, const char*); +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_in_SOAP_ENV__Detail(struct soap*, const char*, struct SOAP_ENV__Detail *, const char*); +SOAP_FMAC5 struct SOAP_ENV__Detail * SOAP_FMAC6 soap_new_SOAP_ENV__Detail(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail*); +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Detail(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Detail(struct soap*, int, int, void*, size_t, const void*, size_t); + +#endif + +#ifndef WITH_NOGLOBAL + +#ifndef SOAP_TYPE_SOAP_ENV__Code +#define SOAP_TYPE_SOAP_ENV__Code (1669) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap*, const struct SOAP_ENV__Code *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Code(struct soap*, const struct SOAP_ENV__Code *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Code(struct soap*, const char*, int, const struct SOAP_ENV__Code *, const char*); +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_get_SOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *, const char*, const char*); +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_in_SOAP_ENV__Code(struct soap*, const char*, struct SOAP_ENV__Code *, const char*); +SOAP_FMAC5 struct SOAP_ENV__Code * SOAP_FMAC6 soap_new_SOAP_ENV__Code(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code*); +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Code(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Code(struct soap*, int, int, void*, size_t, const void*, size_t); + +#endif + +#ifndef WITH_NOGLOBAL + +#ifndef SOAP_TYPE_SOAP_ENV__Header +#define SOAP_TYPE_SOAP_ENV__Header (1668) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap*, const struct SOAP_ENV__Header *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap*, struct SOAP_ENV__Header *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Header(struct soap*, const struct SOAP_ENV__Header *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Header(struct soap*, const char*, int, const struct SOAP_ENV__Header *, const char*); +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_get_SOAP_ENV__Header(struct soap*, struct SOAP_ENV__Header *, const char*, const char*); +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_in_SOAP_ENV__Header(struct soap*, const char*, struct SOAP_ENV__Header *, const char*); +SOAP_FMAC5 struct SOAP_ENV__Header * SOAP_FMAC6 soap_new_SOAP_ENV__Header(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Header(struct soap*, struct SOAP_ENV__Header*); +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Header(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Header(struct soap*, int, int, void*, size_t, const void*, size_t); + +#endif + +#ifndef SOAP_TYPE___wcxs__GetWirelessSettings +#define SOAP_TYPE___wcxs__GetWirelessSettings (1665) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__GetWirelessSettings(struct soap*, const struct __wcxs__GetWirelessSettings *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__GetWirelessSettings(struct soap*, struct __wcxs__GetWirelessSettings *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__GetWirelessSettings(struct soap*, const struct __wcxs__GetWirelessSettings *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__GetWirelessSettings(struct soap*, const char*, int, const struct __wcxs__GetWirelessSettings *, const char*); +SOAP_FMAC3 struct __wcxs__GetWirelessSettings * SOAP_FMAC4 soap_get___wcxs__GetWirelessSettings(struct soap*, struct __wcxs__GetWirelessSettings *, const char*, const char*); +SOAP_FMAC3 struct __wcxs__GetWirelessSettings * SOAP_FMAC4 soap_in___wcxs__GetWirelessSettings(struct soap*, const char*, struct __wcxs__GetWirelessSettings *, const char*); +SOAP_FMAC5 struct __wcxs__GetWirelessSettings * SOAP_FMAC6 soap_new___wcxs__GetWirelessSettings(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__GetWirelessSettings(struct soap*, struct __wcxs__GetWirelessSettings*); +SOAP_FMAC3 struct __wcxs__GetWirelessSettings * SOAP_FMAC4 soap_instantiate___wcxs__GetWirelessSettings(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__GetWirelessSettings(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___wcxs__GetWirelessCapabilities +#define SOAP_TYPE___wcxs__GetWirelessCapabilities (1661) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__GetWirelessCapabilities(struct soap*, const struct __wcxs__GetWirelessCapabilities *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__GetWirelessCapabilities(struct soap*, struct __wcxs__GetWirelessCapabilities *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__GetWirelessCapabilities(struct soap*, const struct __wcxs__GetWirelessCapabilities *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__GetWirelessCapabilities(struct soap*, const char*, int, const struct __wcxs__GetWirelessCapabilities *, const char*); +SOAP_FMAC3 struct __wcxs__GetWirelessCapabilities * SOAP_FMAC4 soap_get___wcxs__GetWirelessCapabilities(struct soap*, struct __wcxs__GetWirelessCapabilities *, const char*, const char*); +SOAP_FMAC3 struct __wcxs__GetWirelessCapabilities * SOAP_FMAC4 soap_in___wcxs__GetWirelessCapabilities(struct soap*, const char*, struct __wcxs__GetWirelessCapabilities *, const char*); +SOAP_FMAC5 struct __wcxs__GetWirelessCapabilities * SOAP_FMAC6 soap_new___wcxs__GetWirelessCapabilities(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__GetWirelessCapabilities(struct soap*, struct __wcxs__GetWirelessCapabilities*); +SOAP_FMAC3 struct __wcxs__GetWirelessCapabilities * SOAP_FMAC4 soap_instantiate___wcxs__GetWirelessCapabilities(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__GetWirelessCapabilities(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___wcxs__EnumerateWirelessProfiles +#define SOAP_TYPE___wcxs__EnumerateWirelessProfiles (1657) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__EnumerateWirelessProfiles(struct soap*, const struct __wcxs__EnumerateWirelessProfiles *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__EnumerateWirelessProfiles(struct soap*, struct __wcxs__EnumerateWirelessProfiles *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__EnumerateWirelessProfiles(struct soap*, const struct __wcxs__EnumerateWirelessProfiles *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__EnumerateWirelessProfiles(struct soap*, const char*, int, const struct __wcxs__EnumerateWirelessProfiles *, const char*); +SOAP_FMAC3 struct __wcxs__EnumerateWirelessProfiles * SOAP_FMAC4 soap_get___wcxs__EnumerateWirelessProfiles(struct soap*, struct __wcxs__EnumerateWirelessProfiles *, const char*, const char*); +SOAP_FMAC3 struct __wcxs__EnumerateWirelessProfiles * SOAP_FMAC4 soap_in___wcxs__EnumerateWirelessProfiles(struct soap*, const char*, struct __wcxs__EnumerateWirelessProfiles *, const char*); +SOAP_FMAC5 struct __wcxs__EnumerateWirelessProfiles * SOAP_FMAC6 soap_new___wcxs__EnumerateWirelessProfiles(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__EnumerateWirelessProfiles(struct soap*, struct __wcxs__EnumerateWirelessProfiles*); +SOAP_FMAC3 struct __wcxs__EnumerateWirelessProfiles * SOAP_FMAC4 soap_instantiate___wcxs__EnumerateWirelessProfiles(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__EnumerateWirelessProfiles(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___wcxs__UpdateWirelessProfile +#define SOAP_TYPE___wcxs__UpdateWirelessProfile (1653) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__UpdateWirelessProfile(struct soap*, const struct __wcxs__UpdateWirelessProfile *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__UpdateWirelessProfile(struct soap*, struct __wcxs__UpdateWirelessProfile *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__UpdateWirelessProfile(struct soap*, const struct __wcxs__UpdateWirelessProfile *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__UpdateWirelessProfile(struct soap*, const char*, int, const struct __wcxs__UpdateWirelessProfile *, const char*); +SOAP_FMAC3 struct __wcxs__UpdateWirelessProfile * SOAP_FMAC4 soap_get___wcxs__UpdateWirelessProfile(struct soap*, struct __wcxs__UpdateWirelessProfile *, const char*, const char*); +SOAP_FMAC3 struct __wcxs__UpdateWirelessProfile * SOAP_FMAC4 soap_in___wcxs__UpdateWirelessProfile(struct soap*, const char*, struct __wcxs__UpdateWirelessProfile *, const char*); +SOAP_FMAC5 struct __wcxs__UpdateWirelessProfile * SOAP_FMAC6 soap_new___wcxs__UpdateWirelessProfile(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__UpdateWirelessProfile(struct soap*, struct __wcxs__UpdateWirelessProfile*); +SOAP_FMAC3 struct __wcxs__UpdateWirelessProfile * SOAP_FMAC4 soap_instantiate___wcxs__UpdateWirelessProfile(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__UpdateWirelessProfile(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___wcxs__RemoveWirelessProfile +#define SOAP_TYPE___wcxs__RemoveWirelessProfile (1649) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__RemoveWirelessProfile(struct soap*, const struct __wcxs__RemoveWirelessProfile *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__RemoveWirelessProfile(struct soap*, struct __wcxs__RemoveWirelessProfile *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__RemoveWirelessProfile(struct soap*, const struct __wcxs__RemoveWirelessProfile *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__RemoveWirelessProfile(struct soap*, const char*, int, const struct __wcxs__RemoveWirelessProfile *, const char*); +SOAP_FMAC3 struct __wcxs__RemoveWirelessProfile * SOAP_FMAC4 soap_get___wcxs__RemoveWirelessProfile(struct soap*, struct __wcxs__RemoveWirelessProfile *, const char*, const char*); +SOAP_FMAC3 struct __wcxs__RemoveWirelessProfile * SOAP_FMAC4 soap_in___wcxs__RemoveWirelessProfile(struct soap*, const char*, struct __wcxs__RemoveWirelessProfile *, const char*); +SOAP_FMAC5 struct __wcxs__RemoveWirelessProfile * SOAP_FMAC6 soap_new___wcxs__RemoveWirelessProfile(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__RemoveWirelessProfile(struct soap*, struct __wcxs__RemoveWirelessProfile*); +SOAP_FMAC3 struct __wcxs__RemoveWirelessProfile * SOAP_FMAC4 soap_instantiate___wcxs__RemoveWirelessProfile(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__RemoveWirelessProfile(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___wcxs__GetWirelessProfile +#define SOAP_TYPE___wcxs__GetWirelessProfile (1645) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__GetWirelessProfile(struct soap*, const struct __wcxs__GetWirelessProfile *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__GetWirelessProfile(struct soap*, struct __wcxs__GetWirelessProfile *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__GetWirelessProfile(struct soap*, const struct __wcxs__GetWirelessProfile *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__GetWirelessProfile(struct soap*, const char*, int, const struct __wcxs__GetWirelessProfile *, const char*); +SOAP_FMAC3 struct __wcxs__GetWirelessProfile * SOAP_FMAC4 soap_get___wcxs__GetWirelessProfile(struct soap*, struct __wcxs__GetWirelessProfile *, const char*, const char*); +SOAP_FMAC3 struct __wcxs__GetWirelessProfile * SOAP_FMAC4 soap_in___wcxs__GetWirelessProfile(struct soap*, const char*, struct __wcxs__GetWirelessProfile *, const char*); +SOAP_FMAC5 struct __wcxs__GetWirelessProfile * SOAP_FMAC6 soap_new___wcxs__GetWirelessProfile(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__GetWirelessProfile(struct soap*, struct __wcxs__GetWirelessProfile*); +SOAP_FMAC3 struct __wcxs__GetWirelessProfile * SOAP_FMAC4 soap_instantiate___wcxs__GetWirelessProfile(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__GetWirelessProfile(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___wcxs__AddWirelessProfile +#define SOAP_TYPE___wcxs__AddWirelessProfile (1641) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__AddWirelessProfile(struct soap*, const struct __wcxs__AddWirelessProfile *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__AddWirelessProfile(struct soap*, struct __wcxs__AddWirelessProfile *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__AddWirelessProfile(struct soap*, const struct __wcxs__AddWirelessProfile *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__AddWirelessProfile(struct soap*, const char*, int, const struct __wcxs__AddWirelessProfile *, const char*); +SOAP_FMAC3 struct __wcxs__AddWirelessProfile * SOAP_FMAC4 soap_get___wcxs__AddWirelessProfile(struct soap*, struct __wcxs__AddWirelessProfile *, const char*, const char*); +SOAP_FMAC3 struct __wcxs__AddWirelessProfile * SOAP_FMAC4 soap_in___wcxs__AddWirelessProfile(struct soap*, const char*, struct __wcxs__AddWirelessProfile *, const char*); +SOAP_FMAC5 struct __wcxs__AddWirelessProfile * SOAP_FMAC6 soap_new___wcxs__AddWirelessProfile(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__AddWirelessProfile(struct soap*, struct __wcxs__AddWirelessProfile*); +SOAP_FMAC3 struct __wcxs__AddWirelessProfile * SOAP_FMAC4 soap_instantiate___wcxs__AddWirelessProfile(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__AddWirelessProfile(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___tim__SetHighAccuracyTimeSynch +#define SOAP_TYPE___tim__SetHighAccuracyTimeSynch (1637) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tim__SetHighAccuracyTimeSynch(struct soap*, const struct __tim__SetHighAccuracyTimeSynch *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___tim__SetHighAccuracyTimeSynch(struct soap*, struct __tim__SetHighAccuracyTimeSynch *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___tim__SetHighAccuracyTimeSynch(struct soap*, const struct __tim__SetHighAccuracyTimeSynch *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___tim__SetHighAccuracyTimeSynch(struct soap*, const char*, int, const struct __tim__SetHighAccuracyTimeSynch *, const char*); +SOAP_FMAC3 struct __tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_get___tim__SetHighAccuracyTimeSynch(struct soap*, struct __tim__SetHighAccuracyTimeSynch *, const char*, const char*); +SOAP_FMAC3 struct __tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_in___tim__SetHighAccuracyTimeSynch(struct soap*, const char*, struct __tim__SetHighAccuracyTimeSynch *, const char*); +SOAP_FMAC5 struct __tim__SetHighAccuracyTimeSynch * SOAP_FMAC6 soap_new___tim__SetHighAccuracyTimeSynch(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___tim__SetHighAccuracyTimeSynch(struct soap*, struct __tim__SetHighAccuracyTimeSynch*); +SOAP_FMAC3 struct __tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_instantiate___tim__SetHighAccuracyTimeSynch(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___tim__SetHighAccuracyTimeSynch(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___tim__GetLowAccuracyTimeSynch +#define SOAP_TYPE___tim__GetLowAccuracyTimeSynch (1633) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tim__GetLowAccuracyTimeSynch(struct soap*, const struct __tim__GetLowAccuracyTimeSynch *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___tim__GetLowAccuracyTimeSynch(struct soap*, struct __tim__GetLowAccuracyTimeSynch *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___tim__GetLowAccuracyTimeSynch(struct soap*, const struct __tim__GetLowAccuracyTimeSynch *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___tim__GetLowAccuracyTimeSynch(struct soap*, const char*, int, const struct __tim__GetLowAccuracyTimeSynch *, const char*); +SOAP_FMAC3 struct __tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_get___tim__GetLowAccuracyTimeSynch(struct soap*, struct __tim__GetLowAccuracyTimeSynch *, const char*, const char*); +SOAP_FMAC3 struct __tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_in___tim__GetLowAccuracyTimeSynch(struct soap*, const char*, struct __tim__GetLowAccuracyTimeSynch *, const char*); +SOAP_FMAC5 struct __tim__GetLowAccuracyTimeSynch * SOAP_FMAC6 soap_new___tim__GetLowAccuracyTimeSynch(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___tim__GetLowAccuracyTimeSynch(struct soap*, struct __tim__GetLowAccuracyTimeSynch*); +SOAP_FMAC3 struct __tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_instantiate___tim__GetLowAccuracyTimeSynch(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___tim__GetLowAccuracyTimeSynch(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__RemoveStorageFpaclEntry +#define SOAP_TYPE___stra__RemoveStorageFpaclEntry (1629) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__RemoveStorageFpaclEntry(struct soap*, const struct __stra__RemoveStorageFpaclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__RemoveStorageFpaclEntry(struct soap*, struct __stra__RemoveStorageFpaclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__RemoveStorageFpaclEntry(struct soap*, const struct __stra__RemoveStorageFpaclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__RemoveStorageFpaclEntry(struct soap*, const char*, int, const struct __stra__RemoveStorageFpaclEntry *, const char*); +SOAP_FMAC3 struct __stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_get___stra__RemoveStorageFpaclEntry(struct soap*, struct __stra__RemoveStorageFpaclEntry *, const char*, const char*); +SOAP_FMAC3 struct __stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_in___stra__RemoveStorageFpaclEntry(struct soap*, const char*, struct __stra__RemoveStorageFpaclEntry *, const char*); +SOAP_FMAC5 struct __stra__RemoveStorageFpaclEntry * SOAP_FMAC6 soap_new___stra__RemoveStorageFpaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__RemoveStorageFpaclEntry(struct soap*, struct __stra__RemoveStorageFpaclEntry*); +SOAP_FMAC3 struct __stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_instantiate___stra__RemoveStorageFpaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__RemoveStorageFpaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__UpdateStorageFpaclEntry +#define SOAP_TYPE___stra__UpdateStorageFpaclEntry (1625) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__UpdateStorageFpaclEntry(struct soap*, const struct __stra__UpdateStorageFpaclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__UpdateStorageFpaclEntry(struct soap*, struct __stra__UpdateStorageFpaclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__UpdateStorageFpaclEntry(struct soap*, const struct __stra__UpdateStorageFpaclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__UpdateStorageFpaclEntry(struct soap*, const char*, int, const struct __stra__UpdateStorageFpaclEntry *, const char*); +SOAP_FMAC3 struct __stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_get___stra__UpdateStorageFpaclEntry(struct soap*, struct __stra__UpdateStorageFpaclEntry *, const char*, const char*); +SOAP_FMAC3 struct __stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_in___stra__UpdateStorageFpaclEntry(struct soap*, const char*, struct __stra__UpdateStorageFpaclEntry *, const char*); +SOAP_FMAC5 struct __stra__UpdateStorageFpaclEntry * SOAP_FMAC6 soap_new___stra__UpdateStorageFpaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__UpdateStorageFpaclEntry(struct soap*, struct __stra__UpdateStorageFpaclEntry*); +SOAP_FMAC3 struct __stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_instantiate___stra__UpdateStorageFpaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__UpdateStorageFpaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__GetStorageAllocEntry +#define SOAP_TYPE___stra__GetStorageAllocEntry (1621) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__GetStorageAllocEntry(struct soap*, const struct __stra__GetStorageAllocEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__GetStorageAllocEntry(struct soap*, struct __stra__GetStorageAllocEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__GetStorageAllocEntry(struct soap*, const struct __stra__GetStorageAllocEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__GetStorageAllocEntry(struct soap*, const char*, int, const struct __stra__GetStorageAllocEntry *, const char*); +SOAP_FMAC3 struct __stra__GetStorageAllocEntry * SOAP_FMAC4 soap_get___stra__GetStorageAllocEntry(struct soap*, struct __stra__GetStorageAllocEntry *, const char*, const char*); +SOAP_FMAC3 struct __stra__GetStorageAllocEntry * SOAP_FMAC4 soap_in___stra__GetStorageAllocEntry(struct soap*, const char*, struct __stra__GetStorageAllocEntry *, const char*); +SOAP_FMAC5 struct __stra__GetStorageAllocEntry * SOAP_FMAC6 soap_new___stra__GetStorageAllocEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__GetStorageAllocEntry(struct soap*, struct __stra__GetStorageAllocEntry*); +SOAP_FMAC3 struct __stra__GetStorageAllocEntry * SOAP_FMAC4 soap_instantiate___stra__GetStorageAllocEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__GetStorageAllocEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__EnumerateStorageAllocEntries +#define SOAP_TYPE___stra__EnumerateStorageAllocEntries (1617) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__EnumerateStorageAllocEntries(struct soap*, const struct __stra__EnumerateStorageAllocEntries *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__EnumerateStorageAllocEntries(struct soap*, struct __stra__EnumerateStorageAllocEntries *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__EnumerateStorageAllocEntries(struct soap*, const struct __stra__EnumerateStorageAllocEntries *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__EnumerateStorageAllocEntries(struct soap*, const char*, int, const struct __stra__EnumerateStorageAllocEntries *, const char*); +SOAP_FMAC3 struct __stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_get___stra__EnumerateStorageAllocEntries(struct soap*, struct __stra__EnumerateStorageAllocEntries *, const char*, const char*); +SOAP_FMAC3 struct __stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_in___stra__EnumerateStorageAllocEntries(struct soap*, const char*, struct __stra__EnumerateStorageAllocEntries *, const char*); +SOAP_FMAC5 struct __stra__EnumerateStorageAllocEntries * SOAP_FMAC6 soap_new___stra__EnumerateStorageAllocEntries(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__EnumerateStorageAllocEntries(struct soap*, struct __stra__EnumerateStorageAllocEntries*); +SOAP_FMAC3 struct __stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_instantiate___stra__EnumerateStorageAllocEntries(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__EnumerateStorageAllocEntries(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__AddStorageFpaclEntry +#define SOAP_TYPE___stra__AddStorageFpaclEntry (1613) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AddStorageFpaclEntry(struct soap*, const struct __stra__AddStorageFpaclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AddStorageFpaclEntry(struct soap*, struct __stra__AddStorageFpaclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AddStorageFpaclEntry(struct soap*, const struct __stra__AddStorageFpaclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AddStorageFpaclEntry(struct soap*, const char*, int, const struct __stra__AddStorageFpaclEntry *, const char*); +SOAP_FMAC3 struct __stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_get___stra__AddStorageFpaclEntry(struct soap*, struct __stra__AddStorageFpaclEntry *, const char*, const char*); +SOAP_FMAC3 struct __stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_in___stra__AddStorageFpaclEntry(struct soap*, const char*, struct __stra__AddStorageFpaclEntry *, const char*); +SOAP_FMAC5 struct __stra__AddStorageFpaclEntry * SOAP_FMAC6 soap_new___stra__AddStorageFpaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AddStorageFpaclEntry(struct soap*, struct __stra__AddStorageFpaclEntry*); +SOAP_FMAC3 struct __stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_instantiate___stra__AddStorageFpaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AddStorageFpaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__RemoveStorageEaclEntry +#define SOAP_TYPE___stra__RemoveStorageEaclEntry (1609) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__RemoveStorageEaclEntry(struct soap*, const struct __stra__RemoveStorageEaclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__RemoveStorageEaclEntry(struct soap*, struct __stra__RemoveStorageEaclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__RemoveStorageEaclEntry(struct soap*, const struct __stra__RemoveStorageEaclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__RemoveStorageEaclEntry(struct soap*, const char*, int, const struct __stra__RemoveStorageEaclEntry *, const char*); +SOAP_FMAC3 struct __stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_get___stra__RemoveStorageEaclEntry(struct soap*, struct __stra__RemoveStorageEaclEntry *, const char*, const char*); +SOAP_FMAC3 struct __stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_in___stra__RemoveStorageEaclEntry(struct soap*, const char*, struct __stra__RemoveStorageEaclEntry *, const char*); +SOAP_FMAC5 struct __stra__RemoveStorageEaclEntry * SOAP_FMAC6 soap_new___stra__RemoveStorageEaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__RemoveStorageEaclEntry(struct soap*, struct __stra__RemoveStorageEaclEntry*); +SOAP_FMAC3 struct __stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_instantiate___stra__RemoveStorageEaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__RemoveStorageEaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__GetStorageEaclEntry +#define SOAP_TYPE___stra__GetStorageEaclEntry (1605) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__GetStorageEaclEntry(struct soap*, const struct __stra__GetStorageEaclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__GetStorageEaclEntry(struct soap*, struct __stra__GetStorageEaclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__GetStorageEaclEntry(struct soap*, const struct __stra__GetStorageEaclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__GetStorageEaclEntry(struct soap*, const char*, int, const struct __stra__GetStorageEaclEntry *, const char*); +SOAP_FMAC3 struct __stra__GetStorageEaclEntry * SOAP_FMAC4 soap_get___stra__GetStorageEaclEntry(struct soap*, struct __stra__GetStorageEaclEntry *, const char*, const char*); +SOAP_FMAC3 struct __stra__GetStorageEaclEntry * SOAP_FMAC4 soap_in___stra__GetStorageEaclEntry(struct soap*, const char*, struct __stra__GetStorageEaclEntry *, const char*); +SOAP_FMAC5 struct __stra__GetStorageEaclEntry * SOAP_FMAC6 soap_new___stra__GetStorageEaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__GetStorageEaclEntry(struct soap*, struct __stra__GetStorageEaclEntry*); +SOAP_FMAC3 struct __stra__GetStorageEaclEntry * SOAP_FMAC4 soap_instantiate___stra__GetStorageEaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__GetStorageEaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__EnumerateStorageEaclEntries +#define SOAP_TYPE___stra__EnumerateStorageEaclEntries (1601) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__EnumerateStorageEaclEntries(struct soap*, const struct __stra__EnumerateStorageEaclEntries *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__EnumerateStorageEaclEntries(struct soap*, struct __stra__EnumerateStorageEaclEntries *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__EnumerateStorageEaclEntries(struct soap*, const struct __stra__EnumerateStorageEaclEntries *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__EnumerateStorageEaclEntries(struct soap*, const char*, int, const struct __stra__EnumerateStorageEaclEntries *, const char*); +SOAP_FMAC3 struct __stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_get___stra__EnumerateStorageEaclEntries(struct soap*, struct __stra__EnumerateStorageEaclEntries *, const char*, const char*); +SOAP_FMAC3 struct __stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_in___stra__EnumerateStorageEaclEntries(struct soap*, const char*, struct __stra__EnumerateStorageEaclEntries *, const char*); +SOAP_FMAC5 struct __stra__EnumerateStorageEaclEntries * SOAP_FMAC6 soap_new___stra__EnumerateStorageEaclEntries(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__EnumerateStorageEaclEntries(struct soap*, struct __stra__EnumerateStorageEaclEntries*); +SOAP_FMAC3 struct __stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_instantiate___stra__EnumerateStorageEaclEntries(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__EnumerateStorageEaclEntries(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__AddStorageEaclEntry +#define SOAP_TYPE___stra__AddStorageEaclEntry (1597) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AddStorageEaclEntry(struct soap*, const struct __stra__AddStorageEaclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AddStorageEaclEntry(struct soap*, struct __stra__AddStorageEaclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AddStorageEaclEntry(struct soap*, const struct __stra__AddStorageEaclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AddStorageEaclEntry(struct soap*, const char*, int, const struct __stra__AddStorageEaclEntry *, const char*); +SOAP_FMAC3 struct __stra__AddStorageEaclEntry * SOAP_FMAC4 soap_get___stra__AddStorageEaclEntry(struct soap*, struct __stra__AddStorageEaclEntry *, const char*, const char*); +SOAP_FMAC3 struct __stra__AddStorageEaclEntry * SOAP_FMAC4 soap_in___stra__AddStorageEaclEntry(struct soap*, const char*, struct __stra__AddStorageEaclEntry *, const char*); +SOAP_FMAC5 struct __stra__AddStorageEaclEntry * SOAP_FMAC6 soap_new___stra__AddStorageEaclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AddStorageEaclEntry(struct soap*, struct __stra__AddStorageEaclEntry*); +SOAP_FMAC3 struct __stra__AddStorageEaclEntry * SOAP_FMAC4 soap_instantiate___stra__AddStorageEaclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AddStorageEaclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__AdminRemoveApplication +#define SOAP_TYPE___stra__AdminRemoveApplication (1593) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AdminRemoveApplication(struct soap*, const struct __stra__AdminRemoveApplication *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AdminRemoveApplication(struct soap*, struct __stra__AdminRemoveApplication *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AdminRemoveApplication(struct soap*, const struct __stra__AdminRemoveApplication *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AdminRemoveApplication(struct soap*, const char*, int, const struct __stra__AdminRemoveApplication *, const char*); +SOAP_FMAC3 struct __stra__AdminRemoveApplication * SOAP_FMAC4 soap_get___stra__AdminRemoveApplication(struct soap*, struct __stra__AdminRemoveApplication *, const char*, const char*); +SOAP_FMAC3 struct __stra__AdminRemoveApplication * SOAP_FMAC4 soap_in___stra__AdminRemoveApplication(struct soap*, const char*, struct __stra__AdminRemoveApplication *, const char*); +SOAP_FMAC5 struct __stra__AdminRemoveApplication * SOAP_FMAC6 soap_new___stra__AdminRemoveApplication(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AdminRemoveApplication(struct soap*, struct __stra__AdminRemoveApplication*); +SOAP_FMAC3 struct __stra__AdminRemoveApplication * SOAP_FMAC4 soap_instantiate___stra__AdminRemoveApplication(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AdminRemoveApplication(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__AdminGetApplicationAttributes +#define SOAP_TYPE___stra__AdminGetApplicationAttributes (1589) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AdminGetApplicationAttributes(struct soap*, const struct __stra__AdminGetApplicationAttributes *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AdminGetApplicationAttributes(struct soap*, struct __stra__AdminGetApplicationAttributes *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AdminGetApplicationAttributes(struct soap*, const struct __stra__AdminGetApplicationAttributes *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AdminGetApplicationAttributes(struct soap*, const char*, int, const struct __stra__AdminGetApplicationAttributes *, const char*); +SOAP_FMAC3 struct __stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_get___stra__AdminGetApplicationAttributes(struct soap*, struct __stra__AdminGetApplicationAttributes *, const char*, const char*); +SOAP_FMAC3 struct __stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_in___stra__AdminGetApplicationAttributes(struct soap*, const char*, struct __stra__AdminGetApplicationAttributes *, const char*); +SOAP_FMAC5 struct __stra__AdminGetApplicationAttributes * SOAP_FMAC6 soap_new___stra__AdminGetApplicationAttributes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AdminGetApplicationAttributes(struct soap*, struct __stra__AdminGetApplicationAttributes*); +SOAP_FMAC3 struct __stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_instantiate___stra__AdminGetApplicationAttributes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AdminGetApplicationAttributes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__AdminGetRegisteredApplications +#define SOAP_TYPE___stra__AdminGetRegisteredApplications (1585) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AdminGetRegisteredApplications(struct soap*, const struct __stra__AdminGetRegisteredApplications *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AdminGetRegisteredApplications(struct soap*, struct __stra__AdminGetRegisteredApplications *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AdminGetRegisteredApplications(struct soap*, const struct __stra__AdminGetRegisteredApplications *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AdminGetRegisteredApplications(struct soap*, const char*, int, const struct __stra__AdminGetRegisteredApplications *, const char*); +SOAP_FMAC3 struct __stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_get___stra__AdminGetRegisteredApplications(struct soap*, struct __stra__AdminGetRegisteredApplications *, const char*, const char*); +SOAP_FMAC3 struct __stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_in___stra__AdminGetRegisteredApplications(struct soap*, const char*, struct __stra__AdminGetRegisteredApplications *, const char*); +SOAP_FMAC5 struct __stra__AdminGetRegisteredApplications * SOAP_FMAC6 soap_new___stra__AdminGetRegisteredApplications(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AdminGetRegisteredApplications(struct soap*, struct __stra__AdminGetRegisteredApplications*); +SOAP_FMAC3 struct __stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_instantiate___stra__AdminGetRegisteredApplications(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AdminGetRegisteredApplications(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__SetGlobalStorageAttributes +#define SOAP_TYPE___stra__SetGlobalStorageAttributes (1581) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__SetGlobalStorageAttributes(struct soap*, const struct __stra__SetGlobalStorageAttributes *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__SetGlobalStorageAttributes(struct soap*, struct __stra__SetGlobalStorageAttributes *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__SetGlobalStorageAttributes(struct soap*, const struct __stra__SetGlobalStorageAttributes *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__SetGlobalStorageAttributes(struct soap*, const char*, int, const struct __stra__SetGlobalStorageAttributes *, const char*); +SOAP_FMAC3 struct __stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_get___stra__SetGlobalStorageAttributes(struct soap*, struct __stra__SetGlobalStorageAttributes *, const char*, const char*); +SOAP_FMAC3 struct __stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_in___stra__SetGlobalStorageAttributes(struct soap*, const char*, struct __stra__SetGlobalStorageAttributes *, const char*); +SOAP_FMAC5 struct __stra__SetGlobalStorageAttributes * SOAP_FMAC6 soap_new___stra__SetGlobalStorageAttributes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__SetGlobalStorageAttributes(struct soap*, struct __stra__SetGlobalStorageAttributes*); +SOAP_FMAC3 struct __stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_instantiate___stra__SetGlobalStorageAttributes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__SetGlobalStorageAttributes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___stra__GetGlobalStorageAttributes +#define SOAP_TYPE___stra__GetGlobalStorageAttributes (1577) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__GetGlobalStorageAttributes(struct soap*, const struct __stra__GetGlobalStorageAttributes *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__GetGlobalStorageAttributes(struct soap*, struct __stra__GetGlobalStorageAttributes *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__GetGlobalStorageAttributes(struct soap*, const struct __stra__GetGlobalStorageAttributes *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__GetGlobalStorageAttributes(struct soap*, const char*, int, const struct __stra__GetGlobalStorageAttributes *, const char*); +SOAP_FMAC3 struct __stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_get___stra__GetGlobalStorageAttributes(struct soap*, struct __stra__GetGlobalStorageAttributes *, const char*, const char*); +SOAP_FMAC3 struct __stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_in___stra__GetGlobalStorageAttributes(struct soap*, const char*, struct __stra__GetGlobalStorageAttributes *, const char*); +SOAP_FMAC5 struct __stra__GetGlobalStorageAttributes * SOAP_FMAC6 soap_new___stra__GetGlobalStorageAttributes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__GetGlobalStorageAttributes(struct soap*, struct __stra__GetGlobalStorageAttributes*); +SOAP_FMAC3 struct __stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_instantiate___stra__GetGlobalStorageAttributes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__GetGlobalStorageAttributes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___str__ExecuteStorageOperation +#define SOAP_TYPE___str__ExecuteStorageOperation (1573) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___str__ExecuteStorageOperation(struct soap*, const struct __str__ExecuteStorageOperation *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___str__ExecuteStorageOperation(struct soap*, struct __str__ExecuteStorageOperation *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___str__ExecuteStorageOperation(struct soap*, const struct __str__ExecuteStorageOperation *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___str__ExecuteStorageOperation(struct soap*, const char*, int, const struct __str__ExecuteStorageOperation *, const char*); +SOAP_FMAC3 struct __str__ExecuteStorageOperation * SOAP_FMAC4 soap_get___str__ExecuteStorageOperation(struct soap*, struct __str__ExecuteStorageOperation *, const char*, const char*); +SOAP_FMAC3 struct __str__ExecuteStorageOperation * SOAP_FMAC4 soap_in___str__ExecuteStorageOperation(struct soap*, const char*, struct __str__ExecuteStorageOperation *, const char*); +SOAP_FMAC5 struct __str__ExecuteStorageOperation * SOAP_FMAC6 soap_new___str__ExecuteStorageOperation(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___str__ExecuteStorageOperation(struct soap*, struct __str__ExecuteStorageOperation*); +SOAP_FMAC3 struct __str__ExecuteStorageOperation * SOAP_FMAC4 soap_instantiate___str__ExecuteStorageOperation(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___str__ExecuteStorageOperation(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetAclEnabledState +#define SOAP_TYPE___sai__GetAclEnabledState (1569) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetAclEnabledState(struct soap*, const struct __sai__GetAclEnabledState *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetAclEnabledState(struct soap*, struct __sai__GetAclEnabledState *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetAclEnabledState(struct soap*, const struct __sai__GetAclEnabledState *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetAclEnabledState(struct soap*, const char*, int, const struct __sai__GetAclEnabledState *, const char*); +SOAP_FMAC3 struct __sai__GetAclEnabledState * SOAP_FMAC4 soap_get___sai__GetAclEnabledState(struct soap*, struct __sai__GetAclEnabledState *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetAclEnabledState * SOAP_FMAC4 soap_in___sai__GetAclEnabledState(struct soap*, const char*, struct __sai__GetAclEnabledState *, const char*); +SOAP_FMAC5 struct __sai__GetAclEnabledState * SOAP_FMAC6 soap_new___sai__GetAclEnabledState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetAclEnabledState(struct soap*, struct __sai__GetAclEnabledState*); +SOAP_FMAC3 struct __sai__GetAclEnabledState * SOAP_FMAC4 soap_instantiate___sai__GetAclEnabledState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetAclEnabledState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetAclEnabledState +#define SOAP_TYPE___sai__SetAclEnabledState (1565) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetAclEnabledState(struct soap*, const struct __sai__SetAclEnabledState *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetAclEnabledState(struct soap*, struct __sai__SetAclEnabledState *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetAclEnabledState(struct soap*, const struct __sai__SetAclEnabledState *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetAclEnabledState(struct soap*, const char*, int, const struct __sai__SetAclEnabledState *, const char*); +SOAP_FMAC3 struct __sai__SetAclEnabledState * SOAP_FMAC4 soap_get___sai__SetAclEnabledState(struct soap*, struct __sai__SetAclEnabledState *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetAclEnabledState * SOAP_FMAC4 soap_in___sai__SetAclEnabledState(struct soap*, const char*, struct __sai__SetAclEnabledState *, const char*); +SOAP_FMAC5 struct __sai__SetAclEnabledState * SOAP_FMAC6 soap_new___sai__SetAclEnabledState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetAclEnabledState(struct soap*, struct __sai__SetAclEnabledState*); +SOAP_FMAC3 struct __sai__SetAclEnabledState * SOAP_FMAC4 soap_instantiate___sai__SetAclEnabledState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetAclEnabledState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetConfigurationServerFQDN +#define SOAP_TYPE___sai__SetConfigurationServerFQDN (1561) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetConfigurationServerFQDN(struct soap*, const struct __sai__SetConfigurationServerFQDN *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetConfigurationServerFQDN(struct soap*, struct __sai__SetConfigurationServerFQDN *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetConfigurationServerFQDN(struct soap*, const struct __sai__SetConfigurationServerFQDN *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetConfigurationServerFQDN(struct soap*, const char*, int, const struct __sai__SetConfigurationServerFQDN *, const char*); +SOAP_FMAC3 struct __sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_get___sai__SetConfigurationServerFQDN(struct soap*, struct __sai__SetConfigurationServerFQDN *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_in___sai__SetConfigurationServerFQDN(struct soap*, const char*, struct __sai__SetConfigurationServerFQDN *, const char*); +SOAP_FMAC5 struct __sai__SetConfigurationServerFQDN * SOAP_FMAC6 soap_new___sai__SetConfigurationServerFQDN(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetConfigurationServerFQDN(struct soap*, struct __sai__SetConfigurationServerFQDN*); +SOAP_FMAC3 struct __sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_instantiate___sai__SetConfigurationServerFQDN(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetConfigurationServerFQDN(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetConfigurationServerFQDN +#define SOAP_TYPE___sai__GetConfigurationServerFQDN (1557) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetConfigurationServerFQDN(struct soap*, const struct __sai__GetConfigurationServerFQDN *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetConfigurationServerFQDN(struct soap*, struct __sai__GetConfigurationServerFQDN *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetConfigurationServerFQDN(struct soap*, const struct __sai__GetConfigurationServerFQDN *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetConfigurationServerFQDN(struct soap*, const char*, int, const struct __sai__GetConfigurationServerFQDN *, const char*); +SOAP_FMAC3 struct __sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_get___sai__GetConfigurationServerFQDN(struct soap*, struct __sai__GetConfigurationServerFQDN *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_in___sai__GetConfigurationServerFQDN(struct soap*, const char*, struct __sai__GetConfigurationServerFQDN *, const char*); +SOAP_FMAC5 struct __sai__GetConfigurationServerFQDN * SOAP_FMAC6 soap_new___sai__GetConfigurationServerFQDN(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetConfigurationServerFQDN(struct soap*, struct __sai__GetConfigurationServerFQDN*); +SOAP_FMAC3 struct __sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_instantiate___sai__GetConfigurationServerFQDN(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetConfigurationServerFQDN(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__EnableVpnRouting +#define SOAP_TYPE___sai__EnableVpnRouting (1553) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnableVpnRouting(struct soap*, const struct __sai__EnableVpnRouting *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnableVpnRouting(struct soap*, struct __sai__EnableVpnRouting *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnableVpnRouting(struct soap*, const struct __sai__EnableVpnRouting *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnableVpnRouting(struct soap*, const char*, int, const struct __sai__EnableVpnRouting *, const char*); +SOAP_FMAC3 struct __sai__EnableVpnRouting * SOAP_FMAC4 soap_get___sai__EnableVpnRouting(struct soap*, struct __sai__EnableVpnRouting *, const char*, const char*); +SOAP_FMAC3 struct __sai__EnableVpnRouting * SOAP_FMAC4 soap_in___sai__EnableVpnRouting(struct soap*, const char*, struct __sai__EnableVpnRouting *, const char*); +SOAP_FMAC5 struct __sai__EnableVpnRouting * SOAP_FMAC6 soap_new___sai__EnableVpnRouting(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnableVpnRouting(struct soap*, struct __sai__EnableVpnRouting*); +SOAP_FMAC3 struct __sai__EnableVpnRouting * SOAP_FMAC4 soap_instantiate___sai__EnableVpnRouting(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnableVpnRouting(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetTLSCredentials +#define SOAP_TYPE___sai__GetTLSCredentials (1549) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTLSCredentials(struct soap*, const struct __sai__GetTLSCredentials *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTLSCredentials(struct soap*, struct __sai__GetTLSCredentials *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTLSCredentials(struct soap*, const struct __sai__GetTLSCredentials *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTLSCredentials(struct soap*, const char*, int, const struct __sai__GetTLSCredentials *, const char*); +SOAP_FMAC3 struct __sai__GetTLSCredentials * SOAP_FMAC4 soap_get___sai__GetTLSCredentials(struct soap*, struct __sai__GetTLSCredentials *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetTLSCredentials * SOAP_FMAC4 soap_in___sai__GetTLSCredentials(struct soap*, const char*, struct __sai__GetTLSCredentials *, const char*); +SOAP_FMAC5 struct __sai__GetTLSCredentials * SOAP_FMAC6 soap_new___sai__GetTLSCredentials(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTLSCredentials(struct soap*, struct __sai__GetTLSCredentials*); +SOAP_FMAC3 struct __sai__GetTLSCredentials * SOAP_FMAC4 soap_instantiate___sai__GetTLSCredentials(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTLSCredentials(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetTLSCredentials +#define SOAP_TYPE___sai__SetTLSCredentials (1545) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTLSCredentials(struct soap*, const struct __sai__SetTLSCredentials *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTLSCredentials(struct soap*, struct __sai__SetTLSCredentials *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTLSCredentials(struct soap*, const struct __sai__SetTLSCredentials *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTLSCredentials(struct soap*, const char*, int, const struct __sai__SetTLSCredentials *, const char*); +SOAP_FMAC3 struct __sai__SetTLSCredentials * SOAP_FMAC4 soap_get___sai__SetTLSCredentials(struct soap*, struct __sai__SetTLSCredentials *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetTLSCredentials * SOAP_FMAC4 soap_in___sai__SetTLSCredentials(struct soap*, const char*, struct __sai__SetTLSCredentials *, const char*); +SOAP_FMAC5 struct __sai__SetTLSCredentials * SOAP_FMAC6 soap_new___sai__SetTLSCredentials(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTLSCredentials(struct soap*, struct __sai__SetTLSCredentials*); +SOAP_FMAC3 struct __sai__SetTLSCredentials * SOAP_FMAC4 soap_instantiate___sai__SetTLSCredentials(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTLSCredentials(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreUpdateCertificate +#define SOAP_TYPE___sai__CertStoreUpdateCertificate (1541) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreUpdateCertificate(struct soap*, const struct __sai__CertStoreUpdateCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreUpdateCertificate(struct soap*, struct __sai__CertStoreUpdateCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreUpdateCertificate(struct soap*, const struct __sai__CertStoreUpdateCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreUpdateCertificate(struct soap*, const char*, int, const struct __sai__CertStoreUpdateCertificate *, const char*); +SOAP_FMAC3 struct __sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_get___sai__CertStoreUpdateCertificate(struct soap*, struct __sai__CertStoreUpdateCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_in___sai__CertStoreUpdateCertificate(struct soap*, const char*, struct __sai__CertStoreUpdateCertificate *, const char*); +SOAP_FMAC5 struct __sai__CertStoreUpdateCertificate * SOAP_FMAC6 soap_new___sai__CertStoreUpdateCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreUpdateCertificate(struct soap*, struct __sai__CertStoreUpdateCertificate*); +SOAP_FMAC3 struct __sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_instantiate___sai__CertStoreUpdateCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreUpdateCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreGetPKCS10Request +#define SOAP_TYPE___sai__CertStoreGetPKCS10Request (1537) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreGetPKCS10Request(struct soap*, const struct __sai__CertStoreGetPKCS10Request *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreGetPKCS10Request(struct soap*, struct __sai__CertStoreGetPKCS10Request *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreGetPKCS10Request(struct soap*, const struct __sai__CertStoreGetPKCS10Request *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreGetPKCS10Request(struct soap*, const char*, int, const struct __sai__CertStoreGetPKCS10Request *, const char*); +SOAP_FMAC3 struct __sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_get___sai__CertStoreGetPKCS10Request(struct soap*, struct __sai__CertStoreGetPKCS10Request *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_in___sai__CertStoreGetPKCS10Request(struct soap*, const char*, struct __sai__CertStoreGetPKCS10Request *, const char*); +SOAP_FMAC5 struct __sai__CertStoreGetPKCS10Request * SOAP_FMAC6 soap_new___sai__CertStoreGetPKCS10Request(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreGetPKCS10Request(struct soap*, struct __sai__CertStoreGetPKCS10Request*); +SOAP_FMAC3 struct __sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_instantiate___sai__CertStoreGetPKCS10Request(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreGetPKCS10Request(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreRemoveCertificate +#define SOAP_TYPE___sai__CertStoreRemoveCertificate (1533) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreRemoveCertificate(struct soap*, const struct __sai__CertStoreRemoveCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreRemoveCertificate(struct soap*, struct __sai__CertStoreRemoveCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreRemoveCertificate(struct soap*, const struct __sai__CertStoreRemoveCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreRemoveCertificate(struct soap*, const char*, int, const struct __sai__CertStoreRemoveCertificate *, const char*); +SOAP_FMAC3 struct __sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_get___sai__CertStoreRemoveCertificate(struct soap*, struct __sai__CertStoreRemoveCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_in___sai__CertStoreRemoveCertificate(struct soap*, const char*, struct __sai__CertStoreRemoveCertificate *, const char*); +SOAP_FMAC5 struct __sai__CertStoreRemoveCertificate * SOAP_FMAC6 soap_new___sai__CertStoreRemoveCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreRemoveCertificate(struct soap*, struct __sai__CertStoreRemoveCertificate*); +SOAP_FMAC3 struct __sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_instantiate___sai__CertStoreRemoveCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreRemoveCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreEnumerateCertificates +#define SOAP_TYPE___sai__CertStoreEnumerateCertificates (1529) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreEnumerateCertificates(struct soap*, const struct __sai__CertStoreEnumerateCertificates *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreEnumerateCertificates(struct soap*, struct __sai__CertStoreEnumerateCertificates *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreEnumerateCertificates(struct soap*, const struct __sai__CertStoreEnumerateCertificates *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreEnumerateCertificates(struct soap*, const char*, int, const struct __sai__CertStoreEnumerateCertificates *, const char*); +SOAP_FMAC3 struct __sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_get___sai__CertStoreEnumerateCertificates(struct soap*, struct __sai__CertStoreEnumerateCertificates *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_in___sai__CertStoreEnumerateCertificates(struct soap*, const char*, struct __sai__CertStoreEnumerateCertificates *, const char*); +SOAP_FMAC5 struct __sai__CertStoreEnumerateCertificates * SOAP_FMAC6 soap_new___sai__CertStoreEnumerateCertificates(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreEnumerateCertificates(struct soap*, struct __sai__CertStoreEnumerateCertificates*); +SOAP_FMAC3 struct __sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_instantiate___sai__CertStoreEnumerateCertificates(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreEnumerateCertificates(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreGetCertificate +#define SOAP_TYPE___sai__CertStoreGetCertificate (1525) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreGetCertificate(struct soap*, const struct __sai__CertStoreGetCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreGetCertificate(struct soap*, struct __sai__CertStoreGetCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreGetCertificate(struct soap*, const struct __sai__CertStoreGetCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreGetCertificate(struct soap*, const char*, int, const struct __sai__CertStoreGetCertificate *, const char*); +SOAP_FMAC3 struct __sai__CertStoreGetCertificate * SOAP_FMAC4 soap_get___sai__CertStoreGetCertificate(struct soap*, struct __sai__CertStoreGetCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreGetCertificate * SOAP_FMAC4 soap_in___sai__CertStoreGetCertificate(struct soap*, const char*, struct __sai__CertStoreGetCertificate *, const char*); +SOAP_FMAC5 struct __sai__CertStoreGetCertificate * SOAP_FMAC6 soap_new___sai__CertStoreGetCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreGetCertificate(struct soap*, struct __sai__CertStoreGetCertificate*); +SOAP_FMAC3 struct __sai__CertStoreGetCertificate * SOAP_FMAC4 soap_instantiate___sai__CertStoreGetCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreGetCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreAddCertificate +#define SOAP_TYPE___sai__CertStoreAddCertificate (1521) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreAddCertificate(struct soap*, const struct __sai__CertStoreAddCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreAddCertificate(struct soap*, struct __sai__CertStoreAddCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreAddCertificate(struct soap*, const struct __sai__CertStoreAddCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreAddCertificate(struct soap*, const char*, int, const struct __sai__CertStoreAddCertificate *, const char*); +SOAP_FMAC3 struct __sai__CertStoreAddCertificate * SOAP_FMAC4 soap_get___sai__CertStoreAddCertificate(struct soap*, struct __sai__CertStoreAddCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreAddCertificate * SOAP_FMAC4 soap_in___sai__CertStoreAddCertificate(struct soap*, const char*, struct __sai__CertStoreAddCertificate *, const char*); +SOAP_FMAC5 struct __sai__CertStoreAddCertificate * SOAP_FMAC6 soap_new___sai__CertStoreAddCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreAddCertificate(struct soap*, struct __sai__CertStoreAddCertificate*); +SOAP_FMAC3 struct __sai__CertStoreAddCertificate * SOAP_FMAC4 soap_instantiate___sai__CertStoreAddCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreAddCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreRemoveKey +#define SOAP_TYPE___sai__CertStoreRemoveKey (1517) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreRemoveKey(struct soap*, const struct __sai__CertStoreRemoveKey *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreRemoveKey(struct soap*, struct __sai__CertStoreRemoveKey *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreRemoveKey(struct soap*, const struct __sai__CertStoreRemoveKey *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreRemoveKey(struct soap*, const char*, int, const struct __sai__CertStoreRemoveKey *, const char*); +SOAP_FMAC3 struct __sai__CertStoreRemoveKey * SOAP_FMAC4 soap_get___sai__CertStoreRemoveKey(struct soap*, struct __sai__CertStoreRemoveKey *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreRemoveKey * SOAP_FMAC4 soap_in___sai__CertStoreRemoveKey(struct soap*, const char*, struct __sai__CertStoreRemoveKey *, const char*); +SOAP_FMAC5 struct __sai__CertStoreRemoveKey * SOAP_FMAC6 soap_new___sai__CertStoreRemoveKey(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreRemoveKey(struct soap*, struct __sai__CertStoreRemoveKey*); +SOAP_FMAC3 struct __sai__CertStoreRemoveKey * SOAP_FMAC4 soap_instantiate___sai__CertStoreRemoveKey(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreRemoveKey(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreGetKey +#define SOAP_TYPE___sai__CertStoreGetKey (1513) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreGetKey(struct soap*, const struct __sai__CertStoreGetKey *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreGetKey(struct soap*, struct __sai__CertStoreGetKey *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreGetKey(struct soap*, const struct __sai__CertStoreGetKey *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreGetKey(struct soap*, const char*, int, const struct __sai__CertStoreGetKey *, const char*); +SOAP_FMAC3 struct __sai__CertStoreGetKey * SOAP_FMAC4 soap_get___sai__CertStoreGetKey(struct soap*, struct __sai__CertStoreGetKey *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreGetKey * SOAP_FMAC4 soap_in___sai__CertStoreGetKey(struct soap*, const char*, struct __sai__CertStoreGetKey *, const char*); +SOAP_FMAC5 struct __sai__CertStoreGetKey * SOAP_FMAC6 soap_new___sai__CertStoreGetKey(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreGetKey(struct soap*, struct __sai__CertStoreGetKey*); +SOAP_FMAC3 struct __sai__CertStoreGetKey * SOAP_FMAC4 soap_instantiate___sai__CertStoreGetKey(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreGetKey(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreEnumerateKeys +#define SOAP_TYPE___sai__CertStoreEnumerateKeys (1509) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreEnumerateKeys(struct soap*, const struct __sai__CertStoreEnumerateKeys *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreEnumerateKeys(struct soap*, struct __sai__CertStoreEnumerateKeys *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreEnumerateKeys(struct soap*, const struct __sai__CertStoreEnumerateKeys *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreEnumerateKeys(struct soap*, const char*, int, const struct __sai__CertStoreEnumerateKeys *, const char*); +SOAP_FMAC3 struct __sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_get___sai__CertStoreEnumerateKeys(struct soap*, struct __sai__CertStoreEnumerateKeys *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_in___sai__CertStoreEnumerateKeys(struct soap*, const char*, struct __sai__CertStoreEnumerateKeys *, const char*); +SOAP_FMAC5 struct __sai__CertStoreEnumerateKeys * SOAP_FMAC6 soap_new___sai__CertStoreEnumerateKeys(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreEnumerateKeys(struct soap*, struct __sai__CertStoreEnumerateKeys*); +SOAP_FMAC3 struct __sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_instantiate___sai__CertStoreEnumerateKeys(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreEnumerateKeys(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CertStoreAddKey +#define SOAP_TYPE___sai__CertStoreAddKey (1505) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreAddKey(struct soap*, const struct __sai__CertStoreAddKey *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreAddKey(struct soap*, struct __sai__CertStoreAddKey *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreAddKey(struct soap*, const struct __sai__CertStoreAddKey *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreAddKey(struct soap*, const char*, int, const struct __sai__CertStoreAddKey *, const char*); +SOAP_FMAC3 struct __sai__CertStoreAddKey * SOAP_FMAC4 soap_get___sai__CertStoreAddKey(struct soap*, struct __sai__CertStoreAddKey *, const char*, const char*); +SOAP_FMAC3 struct __sai__CertStoreAddKey * SOAP_FMAC4 soap_in___sai__CertStoreAddKey(struct soap*, const char*, struct __sai__CertStoreAddKey *, const char*); +SOAP_FMAC5 struct __sai__CertStoreAddKey * SOAP_FMAC6 soap_new___sai__CertStoreAddKey(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreAddKey(struct soap*, struct __sai__CertStoreAddKey*); +SOAP_FMAC3 struct __sai__CertStoreAddKey * SOAP_FMAC4 soap_instantiate___sai__CertStoreAddKey(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreAddKey(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetGlobalPowerPolicy +#define SOAP_TYPE___sai__GetGlobalPowerPolicy (1501) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetGlobalPowerPolicy(struct soap*, const struct __sai__GetGlobalPowerPolicy *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetGlobalPowerPolicy(struct soap*, struct __sai__GetGlobalPowerPolicy *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetGlobalPowerPolicy(struct soap*, const struct __sai__GetGlobalPowerPolicy *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetGlobalPowerPolicy(struct soap*, const char*, int, const struct __sai__GetGlobalPowerPolicy *, const char*); +SOAP_FMAC3 struct __sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_get___sai__GetGlobalPowerPolicy(struct soap*, struct __sai__GetGlobalPowerPolicy *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_in___sai__GetGlobalPowerPolicy(struct soap*, const char*, struct __sai__GetGlobalPowerPolicy *, const char*); +SOAP_FMAC5 struct __sai__GetGlobalPowerPolicy * SOAP_FMAC6 soap_new___sai__GetGlobalPowerPolicy(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetGlobalPowerPolicy(struct soap*, struct __sai__GetGlobalPowerPolicy*); +SOAP_FMAC3 struct __sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_instantiate___sai__GetGlobalPowerPolicy(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetGlobalPowerPolicy(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetGlobalPowerPolicy +#define SOAP_TYPE___sai__SetGlobalPowerPolicy (1497) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetGlobalPowerPolicy(struct soap*, const struct __sai__SetGlobalPowerPolicy *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetGlobalPowerPolicy(struct soap*, struct __sai__SetGlobalPowerPolicy *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetGlobalPowerPolicy(struct soap*, const struct __sai__SetGlobalPowerPolicy *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetGlobalPowerPolicy(struct soap*, const char*, int, const struct __sai__SetGlobalPowerPolicy *, const char*); +SOAP_FMAC3 struct __sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_get___sai__SetGlobalPowerPolicy(struct soap*, struct __sai__SetGlobalPowerPolicy *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_in___sai__SetGlobalPowerPolicy(struct soap*, const char*, struct __sai__SetGlobalPowerPolicy *, const char*); +SOAP_FMAC5 struct __sai__SetGlobalPowerPolicy * SOAP_FMAC6 soap_new___sai__SetGlobalPowerPolicy(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetGlobalPowerPolicy(struct soap*, struct __sai__SetGlobalPowerPolicy*); +SOAP_FMAC3 struct __sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_instantiate___sai__SetGlobalPowerPolicy(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetGlobalPowerPolicy(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetActivePowerPackage +#define SOAP_TYPE___sai__SetActivePowerPackage (1493) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetActivePowerPackage(struct soap*, const struct __sai__SetActivePowerPackage *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetActivePowerPackage(struct soap*, struct __sai__SetActivePowerPackage *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetActivePowerPackage(struct soap*, const struct __sai__SetActivePowerPackage *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetActivePowerPackage(struct soap*, const char*, int, const struct __sai__SetActivePowerPackage *, const char*); +SOAP_FMAC3 struct __sai__SetActivePowerPackage * SOAP_FMAC4 soap_get___sai__SetActivePowerPackage(struct soap*, struct __sai__SetActivePowerPackage *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetActivePowerPackage * SOAP_FMAC4 soap_in___sai__SetActivePowerPackage(struct soap*, const char*, struct __sai__SetActivePowerPackage *, const char*); +SOAP_FMAC5 struct __sai__SetActivePowerPackage * SOAP_FMAC6 soap_new___sai__SetActivePowerPackage(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetActivePowerPackage(struct soap*, struct __sai__SetActivePowerPackage*); +SOAP_FMAC3 struct __sai__SetActivePowerPackage * SOAP_FMAC4 soap_instantiate___sai__SetActivePowerPackage(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetActivePowerPackage(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetActivePowerPackage +#define SOAP_TYPE___sai__GetActivePowerPackage (1489) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetActivePowerPackage(struct soap*, const struct __sai__GetActivePowerPackage *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetActivePowerPackage(struct soap*, struct __sai__GetActivePowerPackage *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetActivePowerPackage(struct soap*, const struct __sai__GetActivePowerPackage *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetActivePowerPackage(struct soap*, const char*, int, const struct __sai__GetActivePowerPackage *, const char*); +SOAP_FMAC3 struct __sai__GetActivePowerPackage * SOAP_FMAC4 soap_get___sai__GetActivePowerPackage(struct soap*, struct __sai__GetActivePowerPackage *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetActivePowerPackage * SOAP_FMAC4 soap_in___sai__GetActivePowerPackage(struct soap*, const char*, struct __sai__GetActivePowerPackage *, const char*); +SOAP_FMAC5 struct __sai__GetActivePowerPackage * SOAP_FMAC6 soap_new___sai__GetActivePowerPackage(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetActivePowerPackage(struct soap*, struct __sai__GetActivePowerPackage*); +SOAP_FMAC3 struct __sai__GetActivePowerPackage * SOAP_FMAC4 soap_instantiate___sai__GetActivePowerPackage(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetActivePowerPackage(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetPowerPackage +#define SOAP_TYPE___sai__GetPowerPackage (1485) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetPowerPackage(struct soap*, const struct __sai__GetPowerPackage *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetPowerPackage(struct soap*, struct __sai__GetPowerPackage *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetPowerPackage(struct soap*, const struct __sai__GetPowerPackage *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetPowerPackage(struct soap*, const char*, int, const struct __sai__GetPowerPackage *, const char*); +SOAP_FMAC3 struct __sai__GetPowerPackage * SOAP_FMAC4 soap_get___sai__GetPowerPackage(struct soap*, struct __sai__GetPowerPackage *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetPowerPackage * SOAP_FMAC4 soap_in___sai__GetPowerPackage(struct soap*, const char*, struct __sai__GetPowerPackage *, const char*); +SOAP_FMAC5 struct __sai__GetPowerPackage * SOAP_FMAC6 soap_new___sai__GetPowerPackage(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetPowerPackage(struct soap*, struct __sai__GetPowerPackage*); +SOAP_FMAC3 struct __sai__GetPowerPackage * SOAP_FMAC4 soap_instantiate___sai__GetPowerPackage(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetPowerPackage(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__EnumeratePowerPackages +#define SOAP_TYPE___sai__EnumeratePowerPackages (1481) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnumeratePowerPackages(struct soap*, const struct __sai__EnumeratePowerPackages *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnumeratePowerPackages(struct soap*, struct __sai__EnumeratePowerPackages *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnumeratePowerPackages(struct soap*, const struct __sai__EnumeratePowerPackages *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnumeratePowerPackages(struct soap*, const char*, int, const struct __sai__EnumeratePowerPackages *, const char*); +SOAP_FMAC3 struct __sai__EnumeratePowerPackages * SOAP_FMAC4 soap_get___sai__EnumeratePowerPackages(struct soap*, struct __sai__EnumeratePowerPackages *, const char*, const char*); +SOAP_FMAC3 struct __sai__EnumeratePowerPackages * SOAP_FMAC4 soap_in___sai__EnumeratePowerPackages(struct soap*, const char*, struct __sai__EnumeratePowerPackages *, const char*); +SOAP_FMAC5 struct __sai__EnumeratePowerPackages * SOAP_FMAC6 soap_new___sai__EnumeratePowerPackages(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnumeratePowerPackages(struct soap*, struct __sai__EnumeratePowerPackages*); +SOAP_FMAC3 struct __sai__EnumeratePowerPackages * SOAP_FMAC4 soap_instantiate___sai__EnumeratePowerPackages(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnumeratePowerPackages(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetEnvironmentDetection +#define SOAP_TYPE___sai__GetEnvironmentDetection (1477) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetEnvironmentDetection(struct soap*, const struct __sai__GetEnvironmentDetection *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetEnvironmentDetection(struct soap*, struct __sai__GetEnvironmentDetection *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetEnvironmentDetection(struct soap*, const struct __sai__GetEnvironmentDetection *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetEnvironmentDetection(struct soap*, const char*, int, const struct __sai__GetEnvironmentDetection *, const char*); +SOAP_FMAC3 struct __sai__GetEnvironmentDetection * SOAP_FMAC4 soap_get___sai__GetEnvironmentDetection(struct soap*, struct __sai__GetEnvironmentDetection *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetEnvironmentDetection * SOAP_FMAC4 soap_in___sai__GetEnvironmentDetection(struct soap*, const char*, struct __sai__GetEnvironmentDetection *, const char*); +SOAP_FMAC5 struct __sai__GetEnvironmentDetection * SOAP_FMAC6 soap_new___sai__GetEnvironmentDetection(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetEnvironmentDetection(struct soap*, struct __sai__GetEnvironmentDetection*); +SOAP_FMAC3 struct __sai__GetEnvironmentDetection * SOAP_FMAC4 soap_instantiate___sai__GetEnvironmentDetection(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetEnvironmentDetection(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetEnvironmentDetection +#define SOAP_TYPE___sai__SetEnvironmentDetection (1473) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetEnvironmentDetection(struct soap*, const struct __sai__SetEnvironmentDetection *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetEnvironmentDetection(struct soap*, struct __sai__SetEnvironmentDetection *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetEnvironmentDetection(struct soap*, const struct __sai__SetEnvironmentDetection *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetEnvironmentDetection(struct soap*, const char*, int, const struct __sai__SetEnvironmentDetection *, const char*); +SOAP_FMAC3 struct __sai__SetEnvironmentDetection * SOAP_FMAC4 soap_get___sai__SetEnvironmentDetection(struct soap*, struct __sai__SetEnvironmentDetection *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetEnvironmentDetection * SOAP_FMAC4 soap_in___sai__SetEnvironmentDetection(struct soap*, const char*, struct __sai__SetEnvironmentDetection *, const char*); +SOAP_FMAC5 struct __sai__SetEnvironmentDetection * SOAP_FMAC6 soap_new___sai__SetEnvironmentDetection(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetEnvironmentDetection(struct soap*, struct __sai__SetEnvironmentDetection*); +SOAP_FMAC3 struct __sai__SetEnvironmentDetection * SOAP_FMAC4 soap_instantiate___sai__SetEnvironmentDetection(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetEnvironmentDetection(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetRealmAuthOptions +#define SOAP_TYPE___sai__SetRealmAuthOptions (1469) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetRealmAuthOptions(struct soap*, const struct __sai__SetRealmAuthOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetRealmAuthOptions(struct soap*, struct __sai__SetRealmAuthOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetRealmAuthOptions(struct soap*, const struct __sai__SetRealmAuthOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetRealmAuthOptions(struct soap*, const char*, int, const struct __sai__SetRealmAuthOptions *, const char*); +SOAP_FMAC3 struct __sai__SetRealmAuthOptions * SOAP_FMAC4 soap_get___sai__SetRealmAuthOptions(struct soap*, struct __sai__SetRealmAuthOptions *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetRealmAuthOptions * SOAP_FMAC4 soap_in___sai__SetRealmAuthOptions(struct soap*, const char*, struct __sai__SetRealmAuthOptions *, const char*); +SOAP_FMAC5 struct __sai__SetRealmAuthOptions * SOAP_FMAC6 soap_new___sai__SetRealmAuthOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetRealmAuthOptions(struct soap*, struct __sai__SetRealmAuthOptions*); +SOAP_FMAC3 struct __sai__SetRealmAuthOptions * SOAP_FMAC4 soap_instantiate___sai__SetRealmAuthOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetRealmAuthOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetRealmAuthOptions +#define SOAP_TYPE___sai__GetRealmAuthOptions (1465) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetRealmAuthOptions(struct soap*, const struct __sai__GetRealmAuthOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetRealmAuthOptions(struct soap*, struct __sai__GetRealmAuthOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetRealmAuthOptions(struct soap*, const struct __sai__GetRealmAuthOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetRealmAuthOptions(struct soap*, const char*, int, const struct __sai__GetRealmAuthOptions *, const char*); +SOAP_FMAC3 struct __sai__GetRealmAuthOptions * SOAP_FMAC4 soap_get___sai__GetRealmAuthOptions(struct soap*, struct __sai__GetRealmAuthOptions *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetRealmAuthOptions * SOAP_FMAC4 soap_in___sai__GetRealmAuthOptions(struct soap*, const char*, struct __sai__GetRealmAuthOptions *, const char*); +SOAP_FMAC5 struct __sai__GetRealmAuthOptions * SOAP_FMAC6 soap_new___sai__GetRealmAuthOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetRealmAuthOptions(struct soap*, struct __sai__GetRealmAuthOptions*); +SOAP_FMAC3 struct __sai__GetRealmAuthOptions * SOAP_FMAC4 soap_instantiate___sai__GetRealmAuthOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetRealmAuthOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__ExtendProvisioningPeriod +#define SOAP_TYPE___sai__ExtendProvisioningPeriod (1461) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__ExtendProvisioningPeriod(struct soap*, const struct __sai__ExtendProvisioningPeriod *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__ExtendProvisioningPeriod(struct soap*, struct __sai__ExtendProvisioningPeriod *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__ExtendProvisioningPeriod(struct soap*, const struct __sai__ExtendProvisioningPeriod *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__ExtendProvisioningPeriod(struct soap*, const char*, int, const struct __sai__ExtendProvisioningPeriod *, const char*); +SOAP_FMAC3 struct __sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_get___sai__ExtendProvisioningPeriod(struct soap*, struct __sai__ExtendProvisioningPeriod *, const char*, const char*); +SOAP_FMAC3 struct __sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_in___sai__ExtendProvisioningPeriod(struct soap*, const char*, struct __sai__ExtendProvisioningPeriod *, const char*); +SOAP_FMAC5 struct __sai__ExtendProvisioningPeriod * SOAP_FMAC6 soap_new___sai__ExtendProvisioningPeriod(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__ExtendProvisioningPeriod(struct soap*, struct __sai__ExtendProvisioningPeriod*); +SOAP_FMAC3 struct __sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_instantiate___sai__ExtendProvisioningPeriod(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__ExtendProvisioningPeriod(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetProvisioningPID +#define SOAP_TYPE___sai__GetProvisioningPID (1457) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetProvisioningPID(struct soap*, const struct __sai__GetProvisioningPID *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetProvisioningPID(struct soap*, struct __sai__GetProvisioningPID *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetProvisioningPID(struct soap*, const struct __sai__GetProvisioningPID *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetProvisioningPID(struct soap*, const char*, int, const struct __sai__GetProvisioningPID *, const char*); +SOAP_FMAC3 struct __sai__GetProvisioningPID * SOAP_FMAC4 soap_get___sai__GetProvisioningPID(struct soap*, struct __sai__GetProvisioningPID *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetProvisioningPID * SOAP_FMAC4 soap_in___sai__GetProvisioningPID(struct soap*, const char*, struct __sai__GetProvisioningPID *, const char*); +SOAP_FMAC5 struct __sai__GetProvisioningPID * SOAP_FMAC6 soap_new___sai__GetProvisioningPID(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetProvisioningPID(struct soap*, struct __sai__GetProvisioningPID*); +SOAP_FMAC3 struct __sai__GetProvisioningPID * SOAP_FMAC4 soap_instantiate___sai__GetProvisioningPID(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetProvisioningPID(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetProvisioningAuditRecord +#define SOAP_TYPE___sai__GetProvisioningAuditRecord (1453) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetProvisioningAuditRecord(struct soap*, const struct __sai__GetProvisioningAuditRecord *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetProvisioningAuditRecord(struct soap*, struct __sai__GetProvisioningAuditRecord *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetProvisioningAuditRecord(struct soap*, const struct __sai__GetProvisioningAuditRecord *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetProvisioningAuditRecord(struct soap*, const char*, int, const struct __sai__GetProvisioningAuditRecord *, const char*); +SOAP_FMAC3 struct __sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_get___sai__GetProvisioningAuditRecord(struct soap*, struct __sai__GetProvisioningAuditRecord *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_in___sai__GetProvisioningAuditRecord(struct soap*, const char*, struct __sai__GetProvisioningAuditRecord *, const char*); +SOAP_FMAC5 struct __sai__GetProvisioningAuditRecord * SOAP_FMAC6 soap_new___sai__GetProvisioningAuditRecord(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetProvisioningAuditRecord(struct soap*, struct __sai__GetProvisioningAuditRecord*); +SOAP_FMAC3 struct __sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_instantiate___sai__GetProvisioningAuditRecord(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetProvisioningAuditRecord(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetZeroTouchConfigurationMode +#define SOAP_TYPE___sai__SetZeroTouchConfigurationMode (1449) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetZeroTouchConfigurationMode(struct soap*, const struct __sai__SetZeroTouchConfigurationMode *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetZeroTouchConfigurationMode(struct soap*, struct __sai__SetZeroTouchConfigurationMode *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetZeroTouchConfigurationMode(struct soap*, const struct __sai__SetZeroTouchConfigurationMode *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetZeroTouchConfigurationMode(struct soap*, const char*, int, const struct __sai__SetZeroTouchConfigurationMode *, const char*); +SOAP_FMAC3 struct __sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_get___sai__SetZeroTouchConfigurationMode(struct soap*, struct __sai__SetZeroTouchConfigurationMode *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_in___sai__SetZeroTouchConfigurationMode(struct soap*, const char*, struct __sai__SetZeroTouchConfigurationMode *, const char*); +SOAP_FMAC5 struct __sai__SetZeroTouchConfigurationMode * SOAP_FMAC6 soap_new___sai__SetZeroTouchConfigurationMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetZeroTouchConfigurationMode(struct soap*, struct __sai__SetZeroTouchConfigurationMode*); +SOAP_FMAC3 struct __sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_instantiate___sai__SetZeroTouchConfigurationMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetZeroTouchConfigurationMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetZeroTouchConfigurationMode +#define SOAP_TYPE___sai__GetZeroTouchConfigurationMode (1445) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetZeroTouchConfigurationMode(struct soap*, const struct __sai__GetZeroTouchConfigurationMode *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetZeroTouchConfigurationMode(struct soap*, struct __sai__GetZeroTouchConfigurationMode *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetZeroTouchConfigurationMode(struct soap*, const struct __sai__GetZeroTouchConfigurationMode *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetZeroTouchConfigurationMode(struct soap*, const char*, int, const struct __sai__GetZeroTouchConfigurationMode *, const char*); +SOAP_FMAC3 struct __sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_get___sai__GetZeroTouchConfigurationMode(struct soap*, struct __sai__GetZeroTouchConfigurationMode *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_in___sai__GetZeroTouchConfigurationMode(struct soap*, const char*, struct __sai__GetZeroTouchConfigurationMode *, const char*); +SOAP_FMAC5 struct __sai__GetZeroTouchConfigurationMode * SOAP_FMAC6 soap_new___sai__GetZeroTouchConfigurationMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetZeroTouchConfigurationMode(struct soap*, struct __sai__GetZeroTouchConfigurationMode*); +SOAP_FMAC3 struct __sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_instantiate___sai__GetZeroTouchConfigurationMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetZeroTouchConfigurationMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__EnableCertificateHashEntry +#define SOAP_TYPE___sai__EnableCertificateHashEntry (1441) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnableCertificateHashEntry(struct soap*, const struct __sai__EnableCertificateHashEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnableCertificateHashEntry(struct soap*, struct __sai__EnableCertificateHashEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnableCertificateHashEntry(struct soap*, const struct __sai__EnableCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnableCertificateHashEntry(struct soap*, const char*, int, const struct __sai__EnableCertificateHashEntry *, const char*); +SOAP_FMAC3 struct __sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_get___sai__EnableCertificateHashEntry(struct soap*, struct __sai__EnableCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_in___sai__EnableCertificateHashEntry(struct soap*, const char*, struct __sai__EnableCertificateHashEntry *, const char*); +SOAP_FMAC5 struct __sai__EnableCertificateHashEntry * SOAP_FMAC6 soap_new___sai__EnableCertificateHashEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnableCertificateHashEntry(struct soap*, struct __sai__EnableCertificateHashEntry*); +SOAP_FMAC3 struct __sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_instantiate___sai__EnableCertificateHashEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnableCertificateHashEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__DeleteCertificateHashEntry +#define SOAP_TYPE___sai__DeleteCertificateHashEntry (1437) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__DeleteCertificateHashEntry(struct soap*, const struct __sai__DeleteCertificateHashEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__DeleteCertificateHashEntry(struct soap*, struct __sai__DeleteCertificateHashEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__DeleteCertificateHashEntry(struct soap*, const struct __sai__DeleteCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__DeleteCertificateHashEntry(struct soap*, const char*, int, const struct __sai__DeleteCertificateHashEntry *, const char*); +SOAP_FMAC3 struct __sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_get___sai__DeleteCertificateHashEntry(struct soap*, struct __sai__DeleteCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_in___sai__DeleteCertificateHashEntry(struct soap*, const char*, struct __sai__DeleteCertificateHashEntry *, const char*); +SOAP_FMAC5 struct __sai__DeleteCertificateHashEntry * SOAP_FMAC6 soap_new___sai__DeleteCertificateHashEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__DeleteCertificateHashEntry(struct soap*, struct __sai__DeleteCertificateHashEntry*); +SOAP_FMAC3 struct __sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_instantiate___sai__DeleteCertificateHashEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__DeleteCertificateHashEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__AddCertificateHashEntry +#define SOAP_TYPE___sai__AddCertificateHashEntry (1433) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__AddCertificateHashEntry(struct soap*, const struct __sai__AddCertificateHashEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__AddCertificateHashEntry(struct soap*, struct __sai__AddCertificateHashEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__AddCertificateHashEntry(struct soap*, const struct __sai__AddCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__AddCertificateHashEntry(struct soap*, const char*, int, const struct __sai__AddCertificateHashEntry *, const char*); +SOAP_FMAC3 struct __sai__AddCertificateHashEntry * SOAP_FMAC4 soap_get___sai__AddCertificateHashEntry(struct soap*, struct __sai__AddCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__AddCertificateHashEntry * SOAP_FMAC4 soap_in___sai__AddCertificateHashEntry(struct soap*, const char*, struct __sai__AddCertificateHashEntry *, const char*); +SOAP_FMAC5 struct __sai__AddCertificateHashEntry * SOAP_FMAC6 soap_new___sai__AddCertificateHashEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__AddCertificateHashEntry(struct soap*, struct __sai__AddCertificateHashEntry*); +SOAP_FMAC3 struct __sai__AddCertificateHashEntry * SOAP_FMAC4 soap_instantiate___sai__AddCertificateHashEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__AddCertificateHashEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetCertificateHashEntry +#define SOAP_TYPE___sai__GetCertificateHashEntry (1429) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetCertificateHashEntry(struct soap*, const struct __sai__GetCertificateHashEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetCertificateHashEntry(struct soap*, struct __sai__GetCertificateHashEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetCertificateHashEntry(struct soap*, const struct __sai__GetCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetCertificateHashEntry(struct soap*, const char*, int, const struct __sai__GetCertificateHashEntry *, const char*); +SOAP_FMAC3 struct __sai__GetCertificateHashEntry * SOAP_FMAC4 soap_get___sai__GetCertificateHashEntry(struct soap*, struct __sai__GetCertificateHashEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetCertificateHashEntry * SOAP_FMAC4 soap_in___sai__GetCertificateHashEntry(struct soap*, const char*, struct __sai__GetCertificateHashEntry *, const char*); +SOAP_FMAC5 struct __sai__GetCertificateHashEntry * SOAP_FMAC6 soap_new___sai__GetCertificateHashEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetCertificateHashEntry(struct soap*, struct __sai__GetCertificateHashEntry*); +SOAP_FMAC3 struct __sai__GetCertificateHashEntry * SOAP_FMAC4 soap_instantiate___sai__GetCertificateHashEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetCertificateHashEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__EnumerateCertificateHashEntries +#define SOAP_TYPE___sai__EnumerateCertificateHashEntries (1425) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnumerateCertificateHashEntries(struct soap*, const struct __sai__EnumerateCertificateHashEntries *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnumerateCertificateHashEntries(struct soap*, struct __sai__EnumerateCertificateHashEntries *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnumerateCertificateHashEntries(struct soap*, const struct __sai__EnumerateCertificateHashEntries *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnumerateCertificateHashEntries(struct soap*, const char*, int, const struct __sai__EnumerateCertificateHashEntries *, const char*); +SOAP_FMAC3 struct __sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_get___sai__EnumerateCertificateHashEntries(struct soap*, struct __sai__EnumerateCertificateHashEntries *, const char*, const char*); +SOAP_FMAC3 struct __sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_in___sai__EnumerateCertificateHashEntries(struct soap*, const char*, struct __sai__EnumerateCertificateHashEntries *, const char*); +SOAP_FMAC5 struct __sai__EnumerateCertificateHashEntries * SOAP_FMAC6 soap_new___sai__EnumerateCertificateHashEntries(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnumerateCertificateHashEntries(struct soap*, struct __sai__EnumerateCertificateHashEntries*); +SOAP_FMAC3 struct __sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_instantiate___sai__EnumerateCertificateHashEntries(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnumerateCertificateHashEntries(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetProvisioningServerOTP +#define SOAP_TYPE___sai__GetProvisioningServerOTP (1421) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetProvisioningServerOTP(struct soap*, const struct __sai__GetProvisioningServerOTP *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetProvisioningServerOTP(struct soap*, struct __sai__GetProvisioningServerOTP *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetProvisioningServerOTP(struct soap*, const struct __sai__GetProvisioningServerOTP *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetProvisioningServerOTP(struct soap*, const char*, int, const struct __sai__GetProvisioningServerOTP *, const char*); +SOAP_FMAC3 struct __sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_get___sai__GetProvisioningServerOTP(struct soap*, struct __sai__GetProvisioningServerOTP *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_in___sai__GetProvisioningServerOTP(struct soap*, const char*, struct __sai__GetProvisioningServerOTP *, const char*); +SOAP_FMAC5 struct __sai__GetProvisioningServerOTP * SOAP_FMAC6 soap_new___sai__GetProvisioningServerOTP(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetProvisioningServerOTP(struct soap*, struct __sai__GetProvisioningServerOTP*); +SOAP_FMAC3 struct __sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_instantiate___sai__GetProvisioningServerOTP(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetProvisioningServerOTP(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetProvisioningServerOTP +#define SOAP_TYPE___sai__SetProvisioningServerOTP (1417) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetProvisioningServerOTP(struct soap*, const struct __sai__SetProvisioningServerOTP *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetProvisioningServerOTP(struct soap*, struct __sai__SetProvisioningServerOTP *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetProvisioningServerOTP(struct soap*, const struct __sai__SetProvisioningServerOTP *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetProvisioningServerOTP(struct soap*, const char*, int, const struct __sai__SetProvisioningServerOTP *, const char*); +SOAP_FMAC3 struct __sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_get___sai__SetProvisioningServerOTP(struct soap*, struct __sai__SetProvisioningServerOTP *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_in___sai__SetProvisioningServerOTP(struct soap*, const char*, struct __sai__SetProvisioningServerOTP *, const char*); +SOAP_FMAC5 struct __sai__SetProvisioningServerOTP * SOAP_FMAC6 soap_new___sai__SetProvisioningServerOTP(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetProvisioningServerOTP(struct soap*, struct __sai__SetProvisioningServerOTP*); +SOAP_FMAC3 struct __sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_instantiate___sai__SetProvisioningServerOTP(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetProvisioningServerOTP(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetMEBxPassword +#define SOAP_TYPE___sai__SetMEBxPassword (1413) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetMEBxPassword(struct soap*, const struct __sai__SetMEBxPassword *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetMEBxPassword(struct soap*, struct __sai__SetMEBxPassword *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetMEBxPassword(struct soap*, const struct __sai__SetMEBxPassword *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetMEBxPassword(struct soap*, const char*, int, const struct __sai__SetMEBxPassword *, const char*); +SOAP_FMAC3 struct __sai__SetMEBxPassword * SOAP_FMAC4 soap_get___sai__SetMEBxPassword(struct soap*, struct __sai__SetMEBxPassword *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetMEBxPassword * SOAP_FMAC4 soap_in___sai__SetMEBxPassword(struct soap*, const char*, struct __sai__SetMEBxPassword *, const char*); +SOAP_FMAC5 struct __sai__SetMEBxPassword * SOAP_FMAC6 soap_new___sai__SetMEBxPassword(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetMEBxPassword(struct soap*, struct __sai__SetMEBxPassword*); +SOAP_FMAC3 struct __sai__SetMEBxPassword * SOAP_FMAC4 soap_instantiate___sai__SetMEBxPassword(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetMEBxPassword(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__PartialUnprovision +#define SOAP_TYPE___sai__PartialUnprovision (1409) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__PartialUnprovision(struct soap*, const struct __sai__PartialUnprovision *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__PartialUnprovision(struct soap*, struct __sai__PartialUnprovision *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__PartialUnprovision(struct soap*, const struct __sai__PartialUnprovision *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__PartialUnprovision(struct soap*, const char*, int, const struct __sai__PartialUnprovision *, const char*); +SOAP_FMAC3 struct __sai__PartialUnprovision * SOAP_FMAC4 soap_get___sai__PartialUnprovision(struct soap*, struct __sai__PartialUnprovision *, const char*, const char*); +SOAP_FMAC3 struct __sai__PartialUnprovision * SOAP_FMAC4 soap_in___sai__PartialUnprovision(struct soap*, const char*, struct __sai__PartialUnprovision *, const char*); +SOAP_FMAC5 struct __sai__PartialUnprovision * SOAP_FMAC6 soap_new___sai__PartialUnprovision(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__PartialUnprovision(struct soap*, struct __sai__PartialUnprovision*); +SOAP_FMAC3 struct __sai__PartialUnprovision * SOAP_FMAC4 soap_instantiate___sai__PartialUnprovision(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__PartialUnprovision(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetTLSPSK +#define SOAP_TYPE___sai__SetTLSPSK (1405) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTLSPSK(struct soap*, const struct __sai__SetTLSPSK *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTLSPSK(struct soap*, struct __sai__SetTLSPSK *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTLSPSK(struct soap*, const struct __sai__SetTLSPSK *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTLSPSK(struct soap*, const char*, int, const struct __sai__SetTLSPSK *, const char*); +SOAP_FMAC3 struct __sai__SetTLSPSK * SOAP_FMAC4 soap_get___sai__SetTLSPSK(struct soap*, struct __sai__SetTLSPSK *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetTLSPSK * SOAP_FMAC4 soap_in___sai__SetTLSPSK(struct soap*, const char*, struct __sai__SetTLSPSK *, const char*); +SOAP_FMAC5 struct __sai__SetTLSPSK * SOAP_FMAC6 soap_new___sai__SetTLSPSK(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTLSPSK(struct soap*, struct __sai__SetTLSPSK*); +SOAP_FMAC3 struct __sai__SetTLSPSK * SOAP_FMAC4 soap_instantiate___sai__SetTLSPSK(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTLSPSK(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetPowerSavingOptions +#define SOAP_TYPE___sai__GetPowerSavingOptions (1401) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetPowerSavingOptions(struct soap*, const struct __sai__GetPowerSavingOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetPowerSavingOptions(struct soap*, struct __sai__GetPowerSavingOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetPowerSavingOptions(struct soap*, const struct __sai__GetPowerSavingOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetPowerSavingOptions(struct soap*, const char*, int, const struct __sai__GetPowerSavingOptions *, const char*); +SOAP_FMAC3 struct __sai__GetPowerSavingOptions * SOAP_FMAC4 soap_get___sai__GetPowerSavingOptions(struct soap*, struct __sai__GetPowerSavingOptions *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetPowerSavingOptions * SOAP_FMAC4 soap_in___sai__GetPowerSavingOptions(struct soap*, const char*, struct __sai__GetPowerSavingOptions *, const char*); +SOAP_FMAC5 struct __sai__GetPowerSavingOptions * SOAP_FMAC6 soap_new___sai__GetPowerSavingOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetPowerSavingOptions(struct soap*, struct __sai__GetPowerSavingOptions*); +SOAP_FMAC3 struct __sai__GetPowerSavingOptions * SOAP_FMAC4 soap_instantiate___sai__GetPowerSavingOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetPowerSavingOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetPowerSavingOptions +#define SOAP_TYPE___sai__SetPowerSavingOptions (1397) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetPowerSavingOptions(struct soap*, const struct __sai__SetPowerSavingOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetPowerSavingOptions(struct soap*, struct __sai__SetPowerSavingOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetPowerSavingOptions(struct soap*, const struct __sai__SetPowerSavingOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetPowerSavingOptions(struct soap*, const char*, int, const struct __sai__SetPowerSavingOptions *, const char*); +SOAP_FMAC3 struct __sai__SetPowerSavingOptions * SOAP_FMAC4 soap_get___sai__SetPowerSavingOptions(struct soap*, struct __sai__SetPowerSavingOptions *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetPowerSavingOptions * SOAP_FMAC4 soap_in___sai__SetPowerSavingOptions(struct soap*, const char*, struct __sai__SetPowerSavingOptions *, const char*); +SOAP_FMAC5 struct __sai__SetPowerSavingOptions * SOAP_FMAC6 soap_new___sai__SetPowerSavingOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetPowerSavingOptions(struct soap*, struct __sai__SetPowerSavingOptions*); +SOAP_FMAC3 struct __sai__SetPowerSavingOptions * SOAP_FMAC4 soap_instantiate___sai__SetPowerSavingOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetPowerSavingOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetPkiCapabilities +#define SOAP_TYPE___sai__GetPkiCapabilities (1393) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetPkiCapabilities(struct soap*, const struct __sai__GetPkiCapabilities *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetPkiCapabilities(struct soap*, struct __sai__GetPkiCapabilities *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetPkiCapabilities(struct soap*, const struct __sai__GetPkiCapabilities *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetPkiCapabilities(struct soap*, const char*, int, const struct __sai__GetPkiCapabilities *, const char*); +SOAP_FMAC3 struct __sai__GetPkiCapabilities * SOAP_FMAC4 soap_get___sai__GetPkiCapabilities(struct soap*, struct __sai__GetPkiCapabilities *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetPkiCapabilities * SOAP_FMAC4 soap_in___sai__GetPkiCapabilities(struct soap*, const char*, struct __sai__GetPkiCapabilities *, const char*); +SOAP_FMAC5 struct __sai__GetPkiCapabilities * SOAP_FMAC6 soap_new___sai__GetPkiCapabilities(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetPkiCapabilities(struct soap*, struct __sai__GetPkiCapabilities*); +SOAP_FMAC3 struct __sai__GetPkiCapabilities * SOAP_FMAC4 soap_instantiate___sai__GetPkiCapabilities(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetPkiCapabilities(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetServerCertificateReq +#define SOAP_TYPE___sai__GetServerCertificateReq (1389) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetServerCertificateReq(struct soap*, const struct __sai__GetServerCertificateReq *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetServerCertificateReq(struct soap*, struct __sai__GetServerCertificateReq *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetServerCertificateReq(struct soap*, const struct __sai__GetServerCertificateReq *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetServerCertificateReq(struct soap*, const char*, int, const struct __sai__GetServerCertificateReq *, const char*); +SOAP_FMAC3 struct __sai__GetServerCertificateReq * SOAP_FMAC4 soap_get___sai__GetServerCertificateReq(struct soap*, struct __sai__GetServerCertificateReq *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetServerCertificateReq * SOAP_FMAC4 soap_in___sai__GetServerCertificateReq(struct soap*, const char*, struct __sai__GetServerCertificateReq *, const char*); +SOAP_FMAC5 struct __sai__GetServerCertificateReq * SOAP_FMAC6 soap_new___sai__GetServerCertificateReq(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetServerCertificateReq(struct soap*, struct __sai__GetServerCertificateReq*); +SOAP_FMAC3 struct __sai__GetServerCertificateReq * SOAP_FMAC4 soap_instantiate___sai__GetServerCertificateReq(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetServerCertificateReq(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetCRL +#define SOAP_TYPE___sai__GetCRL (1385) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetCRL(struct soap*, const struct __sai__GetCRL *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetCRL(struct soap*, struct __sai__GetCRL *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetCRL(struct soap*, const struct __sai__GetCRL *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetCRL(struct soap*, const char*, int, const struct __sai__GetCRL *, const char*); +SOAP_FMAC3 struct __sai__GetCRL * SOAP_FMAC4 soap_get___sai__GetCRL(struct soap*, struct __sai__GetCRL *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetCRL * SOAP_FMAC4 soap_in___sai__GetCRL(struct soap*, const char*, struct __sai__GetCRL *, const char*); +SOAP_FMAC5 struct __sai__GetCRL * SOAP_FMAC6 soap_new___sai__GetCRL(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetCRL(struct soap*, struct __sai__GetCRL*); +SOAP_FMAC3 struct __sai__GetCRL * SOAP_FMAC4 soap_instantiate___sai__GetCRL(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetCRL(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetCRL +#define SOAP_TYPE___sai__SetCRL (1381) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetCRL(struct soap*, const struct __sai__SetCRL *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetCRL(struct soap*, struct __sai__SetCRL *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetCRL(struct soap*, const struct __sai__SetCRL *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetCRL(struct soap*, const char*, int, const struct __sai__SetCRL *, const char*); +SOAP_FMAC3 struct __sai__SetCRL * SOAP_FMAC4 soap_get___sai__SetCRL(struct soap*, struct __sai__SetCRL *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetCRL * SOAP_FMAC4 soap_in___sai__SetCRL(struct soap*, const char*, struct __sai__SetCRL *, const char*); +SOAP_FMAC5 struct __sai__SetCRL * SOAP_FMAC6 soap_new___sai__SetCRL(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetCRL(struct soap*, struct __sai__SetCRL*); +SOAP_FMAC3 struct __sai__SetCRL * SOAP_FMAC4 soap_instantiate___sai__SetCRL(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetCRL(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetTrustedFqdnCN +#define SOAP_TYPE___sai__GetTrustedFqdnCN (1377) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTrustedFqdnCN(struct soap*, const struct __sai__GetTrustedFqdnCN *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTrustedFqdnCN(struct soap*, struct __sai__GetTrustedFqdnCN *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTrustedFqdnCN(struct soap*, const struct __sai__GetTrustedFqdnCN *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTrustedFqdnCN(struct soap*, const char*, int, const struct __sai__GetTrustedFqdnCN *, const char*); +SOAP_FMAC3 struct __sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_get___sai__GetTrustedFqdnCN(struct soap*, struct __sai__GetTrustedFqdnCN *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_in___sai__GetTrustedFqdnCN(struct soap*, const char*, struct __sai__GetTrustedFqdnCN *, const char*); +SOAP_FMAC5 struct __sai__GetTrustedFqdnCN * SOAP_FMAC6 soap_new___sai__GetTrustedFqdnCN(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTrustedFqdnCN(struct soap*, struct __sai__GetTrustedFqdnCN*); +SOAP_FMAC3 struct __sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_instantiate___sai__GetTrustedFqdnCN(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTrustedFqdnCN(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetTrustedFqdnCN +#define SOAP_TYPE___sai__SetTrustedFqdnCN (1373) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTrustedFqdnCN(struct soap*, const struct __sai__SetTrustedFqdnCN *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTrustedFqdnCN(struct soap*, struct __sai__SetTrustedFqdnCN *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTrustedFqdnCN(struct soap*, const struct __sai__SetTrustedFqdnCN *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTrustedFqdnCN(struct soap*, const char*, int, const struct __sai__SetTrustedFqdnCN *, const char*); +SOAP_FMAC3 struct __sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_get___sai__SetTrustedFqdnCN(struct soap*, struct __sai__SetTrustedFqdnCN *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_in___sai__SetTrustedFqdnCN(struct soap*, const char*, struct __sai__SetTrustedFqdnCN *, const char*); +SOAP_FMAC5 struct __sai__SetTrustedFqdnCN * SOAP_FMAC6 soap_new___sai__SetTrustedFqdnCN(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTrustedFqdnCN(struct soap*, struct __sai__SetTrustedFqdnCN*); +SOAP_FMAC3 struct __sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_instantiate___sai__SetTrustedFqdnCN(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTrustedFqdnCN(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__EnumerateTrustedRootCertificates +#define SOAP_TYPE___sai__EnumerateTrustedRootCertificates (1369) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnumerateTrustedRootCertificates(struct soap*, const struct __sai__EnumerateTrustedRootCertificates *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnumerateTrustedRootCertificates(struct soap*, struct __sai__EnumerateTrustedRootCertificates *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnumerateTrustedRootCertificates(struct soap*, const struct __sai__EnumerateTrustedRootCertificates *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnumerateTrustedRootCertificates(struct soap*, const char*, int, const struct __sai__EnumerateTrustedRootCertificates *, const char*); +SOAP_FMAC3 struct __sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_get___sai__EnumerateTrustedRootCertificates(struct soap*, struct __sai__EnumerateTrustedRootCertificates *, const char*, const char*); +SOAP_FMAC3 struct __sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_in___sai__EnumerateTrustedRootCertificates(struct soap*, const char*, struct __sai__EnumerateTrustedRootCertificates *, const char*); +SOAP_FMAC5 struct __sai__EnumerateTrustedRootCertificates * SOAP_FMAC6 soap_new___sai__EnumerateTrustedRootCertificates(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnumerateTrustedRootCertificates(struct soap*, struct __sai__EnumerateTrustedRootCertificates*); +SOAP_FMAC3 struct __sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_instantiate___sai__EnumerateTrustedRootCertificates(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnumerateTrustedRootCertificates(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__DeleteTrustedRootCertificate +#define SOAP_TYPE___sai__DeleteTrustedRootCertificate (1365) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__DeleteTrustedRootCertificate(struct soap*, const struct __sai__DeleteTrustedRootCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__DeleteTrustedRootCertificate(struct soap*, struct __sai__DeleteTrustedRootCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__DeleteTrustedRootCertificate(struct soap*, const struct __sai__DeleteTrustedRootCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__DeleteTrustedRootCertificate(struct soap*, const char*, int, const struct __sai__DeleteTrustedRootCertificate *, const char*); +SOAP_FMAC3 struct __sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_get___sai__DeleteTrustedRootCertificate(struct soap*, struct __sai__DeleteTrustedRootCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_in___sai__DeleteTrustedRootCertificate(struct soap*, const char*, struct __sai__DeleteTrustedRootCertificate *, const char*); +SOAP_FMAC5 struct __sai__DeleteTrustedRootCertificate * SOAP_FMAC6 soap_new___sai__DeleteTrustedRootCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__DeleteTrustedRootCertificate(struct soap*, struct __sai__DeleteTrustedRootCertificate*); +SOAP_FMAC3 struct __sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_instantiate___sai__DeleteTrustedRootCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__DeleteTrustedRootCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetTrustedRootCertificate +#define SOAP_TYPE___sai__GetTrustedRootCertificate (1361) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTrustedRootCertificate(struct soap*, const struct __sai__GetTrustedRootCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTrustedRootCertificate(struct soap*, struct __sai__GetTrustedRootCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTrustedRootCertificate(struct soap*, const struct __sai__GetTrustedRootCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTrustedRootCertificate(struct soap*, const char*, int, const struct __sai__GetTrustedRootCertificate *, const char*); +SOAP_FMAC3 struct __sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_get___sai__GetTrustedRootCertificate(struct soap*, struct __sai__GetTrustedRootCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_in___sai__GetTrustedRootCertificate(struct soap*, const char*, struct __sai__GetTrustedRootCertificate *, const char*); +SOAP_FMAC5 struct __sai__GetTrustedRootCertificate * SOAP_FMAC6 soap_new___sai__GetTrustedRootCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTrustedRootCertificate(struct soap*, struct __sai__GetTrustedRootCertificate*); +SOAP_FMAC3 struct __sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_instantiate___sai__GetTrustedRootCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTrustedRootCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__AddTrustedRootCertificate +#define SOAP_TYPE___sai__AddTrustedRootCertificate (1357) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__AddTrustedRootCertificate(struct soap*, const struct __sai__AddTrustedRootCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__AddTrustedRootCertificate(struct soap*, struct __sai__AddTrustedRootCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__AddTrustedRootCertificate(struct soap*, const struct __sai__AddTrustedRootCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__AddTrustedRootCertificate(struct soap*, const char*, int, const struct __sai__AddTrustedRootCertificate *, const char*); +SOAP_FMAC3 struct __sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_get___sai__AddTrustedRootCertificate(struct soap*, struct __sai__AddTrustedRootCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_in___sai__AddTrustedRootCertificate(struct soap*, const char*, struct __sai__AddTrustedRootCertificate *, const char*); +SOAP_FMAC5 struct __sai__AddTrustedRootCertificate * SOAP_FMAC6 soap_new___sai__AddTrustedRootCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__AddTrustedRootCertificate(struct soap*, struct __sai__AddTrustedRootCertificate*); +SOAP_FMAC3 struct __sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_instantiate___sai__AddTrustedRootCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__AddTrustedRootCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetTlsOptions +#define SOAP_TYPE___sai__GetTlsOptions (1353) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTlsOptions(struct soap*, const struct __sai__GetTlsOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTlsOptions(struct soap*, struct __sai__GetTlsOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTlsOptions(struct soap*, const struct __sai__GetTlsOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTlsOptions(struct soap*, const char*, int, const struct __sai__GetTlsOptions *, const char*); +SOAP_FMAC3 struct __sai__GetTlsOptions * SOAP_FMAC4 soap_get___sai__GetTlsOptions(struct soap*, struct __sai__GetTlsOptions *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetTlsOptions * SOAP_FMAC4 soap_in___sai__GetTlsOptions(struct soap*, const char*, struct __sai__GetTlsOptions *, const char*); +SOAP_FMAC5 struct __sai__GetTlsOptions * SOAP_FMAC6 soap_new___sai__GetTlsOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTlsOptions(struct soap*, struct __sai__GetTlsOptions*); +SOAP_FMAC3 struct __sai__GetTlsOptions * SOAP_FMAC4 soap_instantiate___sai__GetTlsOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTlsOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetTlsOptions +#define SOAP_TYPE___sai__SetTlsOptions (1349) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTlsOptions(struct soap*, const struct __sai__SetTlsOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTlsOptions(struct soap*, struct __sai__SetTlsOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTlsOptions(struct soap*, const struct __sai__SetTlsOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTlsOptions(struct soap*, const char*, int, const struct __sai__SetTlsOptions *, const char*); +SOAP_FMAC3 struct __sai__SetTlsOptions * SOAP_FMAC4 soap_get___sai__SetTlsOptions(struct soap*, struct __sai__SetTlsOptions *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetTlsOptions * SOAP_FMAC4 soap_in___sai__SetTlsOptions(struct soap*, const char*, struct __sai__SetTlsOptions *, const char*); +SOAP_FMAC5 struct __sai__SetTlsOptions * SOAP_FMAC6 soap_new___sai__SetTlsOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTlsOptions(struct soap*, struct __sai__SetTlsOptions*); +SOAP_FMAC3 struct __sai__SetTlsOptions * SOAP_FMAC4 soap_instantiate___sai__SetTlsOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTlsOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetEnabledInterfaces +#define SOAP_TYPE___sai__GetEnabledInterfaces (1345) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetEnabledInterfaces(struct soap*, const struct __sai__GetEnabledInterfaces *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetEnabledInterfaces(struct soap*, struct __sai__GetEnabledInterfaces *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetEnabledInterfaces(struct soap*, const struct __sai__GetEnabledInterfaces *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetEnabledInterfaces(struct soap*, const char*, int, const struct __sai__GetEnabledInterfaces *, const char*); +SOAP_FMAC3 struct __sai__GetEnabledInterfaces * SOAP_FMAC4 soap_get___sai__GetEnabledInterfaces(struct soap*, struct __sai__GetEnabledInterfaces *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetEnabledInterfaces * SOAP_FMAC4 soap_in___sai__GetEnabledInterfaces(struct soap*, const char*, struct __sai__GetEnabledInterfaces *, const char*); +SOAP_FMAC5 struct __sai__GetEnabledInterfaces * SOAP_FMAC6 soap_new___sai__GetEnabledInterfaces(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetEnabledInterfaces(struct soap*, struct __sai__GetEnabledInterfaces*); +SOAP_FMAC3 struct __sai__GetEnabledInterfaces * SOAP_FMAC4 soap_instantiate___sai__GetEnabledInterfaces(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetEnabledInterfaces(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetEnabledInterfaces +#define SOAP_TYPE___sai__SetEnabledInterfaces (1341) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetEnabledInterfaces(struct soap*, const struct __sai__SetEnabledInterfaces *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetEnabledInterfaces(struct soap*, struct __sai__SetEnabledInterfaces *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetEnabledInterfaces(struct soap*, const struct __sai__SetEnabledInterfaces *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetEnabledInterfaces(struct soap*, const char*, int, const struct __sai__SetEnabledInterfaces *, const char*); +SOAP_FMAC3 struct __sai__SetEnabledInterfaces * SOAP_FMAC4 soap_get___sai__SetEnabledInterfaces(struct soap*, struct __sai__SetEnabledInterfaces *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetEnabledInterfaces * SOAP_FMAC4 soap_in___sai__SetEnabledInterfaces(struct soap*, const char*, struct __sai__SetEnabledInterfaces *, const char*); +SOAP_FMAC5 struct __sai__SetEnabledInterfaces * SOAP_FMAC6 soap_new___sai__SetEnabledInterfaces(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetEnabledInterfaces(struct soap*, struct __sai__SetEnabledInterfaces*); +SOAP_FMAC3 struct __sai__SetEnabledInterfaces * SOAP_FMAC4 soap_instantiate___sai__SetEnabledInterfaces(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetEnabledInterfaces(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetKerberosOptions +#define SOAP_TYPE___sai__GetKerberosOptions (1337) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetKerberosOptions(struct soap*, const struct __sai__GetKerberosOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetKerberosOptions(struct soap*, struct __sai__GetKerberosOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetKerberosOptions(struct soap*, const struct __sai__GetKerberosOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetKerberosOptions(struct soap*, const char*, int, const struct __sai__GetKerberosOptions *, const char*); +SOAP_FMAC3 struct __sai__GetKerberosOptions * SOAP_FMAC4 soap_get___sai__GetKerberosOptions(struct soap*, struct __sai__GetKerberosOptions *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetKerberosOptions * SOAP_FMAC4 soap_in___sai__GetKerberosOptions(struct soap*, const char*, struct __sai__GetKerberosOptions *, const char*); +SOAP_FMAC5 struct __sai__GetKerberosOptions * SOAP_FMAC6 soap_new___sai__GetKerberosOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetKerberosOptions(struct soap*, struct __sai__GetKerberosOptions*); +SOAP_FMAC3 struct __sai__GetKerberosOptions * SOAP_FMAC4 soap_instantiate___sai__GetKerberosOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetKerberosOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetKerberosOptions +#define SOAP_TYPE___sai__SetKerberosOptions (1333) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetKerberosOptions(struct soap*, const struct __sai__SetKerberosOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetKerberosOptions(struct soap*, struct __sai__SetKerberosOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetKerberosOptions(struct soap*, const struct __sai__SetKerberosOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetKerberosOptions(struct soap*, const char*, int, const struct __sai__SetKerberosOptions *, const char*); +SOAP_FMAC3 struct __sai__SetKerberosOptions * SOAP_FMAC4 soap_get___sai__SetKerberosOptions(struct soap*, struct __sai__SetKerberosOptions *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetKerberosOptions * SOAP_FMAC4 soap_in___sai__SetKerberosOptions(struct soap*, const char*, struct __sai__SetKerberosOptions *, const char*); +SOAP_FMAC5 struct __sai__SetKerberosOptions * SOAP_FMAC6 soap_new___sai__SetKerberosOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetKerberosOptions(struct soap*, struct __sai__SetKerberosOptions*); +SOAP_FMAC3 struct __sai__SetKerberosOptions * SOAP_FMAC4 soap_instantiate___sai__SetKerberosOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetKerberosOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetDigestRealm +#define SOAP_TYPE___sai__GetDigestRealm (1329) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetDigestRealm(struct soap*, const struct __sai__GetDigestRealm *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetDigestRealm(struct soap*, struct __sai__GetDigestRealm *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetDigestRealm(struct soap*, const struct __sai__GetDigestRealm *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetDigestRealm(struct soap*, const char*, int, const struct __sai__GetDigestRealm *, const char*); +SOAP_FMAC3 struct __sai__GetDigestRealm * SOAP_FMAC4 soap_get___sai__GetDigestRealm(struct soap*, struct __sai__GetDigestRealm *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetDigestRealm * SOAP_FMAC4 soap_in___sai__GetDigestRealm(struct soap*, const char*, struct __sai__GetDigestRealm *, const char*); +SOAP_FMAC5 struct __sai__GetDigestRealm * SOAP_FMAC6 soap_new___sai__GetDigestRealm(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetDigestRealm(struct soap*, struct __sai__GetDigestRealm*); +SOAP_FMAC3 struct __sai__GetDigestRealm * SOAP_FMAC4 soap_instantiate___sai__GetDigestRealm(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetDigestRealm(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetAdminAclEntryEx +#define SOAP_TYPE___sai__SetAdminAclEntryEx (1325) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetAdminAclEntryEx(struct soap*, const struct __sai__SetAdminAclEntryEx *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetAdminAclEntryEx(struct soap*, struct __sai__SetAdminAclEntryEx *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetAdminAclEntryEx(struct soap*, const struct __sai__SetAdminAclEntryEx *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetAdminAclEntryEx(struct soap*, const char*, int, const struct __sai__SetAdminAclEntryEx *, const char*); +SOAP_FMAC3 struct __sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_get___sai__SetAdminAclEntryEx(struct soap*, struct __sai__SetAdminAclEntryEx *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_in___sai__SetAdminAclEntryEx(struct soap*, const char*, struct __sai__SetAdminAclEntryEx *, const char*); +SOAP_FMAC5 struct __sai__SetAdminAclEntryEx * SOAP_FMAC6 soap_new___sai__SetAdminAclEntryEx(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetAdminAclEntryEx(struct soap*, struct __sai__SetAdminAclEntryEx*); +SOAP_FMAC3 struct __sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_instantiate___sai__SetAdminAclEntryEx(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetAdminAclEntryEx(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__UpdateUserAclEntryEx +#define SOAP_TYPE___sai__UpdateUserAclEntryEx (1321) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__UpdateUserAclEntryEx(struct soap*, const struct __sai__UpdateUserAclEntryEx *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__UpdateUserAclEntryEx(struct soap*, struct __sai__UpdateUserAclEntryEx *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__UpdateUserAclEntryEx(struct soap*, const struct __sai__UpdateUserAclEntryEx *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__UpdateUserAclEntryEx(struct soap*, const char*, int, const struct __sai__UpdateUserAclEntryEx *, const char*); +SOAP_FMAC3 struct __sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_get___sai__UpdateUserAclEntryEx(struct soap*, struct __sai__UpdateUserAclEntryEx *, const char*, const char*); +SOAP_FMAC3 struct __sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_in___sai__UpdateUserAclEntryEx(struct soap*, const char*, struct __sai__UpdateUserAclEntryEx *, const char*); +SOAP_FMAC5 struct __sai__UpdateUserAclEntryEx * SOAP_FMAC6 soap_new___sai__UpdateUserAclEntryEx(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__UpdateUserAclEntryEx(struct soap*, struct __sai__UpdateUserAclEntryEx*); +SOAP_FMAC3 struct __sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_instantiate___sai__UpdateUserAclEntryEx(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__UpdateUserAclEntryEx(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetUserAclEntryEx +#define SOAP_TYPE___sai__GetUserAclEntryEx (1317) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetUserAclEntryEx(struct soap*, const struct __sai__GetUserAclEntryEx *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetUserAclEntryEx(struct soap*, struct __sai__GetUserAclEntryEx *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetUserAclEntryEx(struct soap*, const struct __sai__GetUserAclEntryEx *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetUserAclEntryEx(struct soap*, const char*, int, const struct __sai__GetUserAclEntryEx *, const char*); +SOAP_FMAC3 struct __sai__GetUserAclEntryEx * SOAP_FMAC4 soap_get___sai__GetUserAclEntryEx(struct soap*, struct __sai__GetUserAclEntryEx *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetUserAclEntryEx * SOAP_FMAC4 soap_in___sai__GetUserAclEntryEx(struct soap*, const char*, struct __sai__GetUserAclEntryEx *, const char*); +SOAP_FMAC5 struct __sai__GetUserAclEntryEx * SOAP_FMAC6 soap_new___sai__GetUserAclEntryEx(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetUserAclEntryEx(struct soap*, struct __sai__GetUserAclEntryEx*); +SOAP_FMAC3 struct __sai__GetUserAclEntryEx * SOAP_FMAC4 soap_instantiate___sai__GetUserAclEntryEx(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetUserAclEntryEx(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__AddUserAclEntryEx +#define SOAP_TYPE___sai__AddUserAclEntryEx (1313) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__AddUserAclEntryEx(struct soap*, const struct __sai__AddUserAclEntryEx *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__AddUserAclEntryEx(struct soap*, struct __sai__AddUserAclEntryEx *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__AddUserAclEntryEx(struct soap*, const struct __sai__AddUserAclEntryEx *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__AddUserAclEntryEx(struct soap*, const char*, int, const struct __sai__AddUserAclEntryEx *, const char*); +SOAP_FMAC3 struct __sai__AddUserAclEntryEx * SOAP_FMAC4 soap_get___sai__AddUserAclEntryEx(struct soap*, struct __sai__AddUserAclEntryEx *, const char*, const char*); +SOAP_FMAC3 struct __sai__AddUserAclEntryEx * SOAP_FMAC4 soap_in___sai__AddUserAclEntryEx(struct soap*, const char*, struct __sai__AddUserAclEntryEx *, const char*); +SOAP_FMAC5 struct __sai__AddUserAclEntryEx * SOAP_FMAC6 soap_new___sai__AddUserAclEntryEx(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__AddUserAclEntryEx(struct soap*, struct __sai__AddUserAclEntryEx*); +SOAP_FMAC3 struct __sai__AddUserAclEntryEx * SOAP_FMAC4 soap_instantiate___sai__AddUserAclEntryEx(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__AddUserAclEntryEx(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetCoreVersion +#define SOAP_TYPE___sai__GetCoreVersion (1309) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetCoreVersion(struct soap*, const struct __sai__GetCoreVersion *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetCoreVersion(struct soap*, struct __sai__GetCoreVersion *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetCoreVersion(struct soap*, const struct __sai__GetCoreVersion *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetCoreVersion(struct soap*, const char*, int, const struct __sai__GetCoreVersion *, const char*); +SOAP_FMAC3 struct __sai__GetCoreVersion * SOAP_FMAC4 soap_get___sai__GetCoreVersion(struct soap*, struct __sai__GetCoreVersion *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetCoreVersion * SOAP_FMAC4 soap_in___sai__GetCoreVersion(struct soap*, const char*, struct __sai__GetCoreVersion *, const char*); +SOAP_FMAC5 struct __sai__GetCoreVersion * SOAP_FMAC6 soap_new___sai__GetCoreVersion(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetCoreVersion(struct soap*, struct __sai__GetCoreVersion*); +SOAP_FMAC3 struct __sai__GetCoreVersion * SOAP_FMAC4 soap_instantiate___sai__GetCoreVersion(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetCoreVersion(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__CommitChanges +#define SOAP_TYPE___sai__CommitChanges (1305) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CommitChanges(struct soap*, const struct __sai__CommitChanges *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CommitChanges(struct soap*, struct __sai__CommitChanges *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CommitChanges(struct soap*, const struct __sai__CommitChanges *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CommitChanges(struct soap*, const char*, int, const struct __sai__CommitChanges *, const char*); +SOAP_FMAC3 struct __sai__CommitChanges * SOAP_FMAC4 soap_get___sai__CommitChanges(struct soap*, struct __sai__CommitChanges *, const char*, const char*); +SOAP_FMAC3 struct __sai__CommitChanges * SOAP_FMAC4 soap_in___sai__CommitChanges(struct soap*, const char*, struct __sai__CommitChanges *, const char*); +SOAP_FMAC5 struct __sai__CommitChanges * SOAP_FMAC6 soap_new___sai__CommitChanges(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CommitChanges(struct soap*, struct __sai__CommitChanges*); +SOAP_FMAC3 struct __sai__CommitChanges * SOAP_FMAC4 soap_instantiate___sai__CommitChanges(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CommitChanges(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__Unprovision +#define SOAP_TYPE___sai__Unprovision (1301) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__Unprovision(struct soap*, const struct __sai__Unprovision *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__Unprovision(struct soap*, struct __sai__Unprovision *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__Unprovision(struct soap*, const struct __sai__Unprovision *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__Unprovision(struct soap*, const char*, int, const struct __sai__Unprovision *, const char*); +SOAP_FMAC3 struct __sai__Unprovision * SOAP_FMAC4 soap_get___sai__Unprovision(struct soap*, struct __sai__Unprovision *, const char*, const char*); +SOAP_FMAC3 struct __sai__Unprovision * SOAP_FMAC4 soap_in___sai__Unprovision(struct soap*, const char*, struct __sai__Unprovision *, const char*); +SOAP_FMAC5 struct __sai__Unprovision * SOAP_FMAC6 soap_new___sai__Unprovision(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__Unprovision(struct soap*, struct __sai__Unprovision*); +SOAP_FMAC3 struct __sai__Unprovision * SOAP_FMAC4 soap_instantiate___sai__Unprovision(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__Unprovision(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetProvisioningMode +#define SOAP_TYPE___sai__SetProvisioningMode (1297) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetProvisioningMode(struct soap*, const struct __sai__SetProvisioningMode *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetProvisioningMode(struct soap*, struct __sai__SetProvisioningMode *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetProvisioningMode(struct soap*, const struct __sai__SetProvisioningMode *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetProvisioningMode(struct soap*, const char*, int, const struct __sai__SetProvisioningMode *, const char*); +SOAP_FMAC3 struct __sai__SetProvisioningMode * SOAP_FMAC4 soap_get___sai__SetProvisioningMode(struct soap*, struct __sai__SetProvisioningMode *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetProvisioningMode * SOAP_FMAC4 soap_in___sai__SetProvisioningMode(struct soap*, const char*, struct __sai__SetProvisioningMode *, const char*); +SOAP_FMAC5 struct __sai__SetProvisioningMode * SOAP_FMAC6 soap_new___sai__SetProvisioningMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetProvisioningMode(struct soap*, struct __sai__SetProvisioningMode*); +SOAP_FMAC3 struct __sai__SetProvisioningMode * SOAP_FMAC4 soap_instantiate___sai__SetProvisioningMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetProvisioningMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetProvisioningMode +#define SOAP_TYPE___sai__GetProvisioningMode (1293) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetProvisioningMode(struct soap*, const struct __sai__GetProvisioningMode *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetProvisioningMode(struct soap*, struct __sai__GetProvisioningMode *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetProvisioningMode(struct soap*, const struct __sai__GetProvisioningMode *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetProvisioningMode(struct soap*, const char*, int, const struct __sai__GetProvisioningMode *, const char*); +SOAP_FMAC3 struct __sai__GetProvisioningMode * SOAP_FMAC4 soap_get___sai__GetProvisioningMode(struct soap*, struct __sai__GetProvisioningMode *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetProvisioningMode * SOAP_FMAC4 soap_in___sai__GetProvisioningMode(struct soap*, const char*, struct __sai__GetProvisioningMode *, const char*); +SOAP_FMAC5 struct __sai__GetProvisioningMode * SOAP_FMAC6 soap_new___sai__GetProvisioningMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetProvisioningMode(struct soap*, struct __sai__GetProvisioningMode*); +SOAP_FMAC3 struct __sai__GetProvisioningMode * SOAP_FMAC4 soap_instantiate___sai__GetProvisioningMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetProvisioningMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__UpdateCoreFromUrl +#define SOAP_TYPE___sai__UpdateCoreFromUrl (1289) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__UpdateCoreFromUrl(struct soap*, const struct __sai__UpdateCoreFromUrl *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__UpdateCoreFromUrl(struct soap*, struct __sai__UpdateCoreFromUrl *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__UpdateCoreFromUrl(struct soap*, const struct __sai__UpdateCoreFromUrl *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__UpdateCoreFromUrl(struct soap*, const char*, int, const struct __sai__UpdateCoreFromUrl *, const char*); +SOAP_FMAC3 struct __sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_get___sai__UpdateCoreFromUrl(struct soap*, struct __sai__UpdateCoreFromUrl *, const char*, const char*); +SOAP_FMAC3 struct __sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_in___sai__UpdateCoreFromUrl(struct soap*, const char*, struct __sai__UpdateCoreFromUrl *, const char*); +SOAP_FMAC5 struct __sai__UpdateCoreFromUrl * SOAP_FMAC6 soap_new___sai__UpdateCoreFromUrl(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__UpdateCoreFromUrl(struct soap*, struct __sai__UpdateCoreFromUrl*); +SOAP_FMAC3 struct __sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_instantiate___sai__UpdateCoreFromUrl(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__UpdateCoreFromUrl(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetTLSCertificate +#define SOAP_TYPE___sai__GetTLSCertificate (1285) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTLSCertificate(struct soap*, const struct __sai__GetTLSCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTLSCertificate(struct soap*, struct __sai__GetTLSCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTLSCertificate(struct soap*, const struct __sai__GetTLSCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTLSCertificate(struct soap*, const char*, int, const struct __sai__GetTLSCertificate *, const char*); +SOAP_FMAC3 struct __sai__GetTLSCertificate * SOAP_FMAC4 soap_get___sai__GetTLSCertificate(struct soap*, struct __sai__GetTLSCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetTLSCertificate * SOAP_FMAC4 soap_in___sai__GetTLSCertificate(struct soap*, const char*, struct __sai__GetTLSCertificate *, const char*); +SOAP_FMAC5 struct __sai__GetTLSCertificate * SOAP_FMAC6 soap_new___sai__GetTLSCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTLSCertificate(struct soap*, struct __sai__GetTLSCertificate*); +SOAP_FMAC3 struct __sai__GetTLSCertificate * SOAP_FMAC4 soap_instantiate___sai__GetTLSCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTLSCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetTLSCertificate +#define SOAP_TYPE___sai__SetTLSCertificate (1281) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTLSCertificate(struct soap*, const struct __sai__SetTLSCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTLSCertificate(struct soap*, struct __sai__SetTLSCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTLSCertificate(struct soap*, const struct __sai__SetTLSCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTLSCertificate(struct soap*, const char*, int, const struct __sai__SetTLSCertificate *, const char*); +SOAP_FMAC3 struct __sai__SetTLSCertificate * SOAP_FMAC4 soap_get___sai__SetTLSCertificate(struct soap*, struct __sai__SetTLSCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetTLSCertificate * SOAP_FMAC4 soap_in___sai__SetTLSCertificate(struct soap*, const char*, struct __sai__SetTLSCertificate *, const char*); +SOAP_FMAC5 struct __sai__SetTLSCertificate * SOAP_FMAC6 soap_new___sai__SetTLSCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTLSCertificate(struct soap*, struct __sai__SetTLSCertificate*); +SOAP_FMAC3 struct __sai__SetTLSCertificate * SOAP_FMAC4 soap_instantiate___sai__SetTLSCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTLSCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetTLSKeyAndCertificate +#define SOAP_TYPE___sai__SetTLSKeyAndCertificate (1277) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTLSKeyAndCertificate(struct soap*, const struct __sai__SetTLSKeyAndCertificate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTLSKeyAndCertificate(struct soap*, struct __sai__SetTLSKeyAndCertificate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTLSKeyAndCertificate(struct soap*, const struct __sai__SetTLSKeyAndCertificate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTLSKeyAndCertificate(struct soap*, const char*, int, const struct __sai__SetTLSKeyAndCertificate *, const char*); +SOAP_FMAC3 struct __sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_get___sai__SetTLSKeyAndCertificate(struct soap*, struct __sai__SetTLSKeyAndCertificate *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_in___sai__SetTLSKeyAndCertificate(struct soap*, const char*, struct __sai__SetTLSKeyAndCertificate *, const char*); +SOAP_FMAC5 struct __sai__SetTLSKeyAndCertificate * SOAP_FMAC6 soap_new___sai__SetTLSKeyAndCertificate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTLSKeyAndCertificate(struct soap*, struct __sai__SetTLSKeyAndCertificate*); +SOAP_FMAC3 struct __sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_instantiate___sai__SetTLSKeyAndCertificate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTLSKeyAndCertificate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetRngKey +#define SOAP_TYPE___sai__SetRngKey (1273) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetRngKey(struct soap*, const struct __sai__SetRngKey *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetRngKey(struct soap*, struct __sai__SetRngKey *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetRngKey(struct soap*, const struct __sai__SetRngKey *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetRngKey(struct soap*, const char*, int, const struct __sai__SetRngKey *, const char*); +SOAP_FMAC3 struct __sai__SetRngKey * SOAP_FMAC4 soap_get___sai__SetRngKey(struct soap*, struct __sai__SetRngKey *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetRngKey * SOAP_FMAC4 soap_in___sai__SetRngKey(struct soap*, const char*, struct __sai__SetRngKey *, const char*); +SOAP_FMAC5 struct __sai__SetRngKey * SOAP_FMAC6 soap_new___sai__SetRngKey(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetRngKey(struct soap*, struct __sai__SetRngKey*); +SOAP_FMAC3 struct __sai__SetRngKey * SOAP_FMAC4 soap_instantiate___sai__SetRngKey(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetRngKey(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetTlsEnabled +#define SOAP_TYPE___sai__SetTlsEnabled (1269) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTlsEnabled(struct soap*, const struct __sai__SetTlsEnabled *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTlsEnabled(struct soap*, struct __sai__SetTlsEnabled *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTlsEnabled(struct soap*, const struct __sai__SetTlsEnabled *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTlsEnabled(struct soap*, const char*, int, const struct __sai__SetTlsEnabled *, const char*); +SOAP_FMAC3 struct __sai__SetTlsEnabled * SOAP_FMAC4 soap_get___sai__SetTlsEnabled(struct soap*, struct __sai__SetTlsEnabled *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetTlsEnabled * SOAP_FMAC4 soap_in___sai__SetTlsEnabled(struct soap*, const char*, struct __sai__SetTlsEnabled *, const char*); +SOAP_FMAC5 struct __sai__SetTlsEnabled * SOAP_FMAC6 soap_new___sai__SetTlsEnabled(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTlsEnabled(struct soap*, struct __sai__SetTlsEnabled*); +SOAP_FMAC3 struct __sai__SetTlsEnabled * SOAP_FMAC4 soap_instantiate___sai__SetTlsEnabled(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTlsEnabled(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__RemoveUserAclEntry +#define SOAP_TYPE___sai__RemoveUserAclEntry (1265) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__RemoveUserAclEntry(struct soap*, const struct __sai__RemoveUserAclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__RemoveUserAclEntry(struct soap*, struct __sai__RemoveUserAclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__RemoveUserAclEntry(struct soap*, const struct __sai__RemoveUserAclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__RemoveUserAclEntry(struct soap*, const char*, int, const struct __sai__RemoveUserAclEntry *, const char*); +SOAP_FMAC3 struct __sai__RemoveUserAclEntry * SOAP_FMAC4 soap_get___sai__RemoveUserAclEntry(struct soap*, struct __sai__RemoveUserAclEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__RemoveUserAclEntry * SOAP_FMAC4 soap_in___sai__RemoveUserAclEntry(struct soap*, const char*, struct __sai__RemoveUserAclEntry *, const char*); +SOAP_FMAC5 struct __sai__RemoveUserAclEntry * SOAP_FMAC6 soap_new___sai__RemoveUserAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__RemoveUserAclEntry(struct soap*, struct __sai__RemoveUserAclEntry*); +SOAP_FMAC3 struct __sai__RemoveUserAclEntry * SOAP_FMAC4 soap_instantiate___sai__RemoveUserAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__RemoveUserAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__UpdateUserAclEntry +#define SOAP_TYPE___sai__UpdateUserAclEntry (1261) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__UpdateUserAclEntry(struct soap*, const struct __sai__UpdateUserAclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__UpdateUserAclEntry(struct soap*, struct __sai__UpdateUserAclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__UpdateUserAclEntry(struct soap*, const struct __sai__UpdateUserAclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__UpdateUserAclEntry(struct soap*, const char*, int, const struct __sai__UpdateUserAclEntry *, const char*); +SOAP_FMAC3 struct __sai__UpdateUserAclEntry * SOAP_FMAC4 soap_get___sai__UpdateUserAclEntry(struct soap*, struct __sai__UpdateUserAclEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__UpdateUserAclEntry * SOAP_FMAC4 soap_in___sai__UpdateUserAclEntry(struct soap*, const char*, struct __sai__UpdateUserAclEntry *, const char*); +SOAP_FMAC5 struct __sai__UpdateUserAclEntry * SOAP_FMAC6 soap_new___sai__UpdateUserAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__UpdateUserAclEntry(struct soap*, struct __sai__UpdateUserAclEntry*); +SOAP_FMAC3 struct __sai__UpdateUserAclEntry * SOAP_FMAC4 soap_instantiate___sai__UpdateUserAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__UpdateUserAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetUserAclEntry +#define SOAP_TYPE___sai__GetUserAclEntry (1257) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetUserAclEntry(struct soap*, const struct __sai__GetUserAclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetUserAclEntry(struct soap*, struct __sai__GetUserAclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetUserAclEntry(struct soap*, const struct __sai__GetUserAclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetUserAclEntry(struct soap*, const char*, int, const struct __sai__GetUserAclEntry *, const char*); +SOAP_FMAC3 struct __sai__GetUserAclEntry * SOAP_FMAC4 soap_get___sai__GetUserAclEntry(struct soap*, struct __sai__GetUserAclEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetUserAclEntry * SOAP_FMAC4 soap_in___sai__GetUserAclEntry(struct soap*, const char*, struct __sai__GetUserAclEntry *, const char*); +SOAP_FMAC5 struct __sai__GetUserAclEntry * SOAP_FMAC6 soap_new___sai__GetUserAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetUserAclEntry(struct soap*, struct __sai__GetUserAclEntry*); +SOAP_FMAC3 struct __sai__GetUserAclEntry * SOAP_FMAC4 soap_instantiate___sai__GetUserAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetUserAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__EnumerateUserAclEntries +#define SOAP_TYPE___sai__EnumerateUserAclEntries (1253) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnumerateUserAclEntries(struct soap*, const struct __sai__EnumerateUserAclEntries *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnumerateUserAclEntries(struct soap*, struct __sai__EnumerateUserAclEntries *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnumerateUserAclEntries(struct soap*, const struct __sai__EnumerateUserAclEntries *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnumerateUserAclEntries(struct soap*, const char*, int, const struct __sai__EnumerateUserAclEntries *, const char*); +SOAP_FMAC3 struct __sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_get___sai__EnumerateUserAclEntries(struct soap*, struct __sai__EnumerateUserAclEntries *, const char*, const char*); +SOAP_FMAC3 struct __sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_in___sai__EnumerateUserAclEntries(struct soap*, const char*, struct __sai__EnumerateUserAclEntries *, const char*); +SOAP_FMAC5 struct __sai__EnumerateUserAclEntries * SOAP_FMAC6 soap_new___sai__EnumerateUserAclEntries(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnumerateUserAclEntries(struct soap*, struct __sai__EnumerateUserAclEntries*); +SOAP_FMAC3 struct __sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_instantiate___sai__EnumerateUserAclEntries(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnumerateUserAclEntries(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__AddUserAclEntry +#define SOAP_TYPE___sai__AddUserAclEntry (1249) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__AddUserAclEntry(struct soap*, const struct __sai__AddUserAclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__AddUserAclEntry(struct soap*, struct __sai__AddUserAclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__AddUserAclEntry(struct soap*, const struct __sai__AddUserAclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__AddUserAclEntry(struct soap*, const char*, int, const struct __sai__AddUserAclEntry *, const char*); +SOAP_FMAC3 struct __sai__AddUserAclEntry * SOAP_FMAC4 soap_get___sai__AddUserAclEntry(struct soap*, struct __sai__AddUserAclEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__AddUserAclEntry * SOAP_FMAC4 soap_in___sai__AddUserAclEntry(struct soap*, const char*, struct __sai__AddUserAclEntry *, const char*); +SOAP_FMAC5 struct __sai__AddUserAclEntry * SOAP_FMAC6 soap_new___sai__AddUserAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__AddUserAclEntry(struct soap*, struct __sai__AddUserAclEntry*); +SOAP_FMAC3 struct __sai__AddUserAclEntry * SOAP_FMAC4 soap_instantiate___sai__AddUserAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__AddUserAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__SetAdminAclEntry +#define SOAP_TYPE___sai__SetAdminAclEntry (1245) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetAdminAclEntry(struct soap*, const struct __sai__SetAdminAclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetAdminAclEntry(struct soap*, struct __sai__SetAdminAclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetAdminAclEntry(struct soap*, const struct __sai__SetAdminAclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetAdminAclEntry(struct soap*, const char*, int, const struct __sai__SetAdminAclEntry *, const char*); +SOAP_FMAC3 struct __sai__SetAdminAclEntry * SOAP_FMAC4 soap_get___sai__SetAdminAclEntry(struct soap*, struct __sai__SetAdminAclEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__SetAdminAclEntry * SOAP_FMAC4 soap_in___sai__SetAdminAclEntry(struct soap*, const char*, struct __sai__SetAdminAclEntry *, const char*); +SOAP_FMAC5 struct __sai__SetAdminAclEntry * SOAP_FMAC6 soap_new___sai__SetAdminAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetAdminAclEntry(struct soap*, struct __sai__SetAdminAclEntry*); +SOAP_FMAC3 struct __sai__SetAdminAclEntry * SOAP_FMAC4 soap_instantiate___sai__SetAdminAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetAdminAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__GetAdminAclEntry +#define SOAP_TYPE___sai__GetAdminAclEntry (1241) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetAdminAclEntry(struct soap*, const struct __sai__GetAdminAclEntry *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetAdminAclEntry(struct soap*, struct __sai__GetAdminAclEntry *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetAdminAclEntry(struct soap*, const struct __sai__GetAdminAclEntry *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetAdminAclEntry(struct soap*, const char*, int, const struct __sai__GetAdminAclEntry *, const char*); +SOAP_FMAC3 struct __sai__GetAdminAclEntry * SOAP_FMAC4 soap_get___sai__GetAdminAclEntry(struct soap*, struct __sai__GetAdminAclEntry *, const char*, const char*); +SOAP_FMAC3 struct __sai__GetAdminAclEntry * SOAP_FMAC4 soap_in___sai__GetAdminAclEntry(struct soap*, const char*, struct __sai__GetAdminAclEntry *, const char*); +SOAP_FMAC5 struct __sai__GetAdminAclEntry * SOAP_FMAC6 soap_new___sai__GetAdminAclEntry(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetAdminAclEntry(struct soap*, struct __sai__GetAdminAclEntry*); +SOAP_FMAC3 struct __sai__GetAdminAclEntry * SOAP_FMAC4 soap_instantiate___sai__GetAdminAclEntry(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetAdminAclEntry(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___sai__ResetFlashWearOutProtection +#define SOAP_TYPE___sai__ResetFlashWearOutProtection (1237) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__ResetFlashWearOutProtection(struct soap*, const struct __sai__ResetFlashWearOutProtection *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__ResetFlashWearOutProtection(struct soap*, struct __sai__ResetFlashWearOutProtection *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__ResetFlashWearOutProtection(struct soap*, const struct __sai__ResetFlashWearOutProtection *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__ResetFlashWearOutProtection(struct soap*, const char*, int, const struct __sai__ResetFlashWearOutProtection *, const char*); +SOAP_FMAC3 struct __sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_get___sai__ResetFlashWearOutProtection(struct soap*, struct __sai__ResetFlashWearOutProtection *, const char*, const char*); +SOAP_FMAC3 struct __sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_in___sai__ResetFlashWearOutProtection(struct soap*, const char*, struct __sai__ResetFlashWearOutProtection *, const char*); +SOAP_FMAC5 struct __sai__ResetFlashWearOutProtection * SOAP_FMAC6 soap_new___sai__ResetFlashWearOutProtection(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__ResetFlashWearOutProtection(struct soap*, struct __sai__ResetFlashWearOutProtection*); +SOAP_FMAC3 struct __sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_instantiate___sai__ResetFlashWearOutProtection(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__ResetFlashWearOutProtection(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___rci__GetSystemPowerState +#define SOAP_TYPE___rci__GetSystemPowerState (1233) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___rci__GetSystemPowerState(struct soap*, const struct __rci__GetSystemPowerState *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___rci__GetSystemPowerState(struct soap*, struct __rci__GetSystemPowerState *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___rci__GetSystemPowerState(struct soap*, const struct __rci__GetSystemPowerState *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___rci__GetSystemPowerState(struct soap*, const char*, int, const struct __rci__GetSystemPowerState *, const char*); +SOAP_FMAC3 struct __rci__GetSystemPowerState * SOAP_FMAC4 soap_get___rci__GetSystemPowerState(struct soap*, struct __rci__GetSystemPowerState *, const char*, const char*); +SOAP_FMAC3 struct __rci__GetSystemPowerState * SOAP_FMAC4 soap_in___rci__GetSystemPowerState(struct soap*, const char*, struct __rci__GetSystemPowerState *, const char*); +SOAP_FMAC5 struct __rci__GetSystemPowerState * SOAP_FMAC6 soap_new___rci__GetSystemPowerState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___rci__GetSystemPowerState(struct soap*, struct __rci__GetSystemPowerState*); +SOAP_FMAC3 struct __rci__GetSystemPowerState * SOAP_FMAC4 soap_instantiate___rci__GetSystemPowerState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___rci__GetSystemPowerState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___rci__RemoteControl +#define SOAP_TYPE___rci__RemoteControl (1229) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___rci__RemoteControl(struct soap*, const struct __rci__RemoteControl *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___rci__RemoteControl(struct soap*, struct __rci__RemoteControl *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___rci__RemoteControl(struct soap*, const struct __rci__RemoteControl *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___rci__RemoteControl(struct soap*, const char*, int, const struct __rci__RemoteControl *, const char*); +SOAP_FMAC3 struct __rci__RemoteControl * SOAP_FMAC4 soap_get___rci__RemoteControl(struct soap*, struct __rci__RemoteControl *, const char*, const char*); +SOAP_FMAC3 struct __rci__RemoteControl * SOAP_FMAC4 soap_in___rci__RemoteControl(struct soap*, const char*, struct __rci__RemoteControl *, const char*); +SOAP_FMAC5 struct __rci__RemoteControl * SOAP_FMAC6 soap_new___rci__RemoteControl(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___rci__RemoteControl(struct soap*, struct __rci__RemoteControl*); +SOAP_FMAC3 struct __rci__RemoteControl * SOAP_FMAC4 soap_instantiate___rci__RemoteControl(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___rci__RemoteControl(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___rci__GetRemoteControlCapabilities +#define SOAP_TYPE___rci__GetRemoteControlCapabilities (1225) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___rci__GetRemoteControlCapabilities(struct soap*, const struct __rci__GetRemoteControlCapabilities *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___rci__GetRemoteControlCapabilities(struct soap*, struct __rci__GetRemoteControlCapabilities *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___rci__GetRemoteControlCapabilities(struct soap*, const struct __rci__GetRemoteControlCapabilities *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___rci__GetRemoteControlCapabilities(struct soap*, const char*, int, const struct __rci__GetRemoteControlCapabilities *, const char*); +SOAP_FMAC3 struct __rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_get___rci__GetRemoteControlCapabilities(struct soap*, struct __rci__GetRemoteControlCapabilities *, const char*, const char*); +SOAP_FMAC3 struct __rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_in___rci__GetRemoteControlCapabilities(struct soap*, const char*, struct __rci__GetRemoteControlCapabilities *, const char*); +SOAP_FMAC5 struct __rci__GetRemoteControlCapabilities * SOAP_FMAC6 soap_new___rci__GetRemoteControlCapabilities(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___rci__GetRemoteControlCapabilities(struct soap*, struct __rci__GetRemoteControlCapabilities*); +SOAP_FMAC3 struct __rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_instantiate___rci__GetRemoteControlCapabilities(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___rci__GetRemoteControlCapabilities(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__Get8021XPxeTimeout +#define SOAP_TYPE___net__Get8021XPxeTimeout (1221) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Get8021XPxeTimeout(struct soap*, const struct __net__Get8021XPxeTimeout *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Get8021XPxeTimeout(struct soap*, struct __net__Get8021XPxeTimeout *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Get8021XPxeTimeout(struct soap*, const struct __net__Get8021XPxeTimeout *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Get8021XPxeTimeout(struct soap*, const char*, int, const struct __net__Get8021XPxeTimeout *, const char*); +SOAP_FMAC3 struct __net__Get8021XPxeTimeout * SOAP_FMAC4 soap_get___net__Get8021XPxeTimeout(struct soap*, struct __net__Get8021XPxeTimeout *, const char*, const char*); +SOAP_FMAC3 struct __net__Get8021XPxeTimeout * SOAP_FMAC4 soap_in___net__Get8021XPxeTimeout(struct soap*, const char*, struct __net__Get8021XPxeTimeout *, const char*); +SOAP_FMAC5 struct __net__Get8021XPxeTimeout * SOAP_FMAC6 soap_new___net__Get8021XPxeTimeout(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Get8021XPxeTimeout(struct soap*, struct __net__Get8021XPxeTimeout*); +SOAP_FMAC3 struct __net__Get8021XPxeTimeout * SOAP_FMAC4 soap_instantiate___net__Get8021XPxeTimeout(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Get8021XPxeTimeout(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__Set8021XPxeTimeout +#define SOAP_TYPE___net__Set8021XPxeTimeout (1217) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Set8021XPxeTimeout(struct soap*, const struct __net__Set8021XPxeTimeout *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Set8021XPxeTimeout(struct soap*, struct __net__Set8021XPxeTimeout *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Set8021XPxeTimeout(struct soap*, const struct __net__Set8021XPxeTimeout *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Set8021XPxeTimeout(struct soap*, const char*, int, const struct __net__Set8021XPxeTimeout *, const char*); +SOAP_FMAC3 struct __net__Set8021XPxeTimeout * SOAP_FMAC4 soap_get___net__Set8021XPxeTimeout(struct soap*, struct __net__Set8021XPxeTimeout *, const char*, const char*); +SOAP_FMAC3 struct __net__Set8021XPxeTimeout * SOAP_FMAC4 soap_in___net__Set8021XPxeTimeout(struct soap*, const char*, struct __net__Set8021XPxeTimeout *, const char*); +SOAP_FMAC5 struct __net__Set8021XPxeTimeout * SOAP_FMAC6 soap_new___net__Set8021XPxeTimeout(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Set8021XPxeTimeout(struct soap*, struct __net__Set8021XPxeTimeout*); +SOAP_FMAC3 struct __net__Set8021XPxeTimeout * SOAP_FMAC4 soap_instantiate___net__Set8021XPxeTimeout(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Set8021XPxeTimeout(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__Get8021XActiveS0 +#define SOAP_TYPE___net__Get8021XActiveS0 (1213) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Get8021XActiveS0(struct soap*, const struct __net__Get8021XActiveS0 *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Get8021XActiveS0(struct soap*, struct __net__Get8021XActiveS0 *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Get8021XActiveS0(struct soap*, const struct __net__Get8021XActiveS0 *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Get8021XActiveS0(struct soap*, const char*, int, const struct __net__Get8021XActiveS0 *, const char*); +SOAP_FMAC3 struct __net__Get8021XActiveS0 * SOAP_FMAC4 soap_get___net__Get8021XActiveS0(struct soap*, struct __net__Get8021XActiveS0 *, const char*, const char*); +SOAP_FMAC3 struct __net__Get8021XActiveS0 * SOAP_FMAC4 soap_in___net__Get8021XActiveS0(struct soap*, const char*, struct __net__Get8021XActiveS0 *, const char*); +SOAP_FMAC5 struct __net__Get8021XActiveS0 * SOAP_FMAC6 soap_new___net__Get8021XActiveS0(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Get8021XActiveS0(struct soap*, struct __net__Get8021XActiveS0*); +SOAP_FMAC3 struct __net__Get8021XActiveS0 * SOAP_FMAC4 soap_instantiate___net__Get8021XActiveS0(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Get8021XActiveS0(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__Set8021XActiveS0 +#define SOAP_TYPE___net__Set8021XActiveS0 (1209) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Set8021XActiveS0(struct soap*, const struct __net__Set8021XActiveS0 *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Set8021XActiveS0(struct soap*, struct __net__Set8021XActiveS0 *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Set8021XActiveS0(struct soap*, const struct __net__Set8021XActiveS0 *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Set8021XActiveS0(struct soap*, const char*, int, const struct __net__Set8021XActiveS0 *, const char*); +SOAP_FMAC3 struct __net__Set8021XActiveS0 * SOAP_FMAC4 soap_get___net__Set8021XActiveS0(struct soap*, struct __net__Set8021XActiveS0 *, const char*, const char*); +SOAP_FMAC3 struct __net__Set8021XActiveS0 * SOAP_FMAC4 soap_in___net__Set8021XActiveS0(struct soap*, const char*, struct __net__Set8021XActiveS0 *, const char*); +SOAP_FMAC5 struct __net__Set8021XActiveS0 * SOAP_FMAC6 soap_new___net__Set8021XActiveS0(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Set8021XActiveS0(struct soap*, struct __net__Set8021XActiveS0*); +SOAP_FMAC3 struct __net__Set8021XActiveS0 * SOAP_FMAC4 soap_instantiate___net__Set8021XActiveS0(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Set8021XActiveS0(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__Get8021XWiredProfile +#define SOAP_TYPE___net__Get8021XWiredProfile (1205) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Get8021XWiredProfile(struct soap*, const struct __net__Get8021XWiredProfile *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Get8021XWiredProfile(struct soap*, struct __net__Get8021XWiredProfile *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Get8021XWiredProfile(struct soap*, const struct __net__Get8021XWiredProfile *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Get8021XWiredProfile(struct soap*, const char*, int, const struct __net__Get8021XWiredProfile *, const char*); +SOAP_FMAC3 struct __net__Get8021XWiredProfile * SOAP_FMAC4 soap_get___net__Get8021XWiredProfile(struct soap*, struct __net__Get8021XWiredProfile *, const char*, const char*); +SOAP_FMAC3 struct __net__Get8021XWiredProfile * SOAP_FMAC4 soap_in___net__Get8021XWiredProfile(struct soap*, const char*, struct __net__Get8021XWiredProfile *, const char*); +SOAP_FMAC5 struct __net__Get8021XWiredProfile * SOAP_FMAC6 soap_new___net__Get8021XWiredProfile(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Get8021XWiredProfile(struct soap*, struct __net__Get8021XWiredProfile*); +SOAP_FMAC3 struct __net__Get8021XWiredProfile * SOAP_FMAC4 soap_instantiate___net__Get8021XWiredProfile(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Get8021XWiredProfile(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__Set8021XWiredProfile +#define SOAP_TYPE___net__Set8021XWiredProfile (1201) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Set8021XWiredProfile(struct soap*, const struct __net__Set8021XWiredProfile *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Set8021XWiredProfile(struct soap*, struct __net__Set8021XWiredProfile *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Set8021XWiredProfile(struct soap*, const struct __net__Set8021XWiredProfile *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Set8021XWiredProfile(struct soap*, const char*, int, const struct __net__Set8021XWiredProfile *, const char*); +SOAP_FMAC3 struct __net__Set8021XWiredProfile * SOAP_FMAC4 soap_get___net__Set8021XWiredProfile(struct soap*, struct __net__Set8021XWiredProfile *, const char*, const char*); +SOAP_FMAC3 struct __net__Set8021XWiredProfile * SOAP_FMAC4 soap_in___net__Set8021XWiredProfile(struct soap*, const char*, struct __net__Set8021XWiredProfile *, const char*); +SOAP_FMAC5 struct __net__Set8021XWiredProfile * SOAP_FMAC6 soap_new___net__Set8021XWiredProfile(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Set8021XWiredProfile(struct soap*, struct __net__Set8021XWiredProfile*); +SOAP_FMAC3 struct __net__Set8021XWiredProfile * SOAP_FMAC4 soap_instantiate___net__Set8021XWiredProfile(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Set8021XWiredProfile(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__SetInterfaceSettings +#define SOAP_TYPE___net__SetInterfaceSettings (1197) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetInterfaceSettings(struct soap*, const struct __net__SetInterfaceSettings *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetInterfaceSettings(struct soap*, struct __net__SetInterfaceSettings *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetInterfaceSettings(struct soap*, const struct __net__SetInterfaceSettings *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetInterfaceSettings(struct soap*, const char*, int, const struct __net__SetInterfaceSettings *, const char*); +SOAP_FMAC3 struct __net__SetInterfaceSettings * SOAP_FMAC4 soap_get___net__SetInterfaceSettings(struct soap*, struct __net__SetInterfaceSettings *, const char*, const char*); +SOAP_FMAC3 struct __net__SetInterfaceSettings * SOAP_FMAC4 soap_in___net__SetInterfaceSettings(struct soap*, const char*, struct __net__SetInterfaceSettings *, const char*); +SOAP_FMAC5 struct __net__SetInterfaceSettings * SOAP_FMAC6 soap_new___net__SetInterfaceSettings(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetInterfaceSettings(struct soap*, struct __net__SetInterfaceSettings*); +SOAP_FMAC3 struct __net__SetInterfaceSettings * SOAP_FMAC4 soap_instantiate___net__SetInterfaceSettings(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetInterfaceSettings(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__GetInterfaceSettings +#define SOAP_TYPE___net__GetInterfaceSettings (1193) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetInterfaceSettings(struct soap*, const struct __net__GetInterfaceSettings *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetInterfaceSettings(struct soap*, struct __net__GetInterfaceSettings *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetInterfaceSettings(struct soap*, const struct __net__GetInterfaceSettings *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetInterfaceSettings(struct soap*, const char*, int, const struct __net__GetInterfaceSettings *, const char*); +SOAP_FMAC3 struct __net__GetInterfaceSettings * SOAP_FMAC4 soap_get___net__GetInterfaceSettings(struct soap*, struct __net__GetInterfaceSettings *, const char*, const char*); +SOAP_FMAC3 struct __net__GetInterfaceSettings * SOAP_FMAC4 soap_in___net__GetInterfaceSettings(struct soap*, const char*, struct __net__GetInterfaceSettings *, const char*); +SOAP_FMAC5 struct __net__GetInterfaceSettings * SOAP_FMAC6 soap_new___net__GetInterfaceSettings(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetInterfaceSettings(struct soap*, struct __net__GetInterfaceSettings*); +SOAP_FMAC3 struct __net__GetInterfaceSettings * SOAP_FMAC4 soap_instantiate___net__GetInterfaceSettings(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetInterfaceSettings(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__EnumerateInterfaces +#define SOAP_TYPE___net__EnumerateInterfaces (1189) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__EnumerateInterfaces(struct soap*, const struct __net__EnumerateInterfaces *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__EnumerateInterfaces(struct soap*, struct __net__EnumerateInterfaces *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__EnumerateInterfaces(struct soap*, const struct __net__EnumerateInterfaces *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__EnumerateInterfaces(struct soap*, const char*, int, const struct __net__EnumerateInterfaces *, const char*); +SOAP_FMAC3 struct __net__EnumerateInterfaces * SOAP_FMAC4 soap_get___net__EnumerateInterfaces(struct soap*, struct __net__EnumerateInterfaces *, const char*, const char*); +SOAP_FMAC3 struct __net__EnumerateInterfaces * SOAP_FMAC4 soap_in___net__EnumerateInterfaces(struct soap*, const char*, struct __net__EnumerateInterfaces *, const char*); +SOAP_FMAC5 struct __net__EnumerateInterfaces * SOAP_FMAC6 soap_new___net__EnumerateInterfaces(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__EnumerateInterfaces(struct soap*, struct __net__EnumerateInterfaces*); +SOAP_FMAC3 struct __net__EnumerateInterfaces * SOAP_FMAC4 soap_instantiate___net__EnumerateInterfaces(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__EnumerateInterfaces(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__GetPingResponse +#define SOAP_TYPE___net__GetPingResponse (1185) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetPingResponse(struct soap*, const struct __net__GetPingResponse *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetPingResponse(struct soap*, struct __net__GetPingResponse *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetPingResponse(struct soap*, const struct __net__GetPingResponse *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetPingResponse(struct soap*, const char*, int, const struct __net__GetPingResponse *, const char*); +SOAP_FMAC3 struct __net__GetPingResponse * SOAP_FMAC4 soap_get___net__GetPingResponse(struct soap*, struct __net__GetPingResponse *, const char*, const char*); +SOAP_FMAC3 struct __net__GetPingResponse * SOAP_FMAC4 soap_in___net__GetPingResponse(struct soap*, const char*, struct __net__GetPingResponse *, const char*); +SOAP_FMAC5 struct __net__GetPingResponse * SOAP_FMAC6 soap_new___net__GetPingResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetPingResponse(struct soap*, struct __net__GetPingResponse*); +SOAP_FMAC3 struct __net__GetPingResponse * SOAP_FMAC4 soap_instantiate___net__GetPingResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetPingResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__SetPingResponse +#define SOAP_TYPE___net__SetPingResponse (1181) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetPingResponse(struct soap*, const struct __net__SetPingResponse *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetPingResponse(struct soap*, struct __net__SetPingResponse *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetPingResponse(struct soap*, const struct __net__SetPingResponse *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetPingResponse(struct soap*, const char*, int, const struct __net__SetPingResponse *, const char*); +SOAP_FMAC3 struct __net__SetPingResponse * SOAP_FMAC4 soap_get___net__SetPingResponse(struct soap*, struct __net__SetPingResponse *, const char*, const char*); +SOAP_FMAC3 struct __net__SetPingResponse * SOAP_FMAC4 soap_in___net__SetPingResponse(struct soap*, const char*, struct __net__SetPingResponse *, const char*); +SOAP_FMAC5 struct __net__SetPingResponse * SOAP_FMAC6 soap_new___net__SetPingResponse(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetPingResponse(struct soap*, struct __net__SetPingResponse*); +SOAP_FMAC3 struct __net__SetPingResponse * SOAP_FMAC4 soap_instantiate___net__SetPingResponse(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetPingResponse(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__GetVlanParameters +#define SOAP_TYPE___net__GetVlanParameters (1177) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetVlanParameters(struct soap*, const struct __net__GetVlanParameters *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetVlanParameters(struct soap*, struct __net__GetVlanParameters *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetVlanParameters(struct soap*, const struct __net__GetVlanParameters *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetVlanParameters(struct soap*, const char*, int, const struct __net__GetVlanParameters *, const char*); +SOAP_FMAC3 struct __net__GetVlanParameters * SOAP_FMAC4 soap_get___net__GetVlanParameters(struct soap*, struct __net__GetVlanParameters *, const char*, const char*); +SOAP_FMAC3 struct __net__GetVlanParameters * SOAP_FMAC4 soap_in___net__GetVlanParameters(struct soap*, const char*, struct __net__GetVlanParameters *, const char*); +SOAP_FMAC5 struct __net__GetVlanParameters * SOAP_FMAC6 soap_new___net__GetVlanParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetVlanParameters(struct soap*, struct __net__GetVlanParameters*); +SOAP_FMAC3 struct __net__GetVlanParameters * SOAP_FMAC4 soap_instantiate___net__GetVlanParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetVlanParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__SetVlanParameters +#define SOAP_TYPE___net__SetVlanParameters (1173) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetVlanParameters(struct soap*, const struct __net__SetVlanParameters *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetVlanParameters(struct soap*, struct __net__SetVlanParameters *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetVlanParameters(struct soap*, const struct __net__SetVlanParameters *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetVlanParameters(struct soap*, const char*, int, const struct __net__SetVlanParameters *, const char*); +SOAP_FMAC3 struct __net__SetVlanParameters * SOAP_FMAC4 soap_get___net__SetVlanParameters(struct soap*, struct __net__SetVlanParameters *, const char*, const char*); +SOAP_FMAC3 struct __net__SetVlanParameters * SOAP_FMAC4 soap_in___net__SetVlanParameters(struct soap*, const char*, struct __net__SetVlanParameters *, const char*); +SOAP_FMAC5 struct __net__SetVlanParameters * SOAP_FMAC6 soap_new___net__SetVlanParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetVlanParameters(struct soap*, struct __net__SetVlanParameters*); +SOAP_FMAC3 struct __net__SetVlanParameters * SOAP_FMAC4 soap_instantiate___net__SetVlanParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetVlanParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__GetTcpIpParameters +#define SOAP_TYPE___net__GetTcpIpParameters (1169) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetTcpIpParameters(struct soap*, const struct __net__GetTcpIpParameters *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetTcpIpParameters(struct soap*, struct __net__GetTcpIpParameters *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetTcpIpParameters(struct soap*, const struct __net__GetTcpIpParameters *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetTcpIpParameters(struct soap*, const char*, int, const struct __net__GetTcpIpParameters *, const char*); +SOAP_FMAC3 struct __net__GetTcpIpParameters * SOAP_FMAC4 soap_get___net__GetTcpIpParameters(struct soap*, struct __net__GetTcpIpParameters *, const char*, const char*); +SOAP_FMAC3 struct __net__GetTcpIpParameters * SOAP_FMAC4 soap_in___net__GetTcpIpParameters(struct soap*, const char*, struct __net__GetTcpIpParameters *, const char*); +SOAP_FMAC5 struct __net__GetTcpIpParameters * SOAP_FMAC6 soap_new___net__GetTcpIpParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetTcpIpParameters(struct soap*, struct __net__GetTcpIpParameters*); +SOAP_FMAC3 struct __net__GetTcpIpParameters * SOAP_FMAC4 soap_instantiate___net__GetTcpIpParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetTcpIpParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__SetTcpIpParameters +#define SOAP_TYPE___net__SetTcpIpParameters (1165) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetTcpIpParameters(struct soap*, const struct __net__SetTcpIpParameters *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetTcpIpParameters(struct soap*, struct __net__SetTcpIpParameters *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetTcpIpParameters(struct soap*, const struct __net__SetTcpIpParameters *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetTcpIpParameters(struct soap*, const char*, int, const struct __net__SetTcpIpParameters *, const char*); +SOAP_FMAC3 struct __net__SetTcpIpParameters * SOAP_FMAC4 soap_get___net__SetTcpIpParameters(struct soap*, struct __net__SetTcpIpParameters *, const char*, const char*); +SOAP_FMAC3 struct __net__SetTcpIpParameters * SOAP_FMAC4 soap_in___net__SetTcpIpParameters(struct soap*, const char*, struct __net__SetTcpIpParameters *, const char*); +SOAP_FMAC5 struct __net__SetTcpIpParameters * SOAP_FMAC6 soap_new___net__SetTcpIpParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetTcpIpParameters(struct soap*, struct __net__SetTcpIpParameters*); +SOAP_FMAC3 struct __net__SetTcpIpParameters * SOAP_FMAC4 soap_instantiate___net__SetTcpIpParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetTcpIpParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__GetDomainName +#define SOAP_TYPE___net__GetDomainName (1161) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetDomainName(struct soap*, const struct __net__GetDomainName *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetDomainName(struct soap*, struct __net__GetDomainName *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetDomainName(struct soap*, const struct __net__GetDomainName *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetDomainName(struct soap*, const char*, int, const struct __net__GetDomainName *, const char*); +SOAP_FMAC3 struct __net__GetDomainName * SOAP_FMAC4 soap_get___net__GetDomainName(struct soap*, struct __net__GetDomainName *, const char*, const char*); +SOAP_FMAC3 struct __net__GetDomainName * SOAP_FMAC4 soap_in___net__GetDomainName(struct soap*, const char*, struct __net__GetDomainName *, const char*); +SOAP_FMAC5 struct __net__GetDomainName * SOAP_FMAC6 soap_new___net__GetDomainName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetDomainName(struct soap*, struct __net__GetDomainName*); +SOAP_FMAC3 struct __net__GetDomainName * SOAP_FMAC4 soap_instantiate___net__GetDomainName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetDomainName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__SetDomainName +#define SOAP_TYPE___net__SetDomainName (1157) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetDomainName(struct soap*, const struct __net__SetDomainName *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetDomainName(struct soap*, struct __net__SetDomainName *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetDomainName(struct soap*, const struct __net__SetDomainName *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetDomainName(struct soap*, const char*, int, const struct __net__SetDomainName *, const char*); +SOAP_FMAC3 struct __net__SetDomainName * SOAP_FMAC4 soap_get___net__SetDomainName(struct soap*, struct __net__SetDomainName *, const char*, const char*); +SOAP_FMAC3 struct __net__SetDomainName * SOAP_FMAC4 soap_in___net__SetDomainName(struct soap*, const char*, struct __net__SetDomainName *, const char*); +SOAP_FMAC5 struct __net__SetDomainName * SOAP_FMAC6 soap_new___net__SetDomainName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetDomainName(struct soap*, struct __net__SetDomainName*); +SOAP_FMAC3 struct __net__SetDomainName * SOAP_FMAC4 soap_instantiate___net__SetDomainName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetDomainName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__GetHostName +#define SOAP_TYPE___net__GetHostName (1153) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetHostName(struct soap*, const struct __net__GetHostName *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetHostName(struct soap*, struct __net__GetHostName *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetHostName(struct soap*, const struct __net__GetHostName *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetHostName(struct soap*, const char*, int, const struct __net__GetHostName *, const char*); +SOAP_FMAC3 struct __net__GetHostName * SOAP_FMAC4 soap_get___net__GetHostName(struct soap*, struct __net__GetHostName *, const char*, const char*); +SOAP_FMAC3 struct __net__GetHostName * SOAP_FMAC4 soap_in___net__GetHostName(struct soap*, const char*, struct __net__GetHostName *, const char*); +SOAP_FMAC5 struct __net__GetHostName * SOAP_FMAC6 soap_new___net__GetHostName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetHostName(struct soap*, struct __net__GetHostName*); +SOAP_FMAC3 struct __net__GetHostName * SOAP_FMAC4 soap_instantiate___net__GetHostName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetHostName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___net__SetHostName +#define SOAP_TYPE___net__SetHostName (1149) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetHostName(struct soap*, const struct __net__SetHostName *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetHostName(struct soap*, struct __net__SetHostName *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetHostName(struct soap*, const struct __net__SetHostName *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetHostName(struct soap*, const char*, int, const struct __net__SetHostName *, const char*); +SOAP_FMAC3 struct __net__SetHostName * SOAP_FMAC4 soap_get___net__SetHostName(struct soap*, struct __net__SetHostName *, const char*, const char*); +SOAP_FMAC3 struct __net__SetHostName * SOAP_FMAC4 soap_in___net__SetHostName(struct soap*, const char*, struct __net__SetHostName *, const char*); +SOAP_FMAC5 struct __net__SetHostName * SOAP_FMAC6 soap_new___net__SetHostName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetHostName(struct soap*, struct __net__SetHostName*); +SOAP_FMAC3 struct __net__SetHostName * SOAP_FMAC4 soap_instantiate___net__SetHostName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetHostName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetIderSessionLog +#define SOAP_TYPE___inf__GetIderSessionLog (1145) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetIderSessionLog(struct soap*, const struct __inf__GetIderSessionLog *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetIderSessionLog(struct soap*, struct __inf__GetIderSessionLog *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetIderSessionLog(struct soap*, const struct __inf__GetIderSessionLog *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetIderSessionLog(struct soap*, const char*, int, const struct __inf__GetIderSessionLog *, const char*); +SOAP_FMAC3 struct __inf__GetIderSessionLog * SOAP_FMAC4 soap_get___inf__GetIderSessionLog(struct soap*, struct __inf__GetIderSessionLog *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetIderSessionLog * SOAP_FMAC4 soap_in___inf__GetIderSessionLog(struct soap*, const char*, struct __inf__GetIderSessionLog *, const char*); +SOAP_FMAC5 struct __inf__GetIderSessionLog * SOAP_FMAC6 soap_new___inf__GetIderSessionLog(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetIderSessionLog(struct soap*, struct __inf__GetIderSessionLog*); +SOAP_FMAC3 struct __inf__GetIderSessionLog * SOAP_FMAC4 soap_instantiate___inf__GetIderSessionLog(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetIderSessionLog(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetSecurityParameters +#define SOAP_TYPE___inf__GetSecurityParameters (1141) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetSecurityParameters(struct soap*, const struct __inf__GetSecurityParameters *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetSecurityParameters(struct soap*, struct __inf__GetSecurityParameters *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetSecurityParameters(struct soap*, const struct __inf__GetSecurityParameters *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetSecurityParameters(struct soap*, const char*, int, const struct __inf__GetSecurityParameters *, const char*); +SOAP_FMAC3 struct __inf__GetSecurityParameters * SOAP_FMAC4 soap_get___inf__GetSecurityParameters(struct soap*, struct __inf__GetSecurityParameters *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetSecurityParameters * SOAP_FMAC4 soap_in___inf__GetSecurityParameters(struct soap*, const char*, struct __inf__GetSecurityParameters *, const char*); +SOAP_FMAC5 struct __inf__GetSecurityParameters * SOAP_FMAC6 soap_new___inf__GetSecurityParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetSecurityParameters(struct soap*, struct __inf__GetSecurityParameters*); +SOAP_FMAC3 struct __inf__GetSecurityParameters * SOAP_FMAC4 soap_instantiate___inf__GetSecurityParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetSecurityParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetNetworkState +#define SOAP_TYPE___inf__GetNetworkState (1137) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetNetworkState(struct soap*, const struct __inf__GetNetworkState *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetNetworkState(struct soap*, struct __inf__GetNetworkState *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetNetworkState(struct soap*, const struct __inf__GetNetworkState *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetNetworkState(struct soap*, const char*, int, const struct __inf__GetNetworkState *, const char*); +SOAP_FMAC3 struct __inf__GetNetworkState * SOAP_FMAC4 soap_get___inf__GetNetworkState(struct soap*, struct __inf__GetNetworkState *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetNetworkState * SOAP_FMAC4 soap_in___inf__GetNetworkState(struct soap*, const char*, struct __inf__GetNetworkState *, const char*); +SOAP_FMAC5 struct __inf__GetNetworkState * SOAP_FMAC6 soap_new___inf__GetNetworkState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetNetworkState(struct soap*, struct __inf__GetNetworkState*); +SOAP_FMAC3 struct __inf__GetNetworkState * SOAP_FMAC4 soap_instantiate___inf__GetNetworkState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetNetworkState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetEnabledInterfaces +#define SOAP_TYPE___inf__GetEnabledInterfaces (1133) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetEnabledInterfaces(struct soap*, const struct __inf__GetEnabledInterfaces *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetEnabledInterfaces(struct soap*, struct __inf__GetEnabledInterfaces *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetEnabledInterfaces(struct soap*, const struct __inf__GetEnabledInterfaces *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetEnabledInterfaces(struct soap*, const char*, int, const struct __inf__GetEnabledInterfaces *, const char*); +SOAP_FMAC3 struct __inf__GetEnabledInterfaces * SOAP_FMAC4 soap_get___inf__GetEnabledInterfaces(struct soap*, struct __inf__GetEnabledInterfaces *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetEnabledInterfaces * SOAP_FMAC4 soap_in___inf__GetEnabledInterfaces(struct soap*, const char*, struct __inf__GetEnabledInterfaces *, const char*); +SOAP_FMAC5 struct __inf__GetEnabledInterfaces * SOAP_FMAC6 soap_new___inf__GetEnabledInterfaces(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetEnabledInterfaces(struct soap*, struct __inf__GetEnabledInterfaces*); +SOAP_FMAC3 struct __inf__GetEnabledInterfaces * SOAP_FMAC4 soap_instantiate___inf__GetEnabledInterfaces(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetEnabledInterfaces(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetPasswordModel +#define SOAP_TYPE___inf__GetPasswordModel (1129) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetPasswordModel(struct soap*, const struct __inf__GetPasswordModel *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetPasswordModel(struct soap*, struct __inf__GetPasswordModel *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetPasswordModel(struct soap*, const struct __inf__GetPasswordModel *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetPasswordModel(struct soap*, const char*, int, const struct __inf__GetPasswordModel *, const char*); +SOAP_FMAC3 struct __inf__GetPasswordModel * SOAP_FMAC4 soap_get___inf__GetPasswordModel(struct soap*, struct __inf__GetPasswordModel *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetPasswordModel * SOAP_FMAC4 soap_in___inf__GetPasswordModel(struct soap*, const char*, struct __inf__GetPasswordModel *, const char*); +SOAP_FMAC5 struct __inf__GetPasswordModel * SOAP_FMAC6 soap_new___inf__GetPasswordModel(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetPasswordModel(struct soap*, struct __inf__GetPasswordModel*); +SOAP_FMAC3 struct __inf__GetPasswordModel * SOAP_FMAC4 soap_instantiate___inf__GetPasswordModel(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetPasswordModel(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetAdminNetAclEntryStatus +#define SOAP_TYPE___inf__GetAdminNetAclEntryStatus (1125) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetAdminNetAclEntryStatus(struct soap*, const struct __inf__GetAdminNetAclEntryStatus *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetAdminNetAclEntryStatus(struct soap*, struct __inf__GetAdminNetAclEntryStatus *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetAdminNetAclEntryStatus(struct soap*, const struct __inf__GetAdminNetAclEntryStatus *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetAdminNetAclEntryStatus(struct soap*, const char*, int, const struct __inf__GetAdminNetAclEntryStatus *, const char*); +SOAP_FMAC3 struct __inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_get___inf__GetAdminNetAclEntryStatus(struct soap*, struct __inf__GetAdminNetAclEntryStatus *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_in___inf__GetAdminNetAclEntryStatus(struct soap*, const char*, struct __inf__GetAdminNetAclEntryStatus *, const char*); +SOAP_FMAC5 struct __inf__GetAdminNetAclEntryStatus * SOAP_FMAC6 soap_new___inf__GetAdminNetAclEntryStatus(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetAdminNetAclEntryStatus(struct soap*, struct __inf__GetAdminNetAclEntryStatus*); +SOAP_FMAC3 struct __inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_instantiate___inf__GetAdminNetAclEntryStatus(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetAdminNetAclEntryStatus(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetAdminAclEntryStatus +#define SOAP_TYPE___inf__GetAdminAclEntryStatus (1121) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetAdminAclEntryStatus(struct soap*, const struct __inf__GetAdminAclEntryStatus *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetAdminAclEntryStatus(struct soap*, struct __inf__GetAdminAclEntryStatus *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetAdminAclEntryStatus(struct soap*, const struct __inf__GetAdminAclEntryStatus *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetAdminAclEntryStatus(struct soap*, const char*, int, const struct __inf__GetAdminAclEntryStatus *, const char*); +SOAP_FMAC3 struct __inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_get___inf__GetAdminAclEntryStatus(struct soap*, struct __inf__GetAdminAclEntryStatus *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_in___inf__GetAdminAclEntryStatus(struct soap*, const char*, struct __inf__GetAdminAclEntryStatus *, const char*); +SOAP_FMAC5 struct __inf__GetAdminAclEntryStatus * SOAP_FMAC6 soap_new___inf__GetAdminAclEntryStatus(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetAdminAclEntryStatus(struct soap*, struct __inf__GetAdminAclEntryStatus*); +SOAP_FMAC3 struct __inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_instantiate___inf__GetAdminAclEntryStatus(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetAdminAclEntryStatus(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetConfigServerInfo +#define SOAP_TYPE___inf__GetConfigServerInfo (1117) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetConfigServerInfo(struct soap*, const struct __inf__GetConfigServerInfo *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetConfigServerInfo(struct soap*, struct __inf__GetConfigServerInfo *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetConfigServerInfo(struct soap*, const struct __inf__GetConfigServerInfo *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetConfigServerInfo(struct soap*, const char*, int, const struct __inf__GetConfigServerInfo *, const char*); +SOAP_FMAC3 struct __inf__GetConfigServerInfo * SOAP_FMAC4 soap_get___inf__GetConfigServerInfo(struct soap*, struct __inf__GetConfigServerInfo *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetConfigServerInfo * SOAP_FMAC4 soap_in___inf__GetConfigServerInfo(struct soap*, const char*, struct __inf__GetConfigServerInfo *, const char*); +SOAP_FMAC5 struct __inf__GetConfigServerInfo * SOAP_FMAC6 soap_new___inf__GetConfigServerInfo(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetConfigServerInfo(struct soap*, struct __inf__GetConfigServerInfo*); +SOAP_FMAC3 struct __inf__GetConfigServerInfo * SOAP_FMAC4 soap_instantiate___inf__GetConfigServerInfo(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetConfigServerInfo(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetHostName +#define SOAP_TYPE___inf__GetHostName (1113) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetHostName(struct soap*, const struct __inf__GetHostName *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetHostName(struct soap*, struct __inf__GetHostName *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetHostName(struct soap*, const struct __inf__GetHostName *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetHostName(struct soap*, const char*, int, const struct __inf__GetHostName *, const char*); +SOAP_FMAC3 struct __inf__GetHostName * SOAP_FMAC4 soap_get___inf__GetHostName(struct soap*, struct __inf__GetHostName *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetHostName * SOAP_FMAC4 soap_in___inf__GetHostName(struct soap*, const char*, struct __inf__GetHostName *, const char*); +SOAP_FMAC5 struct __inf__GetHostName * SOAP_FMAC6 soap_new___inf__GetHostName(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetHostName(struct soap*, struct __inf__GetHostName*); +SOAP_FMAC3 struct __inf__GetHostName * SOAP_FMAC4 soap_instantiate___inf__GetHostName(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetHostName(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetVlanParameters +#define SOAP_TYPE___inf__GetVlanParameters (1109) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetVlanParameters(struct soap*, const struct __inf__GetVlanParameters *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetVlanParameters(struct soap*, struct __inf__GetVlanParameters *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetVlanParameters(struct soap*, const struct __inf__GetVlanParameters *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetVlanParameters(struct soap*, const char*, int, const struct __inf__GetVlanParameters *, const char*); +SOAP_FMAC3 struct __inf__GetVlanParameters * SOAP_FMAC4 soap_get___inf__GetVlanParameters(struct soap*, struct __inf__GetVlanParameters *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetVlanParameters * SOAP_FMAC4 soap_in___inf__GetVlanParameters(struct soap*, const char*, struct __inf__GetVlanParameters *, const char*); +SOAP_FMAC5 struct __inf__GetVlanParameters * SOAP_FMAC6 soap_new___inf__GetVlanParameters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetVlanParameters(struct soap*, struct __inf__GetVlanParameters*); +SOAP_FMAC3 struct __inf__GetVlanParameters * SOAP_FMAC4 soap_instantiate___inf__GetVlanParameters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetVlanParameters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetProvisioningState +#define SOAP_TYPE___inf__GetProvisioningState (1105) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetProvisioningState(struct soap*, const struct __inf__GetProvisioningState *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetProvisioningState(struct soap*, struct __inf__GetProvisioningState *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetProvisioningState(struct soap*, const struct __inf__GetProvisioningState *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetProvisioningState(struct soap*, const char*, int, const struct __inf__GetProvisioningState *, const char*); +SOAP_FMAC3 struct __inf__GetProvisioningState * SOAP_FMAC4 soap_get___inf__GetProvisioningState(struct soap*, struct __inf__GetProvisioningState *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetProvisioningState * SOAP_FMAC4 soap_in___inf__GetProvisioningState(struct soap*, const char*, struct __inf__GetProvisioningState *, const char*); +SOAP_FMAC5 struct __inf__GetProvisioningState * SOAP_FMAC6 soap_new___inf__GetProvisioningState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetProvisioningState(struct soap*, struct __inf__GetProvisioningState*); +SOAP_FMAC3 struct __inf__GetProvisioningState * SOAP_FMAC4 soap_instantiate___inf__GetProvisioningState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetProvisioningState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetProvisioningMode +#define SOAP_TYPE___inf__GetProvisioningMode (1101) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetProvisioningMode(struct soap*, const struct __inf__GetProvisioningMode *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetProvisioningMode(struct soap*, struct __inf__GetProvisioningMode *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetProvisioningMode(struct soap*, const struct __inf__GetProvisioningMode *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetProvisioningMode(struct soap*, const char*, int, const struct __inf__GetProvisioningMode *, const char*); +SOAP_FMAC3 struct __inf__GetProvisioningMode * SOAP_FMAC4 soap_get___inf__GetProvisioningMode(struct soap*, struct __inf__GetProvisioningMode *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetProvisioningMode * SOAP_FMAC4 soap_in___inf__GetProvisioningMode(struct soap*, const char*, struct __inf__GetProvisioningMode *, const char*); +SOAP_FMAC5 struct __inf__GetProvisioningMode * SOAP_FMAC6 soap_new___inf__GetProvisioningMode(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetProvisioningMode(struct soap*, struct __inf__GetProvisioningMode*); +SOAP_FMAC3 struct __inf__GetProvisioningMode * SOAP_FMAC4 soap_instantiate___inf__GetProvisioningMode(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetProvisioningMode(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetCodeVersions +#define SOAP_TYPE___inf__GetCodeVersions (1097) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetCodeVersions(struct soap*, const struct __inf__GetCodeVersions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetCodeVersions(struct soap*, struct __inf__GetCodeVersions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetCodeVersions(struct soap*, const struct __inf__GetCodeVersions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetCodeVersions(struct soap*, const char*, int, const struct __inf__GetCodeVersions *, const char*); +SOAP_FMAC3 struct __inf__GetCodeVersions * SOAP_FMAC4 soap_get___inf__GetCodeVersions(struct soap*, struct __inf__GetCodeVersions *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetCodeVersions * SOAP_FMAC4 soap_in___inf__GetCodeVersions(struct soap*, const char*, struct __inf__GetCodeVersions *, const char*); +SOAP_FMAC5 struct __inf__GetCodeVersions * SOAP_FMAC6 soap_new___inf__GetCodeVersions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetCodeVersions(struct soap*, struct __inf__GetCodeVersions*); +SOAP_FMAC3 struct __inf__GetCodeVersions * SOAP_FMAC4 soap_instantiate___inf__GetCodeVersions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetCodeVersions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___inf__GetCoreVersion +#define SOAP_TYPE___inf__GetCoreVersion (1093) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetCoreVersion(struct soap*, const struct __inf__GetCoreVersion *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetCoreVersion(struct soap*, struct __inf__GetCoreVersion *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetCoreVersion(struct soap*, const struct __inf__GetCoreVersion *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetCoreVersion(struct soap*, const char*, int, const struct __inf__GetCoreVersion *, const char*); +SOAP_FMAC3 struct __inf__GetCoreVersion * SOAP_FMAC4 soap_get___inf__GetCoreVersion(struct soap*, struct __inf__GetCoreVersion *, const char*, const char*); +SOAP_FMAC3 struct __inf__GetCoreVersion * SOAP_FMAC4 soap_in___inf__GetCoreVersion(struct soap*, const char*, struct __inf__GetCoreVersion *, const char*); +SOAP_FMAC5 struct __inf__GetCoreVersion * SOAP_FMAC6 soap_new___inf__GetCoreVersion(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetCoreVersion(struct soap*, struct __inf__GetCoreVersion*); +SOAP_FMAC3 struct __inf__GetCoreVersion * SOAP_FMAC4 soap_instantiate___inf__GetCoreVersion(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetCoreVersion(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___idr__GetIderSessionLog +#define SOAP_TYPE___idr__GetIderSessionLog (1089) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___idr__GetIderSessionLog(struct soap*, const struct __idr__GetIderSessionLog *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___idr__GetIderSessionLog(struct soap*, struct __idr__GetIderSessionLog *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___idr__GetIderSessionLog(struct soap*, const struct __idr__GetIderSessionLog *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___idr__GetIderSessionLog(struct soap*, const char*, int, const struct __idr__GetIderSessionLog *, const char*); +SOAP_FMAC3 struct __idr__GetIderSessionLog * SOAP_FMAC4 soap_get___idr__GetIderSessionLog(struct soap*, struct __idr__GetIderSessionLog *, const char*, const char*); +SOAP_FMAC3 struct __idr__GetIderSessionLog * SOAP_FMAC4 soap_in___idr__GetIderSessionLog(struct soap*, const char*, struct __idr__GetIderSessionLog *, const char*); +SOAP_FMAC5 struct __idr__GetIderSessionLog * SOAP_FMAC6 soap_new___idr__GetIderSessionLog(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___idr__GetIderSessionLog(struct soap*, struct __idr__GetIderSessionLog*); +SOAP_FMAC3 struct __idr__GetIderSessionLog * SOAP_FMAC4 soap_instantiate___idr__GetIderSessionLog(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___idr__GetIderSessionLog(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___idr__GetRedirectionListenerState +#define SOAP_TYPE___idr__GetRedirectionListenerState (1085) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___idr__GetRedirectionListenerState(struct soap*, const struct __idr__GetRedirectionListenerState *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___idr__GetRedirectionListenerState(struct soap*, struct __idr__GetRedirectionListenerState *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___idr__GetRedirectionListenerState(struct soap*, const struct __idr__GetRedirectionListenerState *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___idr__GetRedirectionListenerState(struct soap*, const char*, int, const struct __idr__GetRedirectionListenerState *, const char*); +SOAP_FMAC3 struct __idr__GetRedirectionListenerState * SOAP_FMAC4 soap_get___idr__GetRedirectionListenerState(struct soap*, struct __idr__GetRedirectionListenerState *, const char*, const char*); +SOAP_FMAC3 struct __idr__GetRedirectionListenerState * SOAP_FMAC4 soap_in___idr__GetRedirectionListenerState(struct soap*, const char*, struct __idr__GetRedirectionListenerState *, const char*); +SOAP_FMAC5 struct __idr__GetRedirectionListenerState * SOAP_FMAC6 soap_new___idr__GetRedirectionListenerState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___idr__GetRedirectionListenerState(struct soap*, struct __idr__GetRedirectionListenerState*); +SOAP_FMAC3 struct __idr__GetRedirectionListenerState * SOAP_FMAC4 soap_instantiate___idr__GetRedirectionListenerState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___idr__GetRedirectionListenerState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___idr__SetRedirectionListenerState +#define SOAP_TYPE___idr__SetRedirectionListenerState (1081) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___idr__SetRedirectionListenerState(struct soap*, const struct __idr__SetRedirectionListenerState *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___idr__SetRedirectionListenerState(struct soap*, struct __idr__SetRedirectionListenerState *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___idr__SetRedirectionListenerState(struct soap*, const struct __idr__SetRedirectionListenerState *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___idr__SetRedirectionListenerState(struct soap*, const char*, int, const struct __idr__SetRedirectionListenerState *, const char*); +SOAP_FMAC3 struct __idr__SetRedirectionListenerState * SOAP_FMAC4 soap_get___idr__SetRedirectionListenerState(struct soap*, struct __idr__SetRedirectionListenerState *, const char*, const char*); +SOAP_FMAC3 struct __idr__SetRedirectionListenerState * SOAP_FMAC4 soap_in___idr__SetRedirectionListenerState(struct soap*, const char*, struct __idr__SetRedirectionListenerState *, const char*); +SOAP_FMAC5 struct __idr__SetRedirectionListenerState * SOAP_FMAC6 soap_new___idr__SetRedirectionListenerState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___idr__SetRedirectionListenerState(struct soap*, struct __idr__SetRedirectionListenerState*); +SOAP_FMAC3 struct __idr__SetRedirectionListenerState * SOAP_FMAC4 soap_instantiate___idr__SetRedirectionListenerState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___idr__SetRedirectionListenerState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___hwa__GetAssetData +#define SOAP_TYPE___hwa__GetAssetData (1077) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___hwa__GetAssetData(struct soap*, const struct __hwa__GetAssetData *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___hwa__GetAssetData(struct soap*, struct __hwa__GetAssetData *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___hwa__GetAssetData(struct soap*, const struct __hwa__GetAssetData *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___hwa__GetAssetData(struct soap*, const char*, int, const struct __hwa__GetAssetData *, const char*); +SOAP_FMAC3 struct __hwa__GetAssetData * SOAP_FMAC4 soap_get___hwa__GetAssetData(struct soap*, struct __hwa__GetAssetData *, const char*, const char*); +SOAP_FMAC3 struct __hwa__GetAssetData * SOAP_FMAC4 soap_in___hwa__GetAssetData(struct soap*, const char*, struct __hwa__GetAssetData *, const char*); +SOAP_FMAC5 struct __hwa__GetAssetData * SOAP_FMAC6 soap_new___hwa__GetAssetData(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___hwa__GetAssetData(struct soap*, struct __hwa__GetAssetData*); +SOAP_FMAC3 struct __hwa__GetAssetData * SOAP_FMAC4 soap_instantiate___hwa__GetAssetData(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___hwa__GetAssetData(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___hwa__EnumerateAssetTypes +#define SOAP_TYPE___hwa__EnumerateAssetTypes (1073) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___hwa__EnumerateAssetTypes(struct soap*, const struct __hwa__EnumerateAssetTypes *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___hwa__EnumerateAssetTypes(struct soap*, struct __hwa__EnumerateAssetTypes *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___hwa__EnumerateAssetTypes(struct soap*, const struct __hwa__EnumerateAssetTypes *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___hwa__EnumerateAssetTypes(struct soap*, const char*, int, const struct __hwa__EnumerateAssetTypes *, const char*); +SOAP_FMAC3 struct __hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_get___hwa__EnumerateAssetTypes(struct soap*, struct __hwa__EnumerateAssetTypes *, const char*, const char*); +SOAP_FMAC3 struct __hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_in___hwa__EnumerateAssetTypes(struct soap*, const char*, struct __hwa__EnumerateAssetTypes *, const char*); +SOAP_FMAC5 struct __hwa__EnumerateAssetTypes * SOAP_FMAC6 soap_new___hwa__EnumerateAssetTypes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___hwa__EnumerateAssetTypes(struct soap*, struct __hwa__EnumerateAssetTypes*); +SOAP_FMAC3 struct __hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_instantiate___hwa__EnumerateAssetTypes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___hwa__EnumerateAssetTypes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__GetGeneralAlertSubscription +#define SOAP_TYPE___emi__GetGeneralAlertSubscription (1069) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetGeneralAlertSubscription(struct soap*, const struct __emi__GetGeneralAlertSubscription *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetGeneralAlertSubscription(struct soap*, struct __emi__GetGeneralAlertSubscription *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetGeneralAlertSubscription(struct soap*, const struct __emi__GetGeneralAlertSubscription *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetGeneralAlertSubscription(struct soap*, const char*, int, const struct __emi__GetGeneralAlertSubscription *, const char*); +SOAP_FMAC3 struct __emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_get___emi__GetGeneralAlertSubscription(struct soap*, struct __emi__GetGeneralAlertSubscription *, const char*, const char*); +SOAP_FMAC3 struct __emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_in___emi__GetGeneralAlertSubscription(struct soap*, const char*, struct __emi__GetGeneralAlertSubscription *, const char*); +SOAP_FMAC5 struct __emi__GetGeneralAlertSubscription * SOAP_FMAC6 soap_new___emi__GetGeneralAlertSubscription(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetGeneralAlertSubscription(struct soap*, struct __emi__GetGeneralAlertSubscription*); +SOAP_FMAC3 struct __emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_instantiate___emi__GetGeneralAlertSubscription(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetGeneralAlertSubscription(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__EnumerateGeneralAlertSubscriptions +#define SOAP_TYPE___emi__EnumerateGeneralAlertSubscriptions (1065) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateGeneralAlertSubscriptions(struct soap*, const struct __emi__EnumerateGeneralAlertSubscriptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateGeneralAlertSubscriptions(struct soap*, struct __emi__EnumerateGeneralAlertSubscriptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateGeneralAlertSubscriptions(struct soap*, const struct __emi__EnumerateGeneralAlertSubscriptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateGeneralAlertSubscriptions(struct soap*, const char*, int, const struct __emi__EnumerateGeneralAlertSubscriptions *, const char*); +SOAP_FMAC3 struct __emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_get___emi__EnumerateGeneralAlertSubscriptions(struct soap*, struct __emi__EnumerateGeneralAlertSubscriptions *, const char*, const char*); +SOAP_FMAC3 struct __emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_in___emi__EnumerateGeneralAlertSubscriptions(struct soap*, const char*, struct __emi__EnumerateGeneralAlertSubscriptions *, const char*); +SOAP_FMAC5 struct __emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC6 soap_new___emi__EnumerateGeneralAlertSubscriptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateGeneralAlertSubscriptions(struct soap*, struct __emi__EnumerateGeneralAlertSubscriptions*); +SOAP_FMAC3 struct __emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_instantiate___emi__EnumerateGeneralAlertSubscriptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateGeneralAlertSubscriptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__SubscribeForGeneralAlert +#define SOAP_TYPE___emi__SubscribeForGeneralAlert (1061) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__SubscribeForGeneralAlert(struct soap*, const struct __emi__SubscribeForGeneralAlert *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__SubscribeForGeneralAlert(struct soap*, struct __emi__SubscribeForGeneralAlert *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__SubscribeForGeneralAlert(struct soap*, const struct __emi__SubscribeForGeneralAlert *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__SubscribeForGeneralAlert(struct soap*, const char*, int, const struct __emi__SubscribeForGeneralAlert *, const char*); +SOAP_FMAC3 struct __emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_get___emi__SubscribeForGeneralAlert(struct soap*, struct __emi__SubscribeForGeneralAlert *, const char*, const char*); +SOAP_FMAC3 struct __emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_in___emi__SubscribeForGeneralAlert(struct soap*, const char*, struct __emi__SubscribeForGeneralAlert *, const char*); +SOAP_FMAC5 struct __emi__SubscribeForGeneralAlert * SOAP_FMAC6 soap_new___emi__SubscribeForGeneralAlert(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__SubscribeForGeneralAlert(struct soap*, struct __emi__SubscribeForGeneralAlert*); +SOAP_FMAC3 struct __emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_instantiate___emi__SubscribeForGeneralAlert(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__SubscribeForGeneralAlert(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__GetSensorAttributes +#define SOAP_TYPE___emi__GetSensorAttributes (1057) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetSensorAttributes(struct soap*, const struct __emi__GetSensorAttributes *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetSensorAttributes(struct soap*, struct __emi__GetSensorAttributes *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetSensorAttributes(struct soap*, const struct __emi__GetSensorAttributes *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetSensorAttributes(struct soap*, const char*, int, const struct __emi__GetSensorAttributes *, const char*); +SOAP_FMAC3 struct __emi__GetSensorAttributes * SOAP_FMAC4 soap_get___emi__GetSensorAttributes(struct soap*, struct __emi__GetSensorAttributes *, const char*, const char*); +SOAP_FMAC3 struct __emi__GetSensorAttributes * SOAP_FMAC4 soap_in___emi__GetSensorAttributes(struct soap*, const char*, struct __emi__GetSensorAttributes *, const char*); +SOAP_FMAC5 struct __emi__GetSensorAttributes * SOAP_FMAC6 soap_new___emi__GetSensorAttributes(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetSensorAttributes(struct soap*, struct __emi__GetSensorAttributes*); +SOAP_FMAC3 struct __emi__GetSensorAttributes * SOAP_FMAC4 soap_instantiate___emi__GetSensorAttributes(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetSensorAttributes(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__EnumerateSensors +#define SOAP_TYPE___emi__EnumerateSensors (1053) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateSensors(struct soap*, const struct __emi__EnumerateSensors *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateSensors(struct soap*, struct __emi__EnumerateSensors *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateSensors(struct soap*, const struct __emi__EnumerateSensors *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateSensors(struct soap*, const char*, int, const struct __emi__EnumerateSensors *, const char*); +SOAP_FMAC3 struct __emi__EnumerateSensors * SOAP_FMAC4 soap_get___emi__EnumerateSensors(struct soap*, struct __emi__EnumerateSensors *, const char*, const char*); +SOAP_FMAC3 struct __emi__EnumerateSensors * SOAP_FMAC4 soap_in___emi__EnumerateSensors(struct soap*, const char*, struct __emi__EnumerateSensors *, const char*); +SOAP_FMAC5 struct __emi__EnumerateSensors * SOAP_FMAC6 soap_new___emi__EnumerateSensors(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateSensors(struct soap*, struct __emi__EnumerateSensors*); +SOAP_FMAC3 struct __emi__EnumerateSensors * SOAP_FMAC4 soap_instantiate___emi__EnumerateSensors(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateSensors(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__GetEventLogTimestampClock +#define SOAP_TYPE___emi__GetEventLogTimestampClock (1049) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetEventLogTimestampClock(struct soap*, const struct __emi__GetEventLogTimestampClock *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetEventLogTimestampClock(struct soap*, struct __emi__GetEventLogTimestampClock *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetEventLogTimestampClock(struct soap*, const struct __emi__GetEventLogTimestampClock *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetEventLogTimestampClock(struct soap*, const char*, int, const struct __emi__GetEventLogTimestampClock *, const char*); +SOAP_FMAC3 struct __emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_get___emi__GetEventLogTimestampClock(struct soap*, struct __emi__GetEventLogTimestampClock *, const char*, const char*); +SOAP_FMAC3 struct __emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_in___emi__GetEventLogTimestampClock(struct soap*, const char*, struct __emi__GetEventLogTimestampClock *, const char*); +SOAP_FMAC5 struct __emi__GetEventLogTimestampClock * SOAP_FMAC6 soap_new___emi__GetEventLogTimestampClock(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetEventLogTimestampClock(struct soap*, struct __emi__GetEventLogTimestampClock*); +SOAP_FMAC3 struct __emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_instantiate___emi__GetEventLogTimestampClock(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetEventLogTimestampClock(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__SetEventLogTimestampClock +#define SOAP_TYPE___emi__SetEventLogTimestampClock (1045) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__SetEventLogTimestampClock(struct soap*, const struct __emi__SetEventLogTimestampClock *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__SetEventLogTimestampClock(struct soap*, struct __emi__SetEventLogTimestampClock *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__SetEventLogTimestampClock(struct soap*, const struct __emi__SetEventLogTimestampClock *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__SetEventLogTimestampClock(struct soap*, const char*, int, const struct __emi__SetEventLogTimestampClock *, const char*); +SOAP_FMAC3 struct __emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_get___emi__SetEventLogTimestampClock(struct soap*, struct __emi__SetEventLogTimestampClock *, const char*, const char*); +SOAP_FMAC3 struct __emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_in___emi__SetEventLogTimestampClock(struct soap*, const char*, struct __emi__SetEventLogTimestampClock *, const char*); +SOAP_FMAC5 struct __emi__SetEventLogTimestampClock * SOAP_FMAC6 soap_new___emi__SetEventLogTimestampClock(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__SetEventLogTimestampClock(struct soap*, struct __emi__SetEventLogTimestampClock*); +SOAP_FMAC3 struct __emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_instantiate___emi__SetEventLogTimestampClock(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__SetEventLogTimestampClock(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__FreezeEventLog +#define SOAP_TYPE___emi__FreezeEventLog (1041) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__FreezeEventLog(struct soap*, const struct __emi__FreezeEventLog *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__FreezeEventLog(struct soap*, struct __emi__FreezeEventLog *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__FreezeEventLog(struct soap*, const struct __emi__FreezeEventLog *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__FreezeEventLog(struct soap*, const char*, int, const struct __emi__FreezeEventLog *, const char*); +SOAP_FMAC3 struct __emi__FreezeEventLog * SOAP_FMAC4 soap_get___emi__FreezeEventLog(struct soap*, struct __emi__FreezeEventLog *, const char*, const char*); +SOAP_FMAC3 struct __emi__FreezeEventLog * SOAP_FMAC4 soap_in___emi__FreezeEventLog(struct soap*, const char*, struct __emi__FreezeEventLog *, const char*); +SOAP_FMAC5 struct __emi__FreezeEventLog * SOAP_FMAC6 soap_new___emi__FreezeEventLog(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__FreezeEventLog(struct soap*, struct __emi__FreezeEventLog*); +SOAP_FMAC3 struct __emi__FreezeEventLog * SOAP_FMAC4 soap_instantiate___emi__FreezeEventLog(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__FreezeEventLog(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__ClearEventLog +#define SOAP_TYPE___emi__ClearEventLog (1037) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__ClearEventLog(struct soap*, const struct __emi__ClearEventLog *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__ClearEventLog(struct soap*, struct __emi__ClearEventLog *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__ClearEventLog(struct soap*, const struct __emi__ClearEventLog *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__ClearEventLog(struct soap*, const char*, int, const struct __emi__ClearEventLog *, const char*); +SOAP_FMAC3 struct __emi__ClearEventLog * SOAP_FMAC4 soap_get___emi__ClearEventLog(struct soap*, struct __emi__ClearEventLog *, const char*, const char*); +SOAP_FMAC3 struct __emi__ClearEventLog * SOAP_FMAC4 soap_in___emi__ClearEventLog(struct soap*, const char*, struct __emi__ClearEventLog *, const char*); +SOAP_FMAC5 struct __emi__ClearEventLog * SOAP_FMAC6 soap_new___emi__ClearEventLog(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__ClearEventLog(struct soap*, struct __emi__ClearEventLog*); +SOAP_FMAC3 struct __emi__ClearEventLog * SOAP_FMAC4 soap_instantiate___emi__ClearEventLog(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__ClearEventLog(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__ReadEventLogRecords +#define SOAP_TYPE___emi__ReadEventLogRecords (1033) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__ReadEventLogRecords(struct soap*, const struct __emi__ReadEventLogRecords *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__ReadEventLogRecords(struct soap*, struct __emi__ReadEventLogRecords *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__ReadEventLogRecords(struct soap*, const struct __emi__ReadEventLogRecords *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__ReadEventLogRecords(struct soap*, const char*, int, const struct __emi__ReadEventLogRecords *, const char*); +SOAP_FMAC3 struct __emi__ReadEventLogRecords * SOAP_FMAC4 soap_get___emi__ReadEventLogRecords(struct soap*, struct __emi__ReadEventLogRecords *, const char*, const char*); +SOAP_FMAC3 struct __emi__ReadEventLogRecords * SOAP_FMAC4 soap_in___emi__ReadEventLogRecords(struct soap*, const char*, struct __emi__ReadEventLogRecords *, const char*); +SOAP_FMAC5 struct __emi__ReadEventLogRecords * SOAP_FMAC6 soap_new___emi__ReadEventLogRecords(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__ReadEventLogRecords(struct soap*, struct __emi__ReadEventLogRecords*); +SOAP_FMAC3 struct __emi__ReadEventLogRecords * SOAP_FMAC4 soap_instantiate___emi__ReadEventLogRecords(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__ReadEventLogRecords(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__GetEventLogStatus +#define SOAP_TYPE___emi__GetEventLogStatus (1029) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetEventLogStatus(struct soap*, const struct __emi__GetEventLogStatus *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetEventLogStatus(struct soap*, struct __emi__GetEventLogStatus *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetEventLogStatus(struct soap*, const struct __emi__GetEventLogStatus *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetEventLogStatus(struct soap*, const char*, int, const struct __emi__GetEventLogStatus *, const char*); +SOAP_FMAC3 struct __emi__GetEventLogStatus * SOAP_FMAC4 soap_get___emi__GetEventLogStatus(struct soap*, struct __emi__GetEventLogStatus *, const char*, const char*); +SOAP_FMAC3 struct __emi__GetEventLogStatus * SOAP_FMAC4 soap_in___emi__GetEventLogStatus(struct soap*, const char*, struct __emi__GetEventLogStatus *, const char*); +SOAP_FMAC5 struct __emi__GetEventLogStatus * SOAP_FMAC6 soap_new___emi__GetEventLogStatus(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetEventLogStatus(struct soap*, struct __emi__GetEventLogStatus*); +SOAP_FMAC3 struct __emi__GetEventLogStatus * SOAP_FMAC4 soap_instantiate___emi__GetEventLogStatus(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetEventLogStatus(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__RemoveEventFilter +#define SOAP_TYPE___emi__RemoveEventFilter (1025) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__RemoveEventFilter(struct soap*, const struct __emi__RemoveEventFilter *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__RemoveEventFilter(struct soap*, struct __emi__RemoveEventFilter *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__RemoveEventFilter(struct soap*, const struct __emi__RemoveEventFilter *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__RemoveEventFilter(struct soap*, const char*, int, const struct __emi__RemoveEventFilter *, const char*); +SOAP_FMAC3 struct __emi__RemoveEventFilter * SOAP_FMAC4 soap_get___emi__RemoveEventFilter(struct soap*, struct __emi__RemoveEventFilter *, const char*, const char*); +SOAP_FMAC3 struct __emi__RemoveEventFilter * SOAP_FMAC4 soap_in___emi__RemoveEventFilter(struct soap*, const char*, struct __emi__RemoveEventFilter *, const char*); +SOAP_FMAC5 struct __emi__RemoveEventFilter * SOAP_FMAC6 soap_new___emi__RemoveEventFilter(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__RemoveEventFilter(struct soap*, struct __emi__RemoveEventFilter*); +SOAP_FMAC3 struct __emi__RemoveEventFilter * SOAP_FMAC4 soap_instantiate___emi__RemoveEventFilter(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__RemoveEventFilter(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__UpdateEventFilter +#define SOAP_TYPE___emi__UpdateEventFilter (1021) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__UpdateEventFilter(struct soap*, const struct __emi__UpdateEventFilter *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__UpdateEventFilter(struct soap*, struct __emi__UpdateEventFilter *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__UpdateEventFilter(struct soap*, const struct __emi__UpdateEventFilter *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__UpdateEventFilter(struct soap*, const char*, int, const struct __emi__UpdateEventFilter *, const char*); +SOAP_FMAC3 struct __emi__UpdateEventFilter * SOAP_FMAC4 soap_get___emi__UpdateEventFilter(struct soap*, struct __emi__UpdateEventFilter *, const char*, const char*); +SOAP_FMAC3 struct __emi__UpdateEventFilter * SOAP_FMAC4 soap_in___emi__UpdateEventFilter(struct soap*, const char*, struct __emi__UpdateEventFilter *, const char*); +SOAP_FMAC5 struct __emi__UpdateEventFilter * SOAP_FMAC6 soap_new___emi__UpdateEventFilter(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__UpdateEventFilter(struct soap*, struct __emi__UpdateEventFilter*); +SOAP_FMAC3 struct __emi__UpdateEventFilter * SOAP_FMAC4 soap_instantiate___emi__UpdateEventFilter(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__UpdateEventFilter(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__GetEventFilter +#define SOAP_TYPE___emi__GetEventFilter (1017) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetEventFilter(struct soap*, const struct __emi__GetEventFilter *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetEventFilter(struct soap*, struct __emi__GetEventFilter *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetEventFilter(struct soap*, const struct __emi__GetEventFilter *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetEventFilter(struct soap*, const char*, int, const struct __emi__GetEventFilter *, const char*); +SOAP_FMAC3 struct __emi__GetEventFilter * SOAP_FMAC4 soap_get___emi__GetEventFilter(struct soap*, struct __emi__GetEventFilter *, const char*, const char*); +SOAP_FMAC3 struct __emi__GetEventFilter * SOAP_FMAC4 soap_in___emi__GetEventFilter(struct soap*, const char*, struct __emi__GetEventFilter *, const char*); +SOAP_FMAC5 struct __emi__GetEventFilter * SOAP_FMAC6 soap_new___emi__GetEventFilter(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetEventFilter(struct soap*, struct __emi__GetEventFilter*); +SOAP_FMAC3 struct __emi__GetEventFilter * SOAP_FMAC4 soap_instantiate___emi__GetEventFilter(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetEventFilter(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__CancelAlertSubscription +#define SOAP_TYPE___emi__CancelAlertSubscription (1013) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__CancelAlertSubscription(struct soap*, const struct __emi__CancelAlertSubscription *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__CancelAlertSubscription(struct soap*, struct __emi__CancelAlertSubscription *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__CancelAlertSubscription(struct soap*, const struct __emi__CancelAlertSubscription *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__CancelAlertSubscription(struct soap*, const char*, int, const struct __emi__CancelAlertSubscription *, const char*); +SOAP_FMAC3 struct __emi__CancelAlertSubscription * SOAP_FMAC4 soap_get___emi__CancelAlertSubscription(struct soap*, struct __emi__CancelAlertSubscription *, const char*, const char*); +SOAP_FMAC3 struct __emi__CancelAlertSubscription * SOAP_FMAC4 soap_in___emi__CancelAlertSubscription(struct soap*, const char*, struct __emi__CancelAlertSubscription *, const char*); +SOAP_FMAC5 struct __emi__CancelAlertSubscription * SOAP_FMAC6 soap_new___emi__CancelAlertSubscription(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__CancelAlertSubscription(struct soap*, struct __emi__CancelAlertSubscription*); +SOAP_FMAC3 struct __emi__CancelAlertSubscription * SOAP_FMAC4 soap_instantiate___emi__CancelAlertSubscription(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__CancelAlertSubscription(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__EnumerateAlertPolicies +#define SOAP_TYPE___emi__EnumerateAlertPolicies (1009) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateAlertPolicies(struct soap*, const struct __emi__EnumerateAlertPolicies *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateAlertPolicies(struct soap*, struct __emi__EnumerateAlertPolicies *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateAlertPolicies(struct soap*, const struct __emi__EnumerateAlertPolicies *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateAlertPolicies(struct soap*, const char*, int, const struct __emi__EnumerateAlertPolicies *, const char*); +SOAP_FMAC3 struct __emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_get___emi__EnumerateAlertPolicies(struct soap*, struct __emi__EnumerateAlertPolicies *, const char*, const char*); +SOAP_FMAC3 struct __emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_in___emi__EnumerateAlertPolicies(struct soap*, const char*, struct __emi__EnumerateAlertPolicies *, const char*); +SOAP_FMAC5 struct __emi__EnumerateAlertPolicies * SOAP_FMAC6 soap_new___emi__EnumerateAlertPolicies(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateAlertPolicies(struct soap*, struct __emi__EnumerateAlertPolicies*); +SOAP_FMAC3 struct __emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_instantiate___emi__EnumerateAlertPolicies(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateAlertPolicies(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__EnumerateAlertSubscriptions +#define SOAP_TYPE___emi__EnumerateAlertSubscriptions (1005) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateAlertSubscriptions(struct soap*, const struct __emi__EnumerateAlertSubscriptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateAlertSubscriptions(struct soap*, struct __emi__EnumerateAlertSubscriptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateAlertSubscriptions(struct soap*, const struct __emi__EnumerateAlertSubscriptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateAlertSubscriptions(struct soap*, const char*, int, const struct __emi__EnumerateAlertSubscriptions *, const char*); +SOAP_FMAC3 struct __emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_get___emi__EnumerateAlertSubscriptions(struct soap*, struct __emi__EnumerateAlertSubscriptions *, const char*, const char*); +SOAP_FMAC3 struct __emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_in___emi__EnumerateAlertSubscriptions(struct soap*, const char*, struct __emi__EnumerateAlertSubscriptions *, const char*); +SOAP_FMAC5 struct __emi__EnumerateAlertSubscriptions * SOAP_FMAC6 soap_new___emi__EnumerateAlertSubscriptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateAlertSubscriptions(struct soap*, struct __emi__EnumerateAlertSubscriptions*); +SOAP_FMAC3 struct __emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_instantiate___emi__EnumerateAlertSubscriptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateAlertSubscriptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__SubscribeForAlert +#define SOAP_TYPE___emi__SubscribeForAlert (1001) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__SubscribeForAlert(struct soap*, const struct __emi__SubscribeForAlert *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__SubscribeForAlert(struct soap*, struct __emi__SubscribeForAlert *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__SubscribeForAlert(struct soap*, const struct __emi__SubscribeForAlert *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__SubscribeForAlert(struct soap*, const char*, int, const struct __emi__SubscribeForAlert *, const char*); +SOAP_FMAC3 struct __emi__SubscribeForAlert * SOAP_FMAC4 soap_get___emi__SubscribeForAlert(struct soap*, struct __emi__SubscribeForAlert *, const char*, const char*); +SOAP_FMAC3 struct __emi__SubscribeForAlert * SOAP_FMAC4 soap_in___emi__SubscribeForAlert(struct soap*, const char*, struct __emi__SubscribeForAlert *, const char*); +SOAP_FMAC5 struct __emi__SubscribeForAlert * SOAP_FMAC6 soap_new___emi__SubscribeForAlert(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__SubscribeForAlert(struct soap*, struct __emi__SubscribeForAlert*); +SOAP_FMAC3 struct __emi__SubscribeForAlert * SOAP_FMAC4 soap_instantiate___emi__SubscribeForAlert(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__SubscribeForAlert(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__AddEventFilter +#define SOAP_TYPE___emi__AddEventFilter (997) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__AddEventFilter(struct soap*, const struct __emi__AddEventFilter *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__AddEventFilter(struct soap*, struct __emi__AddEventFilter *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__AddEventFilter(struct soap*, const struct __emi__AddEventFilter *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__AddEventFilter(struct soap*, const char*, int, const struct __emi__AddEventFilter *, const char*); +SOAP_FMAC3 struct __emi__AddEventFilter * SOAP_FMAC4 soap_get___emi__AddEventFilter(struct soap*, struct __emi__AddEventFilter *, const char*, const char*); +SOAP_FMAC3 struct __emi__AddEventFilter * SOAP_FMAC4 soap_in___emi__AddEventFilter(struct soap*, const char*, struct __emi__AddEventFilter *, const char*); +SOAP_FMAC5 struct __emi__AddEventFilter * SOAP_FMAC6 soap_new___emi__AddEventFilter(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__AddEventFilter(struct soap*, struct __emi__AddEventFilter*); +SOAP_FMAC3 struct __emi__AddEventFilter * SOAP_FMAC4 soap_instantiate___emi__AddEventFilter(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__AddEventFilter(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__GetAlertCommunityString +#define SOAP_TYPE___emi__GetAlertCommunityString (993) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetAlertCommunityString(struct soap*, const struct __emi__GetAlertCommunityString *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetAlertCommunityString(struct soap*, struct __emi__GetAlertCommunityString *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetAlertCommunityString(struct soap*, const struct __emi__GetAlertCommunityString *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetAlertCommunityString(struct soap*, const char*, int, const struct __emi__GetAlertCommunityString *, const char*); +SOAP_FMAC3 struct __emi__GetAlertCommunityString * SOAP_FMAC4 soap_get___emi__GetAlertCommunityString(struct soap*, struct __emi__GetAlertCommunityString *, const char*, const char*); +SOAP_FMAC3 struct __emi__GetAlertCommunityString * SOAP_FMAC4 soap_in___emi__GetAlertCommunityString(struct soap*, const char*, struct __emi__GetAlertCommunityString *, const char*); +SOAP_FMAC5 struct __emi__GetAlertCommunityString * SOAP_FMAC6 soap_new___emi__GetAlertCommunityString(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetAlertCommunityString(struct soap*, struct __emi__GetAlertCommunityString*); +SOAP_FMAC3 struct __emi__GetAlertCommunityString * SOAP_FMAC4 soap_instantiate___emi__GetAlertCommunityString(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetAlertCommunityString(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__SetAlertCommunityString +#define SOAP_TYPE___emi__SetAlertCommunityString (989) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__SetAlertCommunityString(struct soap*, const struct __emi__SetAlertCommunityString *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__SetAlertCommunityString(struct soap*, struct __emi__SetAlertCommunityString *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__SetAlertCommunityString(struct soap*, const struct __emi__SetAlertCommunityString *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__SetAlertCommunityString(struct soap*, const char*, int, const struct __emi__SetAlertCommunityString *, const char*); +SOAP_FMAC3 struct __emi__SetAlertCommunityString * SOAP_FMAC4 soap_get___emi__SetAlertCommunityString(struct soap*, struct __emi__SetAlertCommunityString *, const char*, const char*); +SOAP_FMAC3 struct __emi__SetAlertCommunityString * SOAP_FMAC4 soap_in___emi__SetAlertCommunityString(struct soap*, const char*, struct __emi__SetAlertCommunityString *, const char*); +SOAP_FMAC5 struct __emi__SetAlertCommunityString * SOAP_FMAC6 soap_new___emi__SetAlertCommunityString(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__SetAlertCommunityString(struct soap*, struct __emi__SetAlertCommunityString*); +SOAP_FMAC3 struct __emi__SetAlertCommunityString * SOAP_FMAC4 soap_instantiate___emi__SetAlertCommunityString(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__SetAlertCommunityString(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__GetAlertSubscription +#define SOAP_TYPE___emi__GetAlertSubscription (985) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetAlertSubscription(struct soap*, const struct __emi__GetAlertSubscription *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetAlertSubscription(struct soap*, struct __emi__GetAlertSubscription *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetAlertSubscription(struct soap*, const struct __emi__GetAlertSubscription *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetAlertSubscription(struct soap*, const char*, int, const struct __emi__GetAlertSubscription *, const char*); +SOAP_FMAC3 struct __emi__GetAlertSubscription * SOAP_FMAC4 soap_get___emi__GetAlertSubscription(struct soap*, struct __emi__GetAlertSubscription *, const char*, const char*); +SOAP_FMAC3 struct __emi__GetAlertSubscription * SOAP_FMAC4 soap_in___emi__GetAlertSubscription(struct soap*, const char*, struct __emi__GetAlertSubscription *, const char*); +SOAP_FMAC5 struct __emi__GetAlertSubscription * SOAP_FMAC6 soap_new___emi__GetAlertSubscription(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetAlertSubscription(struct soap*, struct __emi__GetAlertSubscription*); +SOAP_FMAC3 struct __emi__GetAlertSubscription * SOAP_FMAC4 soap_instantiate___emi__GetAlertSubscription(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetAlertSubscription(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___emi__EnumerateEventFilters +#define SOAP_TYPE___emi__EnumerateEventFilters (981) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateEventFilters(struct soap*, const struct __emi__EnumerateEventFilters *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateEventFilters(struct soap*, struct __emi__EnumerateEventFilters *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateEventFilters(struct soap*, const struct __emi__EnumerateEventFilters *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateEventFilters(struct soap*, const char*, int, const struct __emi__EnumerateEventFilters *, const char*); +SOAP_FMAC3 struct __emi__EnumerateEventFilters * SOAP_FMAC4 soap_get___emi__EnumerateEventFilters(struct soap*, struct __emi__EnumerateEventFilters *, const char*, const char*); +SOAP_FMAC3 struct __emi__EnumerateEventFilters * SOAP_FMAC4 soap_in___emi__EnumerateEventFilters(struct soap*, const char*, struct __emi__EnumerateEventFilters *, const char*); +SOAP_FMAC5 struct __emi__EnumerateEventFilters * SOAP_FMAC6 soap_new___emi__EnumerateEventFilters(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateEventFilters(struct soap*, struct __emi__EnumerateEventFilters*); +SOAP_FMAC3 struct __emi__EnumerateEventFilters * SOAP_FMAC4 soap_instantiate___emi__EnumerateEventFilters(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateEventFilters(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__GetHcbState +#define SOAP_TYPE___cb__GetHcbState (977) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__GetHcbState(struct soap*, const struct __cb__GetHcbState *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__GetHcbState(struct soap*, struct __cb__GetHcbState *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__GetHcbState(struct soap*, const struct __cb__GetHcbState *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__GetHcbState(struct soap*, const char*, int, const struct __cb__GetHcbState *, const char*); +SOAP_FMAC3 struct __cb__GetHcbState * SOAP_FMAC4 soap_get___cb__GetHcbState(struct soap*, struct __cb__GetHcbState *, const char*, const char*); +SOAP_FMAC3 struct __cb__GetHcbState * SOAP_FMAC4 soap_in___cb__GetHcbState(struct soap*, const char*, struct __cb__GetHcbState *, const char*); +SOAP_FMAC5 struct __cb__GetHcbState * SOAP_FMAC6 soap_new___cb__GetHcbState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__GetHcbState(struct soap*, struct __cb__GetHcbState*); +SOAP_FMAC3 struct __cb__GetHcbState * SOAP_FMAC4 soap_instantiate___cb__GetHcbState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__GetHcbState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__ClearHcbState +#define SOAP_TYPE___cb__ClearHcbState (973) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__ClearHcbState(struct soap*, const struct __cb__ClearHcbState *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__ClearHcbState(struct soap*, struct __cb__ClearHcbState *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__ClearHcbState(struct soap*, const struct __cb__ClearHcbState *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__ClearHcbState(struct soap*, const char*, int, const struct __cb__ClearHcbState *, const char*); +SOAP_FMAC3 struct __cb__ClearHcbState * SOAP_FMAC4 soap_get___cb__ClearHcbState(struct soap*, struct __cb__ClearHcbState *, const char*, const char*); +SOAP_FMAC3 struct __cb__ClearHcbState * SOAP_FMAC4 soap_in___cb__ClearHcbState(struct soap*, const char*, struct __cb__ClearHcbState *, const char*); +SOAP_FMAC5 struct __cb__ClearHcbState * SOAP_FMAC6 soap_new___cb__ClearHcbState(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__ClearHcbState(struct soap*, struct __cb__ClearHcbState*); +SOAP_FMAC3 struct __cb__ClearHcbState * SOAP_FMAC4 soap_instantiate___cb__ClearHcbState(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__ClearHcbState(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__GetHcbOptions +#define SOAP_TYPE___cb__GetHcbOptions (969) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__GetHcbOptions(struct soap*, const struct __cb__GetHcbOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__GetHcbOptions(struct soap*, struct __cb__GetHcbOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__GetHcbOptions(struct soap*, const struct __cb__GetHcbOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__GetHcbOptions(struct soap*, const char*, int, const struct __cb__GetHcbOptions *, const char*); +SOAP_FMAC3 struct __cb__GetHcbOptions * SOAP_FMAC4 soap_get___cb__GetHcbOptions(struct soap*, struct __cb__GetHcbOptions *, const char*, const char*); +SOAP_FMAC3 struct __cb__GetHcbOptions * SOAP_FMAC4 soap_in___cb__GetHcbOptions(struct soap*, const char*, struct __cb__GetHcbOptions *, const char*); +SOAP_FMAC5 struct __cb__GetHcbOptions * SOAP_FMAC6 soap_new___cb__GetHcbOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__GetHcbOptions(struct soap*, struct __cb__GetHcbOptions*); +SOAP_FMAC3 struct __cb__GetHcbOptions * SOAP_FMAC4 soap_instantiate___cb__GetHcbOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__GetHcbOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__SetHcbOptions +#define SOAP_TYPE___cb__SetHcbOptions (965) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__SetHcbOptions(struct soap*, const struct __cb__SetHcbOptions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__SetHcbOptions(struct soap*, struct __cb__SetHcbOptions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__SetHcbOptions(struct soap*, const struct __cb__SetHcbOptions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__SetHcbOptions(struct soap*, const char*, int, const struct __cb__SetHcbOptions *, const char*); +SOAP_FMAC3 struct __cb__SetHcbOptions * SOAP_FMAC4 soap_get___cb__SetHcbOptions(struct soap*, struct __cb__SetHcbOptions *, const char*, const char*); +SOAP_FMAC3 struct __cb__SetHcbOptions * SOAP_FMAC4 soap_in___cb__SetHcbOptions(struct soap*, const char*, struct __cb__SetHcbOptions *, const char*); +SOAP_FMAC5 struct __cb__SetHcbOptions * SOAP_FMAC6 soap_new___cb__SetHcbOptions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__SetHcbOptions(struct soap*, struct __cb__SetHcbOptions*); +SOAP_FMAC3 struct __cb__SetHcbOptions * SOAP_FMAC4 soap_instantiate___cb__SetHcbOptions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__SetHcbOptions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbQueryCapabilities +#define SOAP_TYPE___cb__CbQueryCapabilities (961) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbQueryCapabilities(struct soap*, const struct __cb__CbQueryCapabilities *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbQueryCapabilities(struct soap*, struct __cb__CbQueryCapabilities *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbQueryCapabilities(struct soap*, const struct __cb__CbQueryCapabilities *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbQueryCapabilities(struct soap*, const char*, int, const struct __cb__CbQueryCapabilities *, const char*); +SOAP_FMAC3 struct __cb__CbQueryCapabilities * SOAP_FMAC4 soap_get___cb__CbQueryCapabilities(struct soap*, struct __cb__CbQueryCapabilities *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbQueryCapabilities * SOAP_FMAC4 soap_in___cb__CbQueryCapabilities(struct soap*, const char*, struct __cb__CbQueryCapabilities *, const char*); +SOAP_FMAC5 struct __cb__CbQueryCapabilities * SOAP_FMAC6 soap_new___cb__CbQueryCapabilities(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbQueryCapabilities(struct soap*, struct __cb__CbQueryCapabilities*); +SOAP_FMAC3 struct __cb__CbQueryCapabilities * SOAP_FMAC4 soap_instantiate___cb__CbQueryCapabilities(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbQueryCapabilities(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbFilterEnumerate +#define SOAP_TYPE___cb__CbFilterEnumerate (957) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbFilterEnumerate(struct soap*, const struct __cb__CbFilterEnumerate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbFilterEnumerate(struct soap*, struct __cb__CbFilterEnumerate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbFilterEnumerate(struct soap*, const struct __cb__CbFilterEnumerate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbFilterEnumerate(struct soap*, const char*, int, const struct __cb__CbFilterEnumerate *, const char*); +SOAP_FMAC3 struct __cb__CbFilterEnumerate * SOAP_FMAC4 soap_get___cb__CbFilterEnumerate(struct soap*, struct __cb__CbFilterEnumerate *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbFilterEnumerate * SOAP_FMAC4 soap_in___cb__CbFilterEnumerate(struct soap*, const char*, struct __cb__CbFilterEnumerate *, const char*); +SOAP_FMAC5 struct __cb__CbFilterEnumerate * SOAP_FMAC6 soap_new___cb__CbFilterEnumerate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbFilterEnumerate(struct soap*, struct __cb__CbFilterEnumerate*); +SOAP_FMAC3 struct __cb__CbFilterEnumerate * SOAP_FMAC4 soap_instantiate___cb__CbFilterEnumerate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbFilterEnumerate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbFilterDelete +#define SOAP_TYPE___cb__CbFilterDelete (953) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbFilterDelete(struct soap*, const struct __cb__CbFilterDelete *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbFilterDelete(struct soap*, struct __cb__CbFilterDelete *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbFilterDelete(struct soap*, const struct __cb__CbFilterDelete *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbFilterDelete(struct soap*, const char*, int, const struct __cb__CbFilterDelete *, const char*); +SOAP_FMAC3 struct __cb__CbFilterDelete * SOAP_FMAC4 soap_get___cb__CbFilterDelete(struct soap*, struct __cb__CbFilterDelete *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbFilterDelete * SOAP_FMAC4 soap_in___cb__CbFilterDelete(struct soap*, const char*, struct __cb__CbFilterDelete *, const char*); +SOAP_FMAC5 struct __cb__CbFilterDelete * SOAP_FMAC6 soap_new___cb__CbFilterDelete(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbFilterDelete(struct soap*, struct __cb__CbFilterDelete*); +SOAP_FMAC3 struct __cb__CbFilterDelete * SOAP_FMAC4 soap_instantiate___cb__CbFilterDelete(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbFilterDelete(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbFilterGet +#define SOAP_TYPE___cb__CbFilterGet (949) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbFilterGet(struct soap*, const struct __cb__CbFilterGet *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbFilterGet(struct soap*, struct __cb__CbFilterGet *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbFilterGet(struct soap*, const struct __cb__CbFilterGet *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbFilterGet(struct soap*, const char*, int, const struct __cb__CbFilterGet *, const char*); +SOAP_FMAC3 struct __cb__CbFilterGet * SOAP_FMAC4 soap_get___cb__CbFilterGet(struct soap*, struct __cb__CbFilterGet *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbFilterGet * SOAP_FMAC4 soap_in___cb__CbFilterGet(struct soap*, const char*, struct __cb__CbFilterGet *, const char*); +SOAP_FMAC5 struct __cb__CbFilterGet * SOAP_FMAC6 soap_new___cb__CbFilterGet(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbFilterGet(struct soap*, struct __cb__CbFilterGet*); +SOAP_FMAC3 struct __cb__CbFilterGet * SOAP_FMAC4 soap_instantiate___cb__CbFilterGet(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbFilterGet(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbFilterCreate +#define SOAP_TYPE___cb__CbFilterCreate (945) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbFilterCreate(struct soap*, const struct __cb__CbFilterCreate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbFilterCreate(struct soap*, struct __cb__CbFilterCreate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbFilterCreate(struct soap*, const struct __cb__CbFilterCreate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbFilterCreate(struct soap*, const char*, int, const struct __cb__CbFilterCreate *, const char*); +SOAP_FMAC3 struct __cb__CbFilterCreate * SOAP_FMAC4 soap_get___cb__CbFilterCreate(struct soap*, struct __cb__CbFilterCreate *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbFilterCreate * SOAP_FMAC4 soap_in___cb__CbFilterCreate(struct soap*, const char*, struct __cb__CbFilterCreate *, const char*); +SOAP_FMAC5 struct __cb__CbFilterCreate * SOAP_FMAC6 soap_new___cb__CbFilterCreate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbFilterCreate(struct soap*, struct __cb__CbFilterCreate*); +SOAP_FMAC3 struct __cb__CbFilterCreate * SOAP_FMAC4 soap_instantiate___cb__CbFilterCreate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbFilterCreate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbPolicyGetActiveStatistics +#define SOAP_TYPE___cb__CbPolicyGetActiveStatistics (941) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyGetActiveStatistics(struct soap*, const struct __cb__CbPolicyGetActiveStatistics *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyGetActiveStatistics(struct soap*, struct __cb__CbPolicyGetActiveStatistics *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyGetActiveStatistics(struct soap*, const struct __cb__CbPolicyGetActiveStatistics *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyGetActiveStatistics(struct soap*, const char*, int, const struct __cb__CbPolicyGetActiveStatistics *, const char*); +SOAP_FMAC3 struct __cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_get___cb__CbPolicyGetActiveStatistics(struct soap*, struct __cb__CbPolicyGetActiveStatistics *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_in___cb__CbPolicyGetActiveStatistics(struct soap*, const char*, struct __cb__CbPolicyGetActiveStatistics *, const char*); +SOAP_FMAC5 struct __cb__CbPolicyGetActiveStatistics * SOAP_FMAC6 soap_new___cb__CbPolicyGetActiveStatistics(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyGetActiveStatistics(struct soap*, struct __cb__CbPolicyGetActiveStatistics*); +SOAP_FMAC3 struct __cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_instantiate___cb__CbPolicyGetActiveStatistics(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyGetActiveStatistics(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbPolicyGetEnabled +#define SOAP_TYPE___cb__CbPolicyGetEnabled (937) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyGetEnabled(struct soap*, const struct __cb__CbPolicyGetEnabled *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyGetEnabled(struct soap*, struct __cb__CbPolicyGetEnabled *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyGetEnabled(struct soap*, const struct __cb__CbPolicyGetEnabled *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyGetEnabled(struct soap*, const char*, int, const struct __cb__CbPolicyGetEnabled *, const char*); +SOAP_FMAC3 struct __cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_get___cb__CbPolicyGetEnabled(struct soap*, struct __cb__CbPolicyGetEnabled *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_in___cb__CbPolicyGetEnabled(struct soap*, const char*, struct __cb__CbPolicyGetEnabled *, const char*); +SOAP_FMAC5 struct __cb__CbPolicyGetEnabled * SOAP_FMAC6 soap_new___cb__CbPolicyGetEnabled(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyGetEnabled(struct soap*, struct __cb__CbPolicyGetEnabled*); +SOAP_FMAC3 struct __cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_instantiate___cb__CbPolicyGetEnabled(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyGetEnabled(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbPolicyDisable +#define SOAP_TYPE___cb__CbPolicyDisable (933) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyDisable(struct soap*, const struct __cb__CbPolicyDisable *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyDisable(struct soap*, struct __cb__CbPolicyDisable *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyDisable(struct soap*, const struct __cb__CbPolicyDisable *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyDisable(struct soap*, const char*, int, const struct __cb__CbPolicyDisable *, const char*); +SOAP_FMAC3 struct __cb__CbPolicyDisable * SOAP_FMAC4 soap_get___cb__CbPolicyDisable(struct soap*, struct __cb__CbPolicyDisable *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbPolicyDisable * SOAP_FMAC4 soap_in___cb__CbPolicyDisable(struct soap*, const char*, struct __cb__CbPolicyDisable *, const char*); +SOAP_FMAC5 struct __cb__CbPolicyDisable * SOAP_FMAC6 soap_new___cb__CbPolicyDisable(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyDisable(struct soap*, struct __cb__CbPolicyDisable*); +SOAP_FMAC3 struct __cb__CbPolicyDisable * SOAP_FMAC4 soap_instantiate___cb__CbPolicyDisable(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyDisable(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbPolicyEnable +#define SOAP_TYPE___cb__CbPolicyEnable (929) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyEnable(struct soap*, const struct __cb__CbPolicyEnable *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyEnable(struct soap*, struct __cb__CbPolicyEnable *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyEnable(struct soap*, const struct __cb__CbPolicyEnable *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyEnable(struct soap*, const char*, int, const struct __cb__CbPolicyEnable *, const char*); +SOAP_FMAC3 struct __cb__CbPolicyEnable * SOAP_FMAC4 soap_get___cb__CbPolicyEnable(struct soap*, struct __cb__CbPolicyEnable *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbPolicyEnable * SOAP_FMAC4 soap_in___cb__CbPolicyEnable(struct soap*, const char*, struct __cb__CbPolicyEnable *, const char*); +SOAP_FMAC5 struct __cb__CbPolicyEnable * SOAP_FMAC6 soap_new___cb__CbPolicyEnable(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyEnable(struct soap*, struct __cb__CbPolicyEnable*); +SOAP_FMAC3 struct __cb__CbPolicyEnable * SOAP_FMAC4 soap_instantiate___cb__CbPolicyEnable(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyEnable(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbPolicyEnumerate +#define SOAP_TYPE___cb__CbPolicyEnumerate (925) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyEnumerate(struct soap*, const struct __cb__CbPolicyEnumerate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyEnumerate(struct soap*, struct __cb__CbPolicyEnumerate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyEnumerate(struct soap*, const struct __cb__CbPolicyEnumerate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyEnumerate(struct soap*, const char*, int, const struct __cb__CbPolicyEnumerate *, const char*); +SOAP_FMAC3 struct __cb__CbPolicyEnumerate * SOAP_FMAC4 soap_get___cb__CbPolicyEnumerate(struct soap*, struct __cb__CbPolicyEnumerate *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbPolicyEnumerate * SOAP_FMAC4 soap_in___cb__CbPolicyEnumerate(struct soap*, const char*, struct __cb__CbPolicyEnumerate *, const char*); +SOAP_FMAC5 struct __cb__CbPolicyEnumerate * SOAP_FMAC6 soap_new___cb__CbPolicyEnumerate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyEnumerate(struct soap*, struct __cb__CbPolicyEnumerate*); +SOAP_FMAC3 struct __cb__CbPolicyEnumerate * SOAP_FMAC4 soap_instantiate___cb__CbPolicyEnumerate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyEnumerate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbPolicyDelete +#define SOAP_TYPE___cb__CbPolicyDelete (921) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyDelete(struct soap*, const struct __cb__CbPolicyDelete *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyDelete(struct soap*, struct __cb__CbPolicyDelete *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyDelete(struct soap*, const struct __cb__CbPolicyDelete *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyDelete(struct soap*, const char*, int, const struct __cb__CbPolicyDelete *, const char*); +SOAP_FMAC3 struct __cb__CbPolicyDelete * SOAP_FMAC4 soap_get___cb__CbPolicyDelete(struct soap*, struct __cb__CbPolicyDelete *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbPolicyDelete * SOAP_FMAC4 soap_in___cb__CbPolicyDelete(struct soap*, const char*, struct __cb__CbPolicyDelete *, const char*); +SOAP_FMAC5 struct __cb__CbPolicyDelete * SOAP_FMAC6 soap_new___cb__CbPolicyDelete(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyDelete(struct soap*, struct __cb__CbPolicyDelete*); +SOAP_FMAC3 struct __cb__CbPolicyDelete * SOAP_FMAC4 soap_instantiate___cb__CbPolicyDelete(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyDelete(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbPolicyGet +#define SOAP_TYPE___cb__CbPolicyGet (917) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyGet(struct soap*, const struct __cb__CbPolicyGet *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyGet(struct soap*, struct __cb__CbPolicyGet *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyGet(struct soap*, const struct __cb__CbPolicyGet *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyGet(struct soap*, const char*, int, const struct __cb__CbPolicyGet *, const char*); +SOAP_FMAC3 struct __cb__CbPolicyGet * SOAP_FMAC4 soap_get___cb__CbPolicyGet(struct soap*, struct __cb__CbPolicyGet *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbPolicyGet * SOAP_FMAC4 soap_in___cb__CbPolicyGet(struct soap*, const char*, struct __cb__CbPolicyGet *, const char*); +SOAP_FMAC5 struct __cb__CbPolicyGet * SOAP_FMAC6 soap_new___cb__CbPolicyGet(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyGet(struct soap*, struct __cb__CbPolicyGet*); +SOAP_FMAC3 struct __cb__CbPolicyGet * SOAP_FMAC4 soap_instantiate___cb__CbPolicyGet(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyGet(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___cb__CbPolicyCreate +#define SOAP_TYPE___cb__CbPolicyCreate (913) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyCreate(struct soap*, const struct __cb__CbPolicyCreate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyCreate(struct soap*, struct __cb__CbPolicyCreate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyCreate(struct soap*, const struct __cb__CbPolicyCreate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyCreate(struct soap*, const char*, int, const struct __cb__CbPolicyCreate *, const char*); +SOAP_FMAC3 struct __cb__CbPolicyCreate * SOAP_FMAC4 soap_get___cb__CbPolicyCreate(struct soap*, struct __cb__CbPolicyCreate *, const char*, const char*); +SOAP_FMAC3 struct __cb__CbPolicyCreate * SOAP_FMAC4 soap_in___cb__CbPolicyCreate(struct soap*, const char*, struct __cb__CbPolicyCreate *, const char*); +SOAP_FMAC5 struct __cb__CbPolicyCreate * SOAP_FMAC6 soap_new___cb__CbPolicyCreate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyCreate(struct soap*, struct __cb__CbPolicyCreate*); +SOAP_FMAC3 struct __cb__CbPolicyCreate * SOAP_FMAC4 soap_instantiate___cb__CbPolicyCreate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyCreate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogQueryCapabilities +#define SOAP_TYPE___apr__ConsoleWatchdogQueryCapabilities (909) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogQueryCapabilities(struct soap*, const struct __apr__ConsoleWatchdogQueryCapabilities *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogQueryCapabilities(struct soap*, struct __apr__ConsoleWatchdogQueryCapabilities *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogQueryCapabilities(struct soap*, const struct __apr__ConsoleWatchdogQueryCapabilities *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogQueryCapabilities(struct soap*, const char*, int, const struct __apr__ConsoleWatchdogQueryCapabilities *, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogQueryCapabilities(struct soap*, struct __apr__ConsoleWatchdogQueryCapabilities *, const char*, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogQueryCapabilities(struct soap*, const char*, struct __apr__ConsoleWatchdogQueryCapabilities *, const char*); +SOAP_FMAC5 struct __apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogQueryCapabilities(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogQueryCapabilities(struct soap*, struct __apr__ConsoleWatchdogQueryCapabilities*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogQueryCapabilities(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogQueryCapabilities(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogGetCbPolicy +#define SOAP_TYPE___apr__ConsoleWatchdogGetCbPolicy (905) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogGetCbPolicy(struct soap*, const struct __apr__ConsoleWatchdogGetCbPolicy *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogGetCbPolicy(struct soap*, struct __apr__ConsoleWatchdogGetCbPolicy *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogGetCbPolicy(struct soap*, const struct __apr__ConsoleWatchdogGetCbPolicy *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogGetCbPolicy(struct soap*, const char*, int, const struct __apr__ConsoleWatchdogGetCbPolicy *, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogGetCbPolicy(struct soap*, struct __apr__ConsoleWatchdogGetCbPolicy *, const char*, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogGetCbPolicy(struct soap*, const char*, struct __apr__ConsoleWatchdogGetCbPolicy *, const char*); +SOAP_FMAC5 struct __apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogGetCbPolicy(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogGetCbPolicy(struct soap*, struct __apr__ConsoleWatchdogGetCbPolicy*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogGetCbPolicy(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogGetCbPolicy(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogSetCbPolicy +#define SOAP_TYPE___apr__ConsoleWatchdogSetCbPolicy (901) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogSetCbPolicy(struct soap*, const struct __apr__ConsoleWatchdogSetCbPolicy *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogSetCbPolicy(struct soap*, struct __apr__ConsoleWatchdogSetCbPolicy *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogSetCbPolicy(struct soap*, const struct __apr__ConsoleWatchdogSetCbPolicy *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogSetCbPolicy(struct soap*, const char*, int, const struct __apr__ConsoleWatchdogSetCbPolicy *, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogSetCbPolicy(struct soap*, struct __apr__ConsoleWatchdogSetCbPolicy *, const char*, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogSetCbPolicy(struct soap*, const char*, struct __apr__ConsoleWatchdogSetCbPolicy *, const char*); +SOAP_FMAC5 struct __apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogSetCbPolicy(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogSetCbPolicy(struct soap*, struct __apr__ConsoleWatchdogSetCbPolicy*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogSetCbPolicy(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogSetCbPolicy(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogGetActions +#define SOAP_TYPE___apr__ConsoleWatchdogGetActions (897) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogGetActions(struct soap*, const struct __apr__ConsoleWatchdogGetActions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogGetActions(struct soap*, struct __apr__ConsoleWatchdogGetActions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogGetActions(struct soap*, const struct __apr__ConsoleWatchdogGetActions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogGetActions(struct soap*, const char*, int, const struct __apr__ConsoleWatchdogGetActions *, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogGetActions(struct soap*, struct __apr__ConsoleWatchdogGetActions *, const char*, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogGetActions(struct soap*, const char*, struct __apr__ConsoleWatchdogGetActions *, const char*); +SOAP_FMAC5 struct __apr__ConsoleWatchdogGetActions * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogGetActions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogGetActions(struct soap*, struct __apr__ConsoleWatchdogGetActions*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogGetActions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogGetActions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogSetActions +#define SOAP_TYPE___apr__ConsoleWatchdogSetActions (893) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogSetActions(struct soap*, const struct __apr__ConsoleWatchdogSetActions *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogSetActions(struct soap*, struct __apr__ConsoleWatchdogSetActions *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogSetActions(struct soap*, const struct __apr__ConsoleWatchdogSetActions *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogSetActions(struct soap*, const char*, int, const struct __apr__ConsoleWatchdogSetActions *, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogSetActions(struct soap*, struct __apr__ConsoleWatchdogSetActions *, const char*, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogSetActions(struct soap*, const char*, struct __apr__ConsoleWatchdogSetActions *, const char*); +SOAP_FMAC5 struct __apr__ConsoleWatchdogSetActions * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogSetActions(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogSetActions(struct soap*, struct __apr__ConsoleWatchdogSetActions*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogSetActions(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogSetActions(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogEnumerate +#define SOAP_TYPE___apr__ConsoleWatchdogEnumerate (889) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogEnumerate(struct soap*, const struct __apr__ConsoleWatchdogEnumerate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogEnumerate(struct soap*, struct __apr__ConsoleWatchdogEnumerate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogEnumerate(struct soap*, const struct __apr__ConsoleWatchdogEnumerate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogEnumerate(struct soap*, const char*, int, const struct __apr__ConsoleWatchdogEnumerate *, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogEnumerate(struct soap*, struct __apr__ConsoleWatchdogEnumerate *, const char*, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogEnumerate(struct soap*, const char*, struct __apr__ConsoleWatchdogEnumerate *, const char*); +SOAP_FMAC5 struct __apr__ConsoleWatchdogEnumerate * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogEnumerate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogEnumerate(struct soap*, struct __apr__ConsoleWatchdogEnumerate*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogEnumerate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogEnumerate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogDelete +#define SOAP_TYPE___apr__ConsoleWatchdogDelete (885) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogDelete(struct soap*, const struct __apr__ConsoleWatchdogDelete *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogDelete(struct soap*, struct __apr__ConsoleWatchdogDelete *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogDelete(struct soap*, const struct __apr__ConsoleWatchdogDelete *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogDelete(struct soap*, const char*, int, const struct __apr__ConsoleWatchdogDelete *, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogDelete(struct soap*, struct __apr__ConsoleWatchdogDelete *, const char*, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogDelete(struct soap*, const char*, struct __apr__ConsoleWatchdogDelete *, const char*); +SOAP_FMAC5 struct __apr__ConsoleWatchdogDelete * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogDelete(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogDelete(struct soap*, struct __apr__ConsoleWatchdogDelete*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogDelete(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogDelete(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogCreate +#define SOAP_TYPE___apr__ConsoleWatchdogCreate (881) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogCreate(struct soap*, const struct __apr__ConsoleWatchdogCreate *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogCreate(struct soap*, struct __apr__ConsoleWatchdogCreate *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogCreate(struct soap*, const struct __apr__ConsoleWatchdogCreate *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogCreate(struct soap*, const char*, int, const struct __apr__ConsoleWatchdogCreate *, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogCreate(struct soap*, struct __apr__ConsoleWatchdogCreate *, const char*, const char*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogCreate(struct soap*, const char*, struct __apr__ConsoleWatchdogCreate *, const char*); +SOAP_FMAC5 struct __apr__ConsoleWatchdogCreate * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogCreate(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogCreate(struct soap*, struct __apr__ConsoleWatchdogCreate*); +SOAP_FMAC3 struct __apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogCreate(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogCreate(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apl__AgentWatchdogRegister +#define SOAP_TYPE___apl__AgentWatchdogRegister (877) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apl__AgentWatchdogRegister(struct soap*, const struct __apl__AgentWatchdogRegister *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apl__AgentWatchdogRegister(struct soap*, struct __apl__AgentWatchdogRegister *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apl__AgentWatchdogRegister(struct soap*, const struct __apl__AgentWatchdogRegister *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apl__AgentWatchdogRegister(struct soap*, const char*, int, const struct __apl__AgentWatchdogRegister *, const char*); +SOAP_FMAC3 struct __apl__AgentWatchdogRegister * SOAP_FMAC4 soap_get___apl__AgentWatchdogRegister(struct soap*, struct __apl__AgentWatchdogRegister *, const char*, const char*); +SOAP_FMAC3 struct __apl__AgentWatchdogRegister * SOAP_FMAC4 soap_in___apl__AgentWatchdogRegister(struct soap*, const char*, struct __apl__AgentWatchdogRegister *, const char*); +SOAP_FMAC5 struct __apl__AgentWatchdogRegister * SOAP_FMAC6 soap_new___apl__AgentWatchdogRegister(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apl__AgentWatchdogRegister(struct soap*, struct __apl__AgentWatchdogRegister*); +SOAP_FMAC3 struct __apl__AgentWatchdogRegister * SOAP_FMAC4 soap_instantiate___apl__AgentWatchdogRegister(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apl__AgentWatchdogRegister(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apl__AgentWatchdogHeartbeat +#define SOAP_TYPE___apl__AgentWatchdogHeartbeat (873) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apl__AgentWatchdogHeartbeat(struct soap*, const struct __apl__AgentWatchdogHeartbeat *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apl__AgentWatchdogHeartbeat(struct soap*, struct __apl__AgentWatchdogHeartbeat *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apl__AgentWatchdogHeartbeat(struct soap*, const struct __apl__AgentWatchdogHeartbeat *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apl__AgentWatchdogHeartbeat(struct soap*, const char*, int, const struct __apl__AgentWatchdogHeartbeat *, const char*); +SOAP_FMAC3 struct __apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_get___apl__AgentWatchdogHeartbeat(struct soap*, struct __apl__AgentWatchdogHeartbeat *, const char*, const char*); +SOAP_FMAC3 struct __apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_in___apl__AgentWatchdogHeartbeat(struct soap*, const char*, struct __apl__AgentWatchdogHeartbeat *, const char*); +SOAP_FMAC5 struct __apl__AgentWatchdogHeartbeat * SOAP_FMAC6 soap_new___apl__AgentWatchdogHeartbeat(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apl__AgentWatchdogHeartbeat(struct soap*, struct __apl__AgentWatchdogHeartbeat*); +SOAP_FMAC3 struct __apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_instantiate___apl__AgentWatchdogHeartbeat(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apl__AgentWatchdogHeartbeat(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE___apl__AgentWatchdogShutdown +#define SOAP_TYPE___apl__AgentWatchdogShutdown (869) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apl__AgentWatchdogShutdown(struct soap*, const struct __apl__AgentWatchdogShutdown *); +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apl__AgentWatchdogShutdown(struct soap*, struct __apl__AgentWatchdogShutdown *); +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apl__AgentWatchdogShutdown(struct soap*, const struct __apl__AgentWatchdogShutdown *, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apl__AgentWatchdogShutdown(struct soap*, const char*, int, const struct __apl__AgentWatchdogShutdown *, const char*); +SOAP_FMAC3 struct __apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_get___apl__AgentWatchdogShutdown(struct soap*, struct __apl__AgentWatchdogShutdown *, const char*, const char*); +SOAP_FMAC3 struct __apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_in___apl__AgentWatchdogShutdown(struct soap*, const char*, struct __apl__AgentWatchdogShutdown *, const char*); +SOAP_FMAC5 struct __apl__AgentWatchdogShutdown * SOAP_FMAC6 soap_new___apl__AgentWatchdogShutdown(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apl__AgentWatchdogShutdown(struct soap*, struct __apl__AgentWatchdogShutdown*); +SOAP_FMAC3 struct __apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_instantiate___apl__AgentWatchdogShutdown(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apl__AgentWatchdogShutdown(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE__wcxs__union_ProfileSecuritySettingsType +#define SOAP_TYPE__wcxs__union_ProfileSecuritySettingsType (858) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_ProfileSecuritySettingsType(struct soap*, int, const union _wcxs__union_ProfileSecuritySettingsType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_ProfileSecuritySettingsType(struct soap*, int, const union _wcxs__union_ProfileSecuritySettingsType *); +SOAP_FMAC3 union _wcxs__union_ProfileSecuritySettingsType * SOAP_FMAC4 soap_in__wcxs__union_ProfileSecuritySettingsType(struct soap*, int*, union _wcxs__union_ProfileSecuritySettingsType *); + +#ifndef SOAP_TYPE__wcxs__union_ProfileSecuritySettingRSNType +#define SOAP_TYPE__wcxs__union_ProfileSecuritySettingRSNType (855) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_ProfileSecuritySettingRSNType(struct soap*, int, const union _wcxs__union_ProfileSecuritySettingRSNType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_ProfileSecuritySettingRSNType(struct soap*, int, const union _wcxs__union_ProfileSecuritySettingRSNType *); +SOAP_FMAC3 union _wcxs__union_ProfileSecuritySettingRSNType * SOAP_FMAC4 soap_in__wcxs__union_ProfileSecuritySettingRSNType(struct soap*, int*, union _wcxs__union_ProfileSecuritySettingRSNType *); + +#ifndef SOAP_TYPE__wcxs__union_ProfileSecuritySettingWPAType +#define SOAP_TYPE__wcxs__union_ProfileSecuritySettingWPAType (854) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_ProfileSecuritySettingWPAType(struct soap*, int, const union _wcxs__union_ProfileSecuritySettingWPAType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_ProfileSecuritySettingWPAType(struct soap*, int, const union _wcxs__union_ProfileSecuritySettingWPAType *); +SOAP_FMAC3 union _wcxs__union_ProfileSecuritySettingWPAType * SOAP_FMAC4 soap_in__wcxs__union_ProfileSecuritySettingWPAType(struct soap*, int*, union _wcxs__union_ProfileSecuritySettingWPAType *); + +#ifndef SOAP_TYPE__wcxs__union_DataEncryptionCCMPType +#define SOAP_TYPE__wcxs__union_DataEncryptionCCMPType (851) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_DataEncryptionCCMPType(struct soap*, int, const union _wcxs__union_DataEncryptionCCMPType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_DataEncryptionCCMPType(struct soap*, int, const union _wcxs__union_DataEncryptionCCMPType *); +SOAP_FMAC3 union _wcxs__union_DataEncryptionCCMPType * SOAP_FMAC4 soap_in__wcxs__union_DataEncryptionCCMPType(struct soap*, int*, union _wcxs__union_DataEncryptionCCMPType *); + +#ifndef SOAP_TYPE__wcxs__union_DataEncryptionTKIPType +#define SOAP_TYPE__wcxs__union_DataEncryptionTKIPType (850) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_DataEncryptionTKIPType(struct soap*, int, const union _wcxs__union_DataEncryptionTKIPType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_DataEncryptionTKIPType(struct soap*, int, const union _wcxs__union_DataEncryptionTKIPType *); +SOAP_FMAC3 union _wcxs__union_DataEncryptionTKIPType * SOAP_FMAC4 soap_in__wcxs__union_DataEncryptionTKIPType(struct soap*, int*, union _wcxs__union_DataEncryptionTKIPType *); + +#ifndef SOAP_TYPE__wcxs__union_DataEncryptionWEPType +#define SOAP_TYPE__wcxs__union_DataEncryptionWEPType (848) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_DataEncryptionWEPType(struct soap*, int, const union _wcxs__union_DataEncryptionWEPType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_DataEncryptionWEPType(struct soap*, int, const union _wcxs__union_DataEncryptionWEPType *); +SOAP_FMAC3 union _wcxs__union_DataEncryptionWEPType * SOAP_FMAC4 soap_in__wcxs__union_DataEncryptionWEPType(struct soap*, int*, union _wcxs__union_DataEncryptionWEPType *); + +#ifndef SOAP_TYPE__wcxs__union_DataEncryptionWEPXType +#define SOAP_TYPE__wcxs__union_DataEncryptionWEPXType (846) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_DataEncryptionWEPXType(struct soap*, int, const union _wcxs__union_DataEncryptionWEPXType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_DataEncryptionWEPXType(struct soap*, int, const union _wcxs__union_DataEncryptionWEPXType *); +SOAP_FMAC3 union _wcxs__union_DataEncryptionWEPXType * SOAP_FMAC4 soap_in__wcxs__union_DataEncryptionWEPXType(struct soap*, int*, union _wcxs__union_DataEncryptionWEPXType *); + +#ifndef SOAP_TYPE__wcxs__union_WEP128Type +#define SOAP_TYPE__wcxs__union_WEP128Type (843) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_WEP128Type(struct soap*, int, const union _wcxs__union_WEP128Type *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_WEP128Type(struct soap*, int, const union _wcxs__union_WEP128Type *); +SOAP_FMAC3 union _wcxs__union_WEP128Type * SOAP_FMAC4 soap_in__wcxs__union_WEP128Type(struct soap*, int*, union _wcxs__union_WEP128Type *); + +#ifndef SOAP_TYPE__wcxs__union_WEP64Type +#define SOAP_TYPE__wcxs__union_WEP64Type (840) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_WEP64Type(struct soap*, int, const union _wcxs__union_WEP64Type *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_WEP64Type(struct soap*, int, const union _wcxs__union_WEP64Type *); +SOAP_FMAC3 union _wcxs__union_WEP64Type * SOAP_FMAC4 soap_in__wcxs__union_WEP64Type(struct soap*, int*, union _wcxs__union_WEP64Type *); + +#ifndef SOAP_TYPE__cb__union_CircuitBreakerPacketType +#define SOAP_TYPE__cb__union_CircuitBreakerPacketType (790) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__union_CircuitBreakerPacketType(struct soap*, int, const union _cb__union_CircuitBreakerPacketType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__union_CircuitBreakerPacketType(struct soap*, int, const union _cb__union_CircuitBreakerPacketType *); +SOAP_FMAC3 union _cb__union_CircuitBreakerPacketType * SOAP_FMAC4 soap_in__cb__union_CircuitBreakerPacketType(struct soap*, int*, union _cb__union_CircuitBreakerPacketType *); + +#ifndef SOAP_TYPE__cb__union_CircuitBreakerIPPacketType +#define SOAP_TYPE__cb__union_CircuitBreakerIPPacketType (783) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__union_CircuitBreakerIPPacketType(struct soap*, int, const union _cb__union_CircuitBreakerIPPacketType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__union_CircuitBreakerIPPacketType(struct soap*, int, const union _cb__union_CircuitBreakerIPPacketType *); +SOAP_FMAC3 union _cb__union_CircuitBreakerIPPacketType * SOAP_FMAC4 soap_in__cb__union_CircuitBreakerIPPacketType(struct soap*, int*, union _cb__union_CircuitBreakerIPPacketType *); + +#ifndef SOAP_TYPE__cb__union_CircuitBreakerIPLayeredPortType +#define SOAP_TYPE__cb__union_CircuitBreakerIPLayeredPortType (778) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__union_CircuitBreakerIPLayeredPortType(struct soap*, int, const union _cb__union_CircuitBreakerIPLayeredPortType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__union_CircuitBreakerIPLayeredPortType(struct soap*, int, const union _cb__union_CircuitBreakerIPLayeredPortType *); +SOAP_FMAC3 union _cb__union_CircuitBreakerIPLayeredPortType * SOAP_FMAC4 soap_in__cb__union_CircuitBreakerIPLayeredPortType(struct soap*, int*, union _cb__union_CircuitBreakerIPLayeredPortType *); + +#ifndef SOAP_TYPE__emi__union_AlertSubscriptionGeneralType +#define SOAP_TYPE__emi__union_AlertSubscriptionGeneralType (761) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__emi__union_AlertSubscriptionGeneralType(struct soap*, int, const union _emi__union_AlertSubscriptionGeneralType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__union_AlertSubscriptionGeneralType(struct soap*, int, const union _emi__union_AlertSubscriptionGeneralType *); +SOAP_FMAC3 union _emi__union_AlertSubscriptionGeneralType * SOAP_FMAC4 soap_in__emi__union_AlertSubscriptionGeneralType(struct soap*, int*, union _emi__union_AlertSubscriptionGeneralType *); + +#ifndef SOAP_TYPE__xcfg__union_XProfileType +#define SOAP_TYPE__xcfg__union_XProfileType (725) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__xcfg__union_XProfileType(struct soap*, int, const union _xcfg__union_XProfileType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__xcfg__union_XProfileType(struct soap*, int, const union _xcfg__union_XProfileType *); +SOAP_FMAC3 union _xcfg__union_XProfileType * SOAP_FMAC4 soap_in__xcfg__union_XProfileType(struct soap*, int*, union _xcfg__union_XProfileType *); + +#ifndef SOAP_TYPE__sai__union_UserAclEntryExType +#define SOAP_TYPE__sai__union_UserAclEntryExType (674) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__sai__union_UserAclEntryExType(struct soap*, int, const union _sai__union_UserAclEntryExType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__union_UserAclEntryExType(struct soap*, int, const union _sai__union_UserAclEntryExType *); +SOAP_FMAC3 union _sai__union_UserAclEntryExType * SOAP_FMAC4 soap_in__sai__union_UserAclEntryExType(struct soap*, int*, union _sai__union_UserAclEntryExType *); + +#ifndef SOAP_TYPE__cstr__union_KeyPairType +#define SOAP_TYPE__cstr__union_KeyPairType (668) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cstr__union_KeyPairType(struct soap*, int, const union _cstr__union_KeyPairType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cstr__union_KeyPairType(struct soap*, int, const union _cstr__union_KeyPairType *); +SOAP_FMAC3 union _cstr__union_KeyPairType * SOAP_FMAC4 soap_in__cstr__union_KeyPairType(struct soap*, int*, union _cstr__union_KeyPairType *); + +#ifndef SOAP_TYPE__cmn__union_NodeAddressType +#define SOAP_TYPE__cmn__union_NodeAddressType (666) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cmn__union_NodeAddressType(struct soap*, int, const union _cmn__union_NodeAddressType *); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cmn__union_NodeAddressType(struct soap*, int, const union _cmn__union_NodeAddressType *); +SOAP_FMAC3 union _cmn__union_NodeAddressType * SOAP_FMAC4 soap_in__cmn__union_NodeAddressType(struct soap*, int*, union _cmn__union_NodeAddressType *); + +#ifndef WITH_NOGLOBAL + +#ifndef SOAP_TYPE_PointerToSOAP_ENV__Reason +#define SOAP_TYPE_PointerToSOAP_ENV__Reason (1675) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Reason(struct soap*, const char *, int, struct SOAP_ENV__Reason *const*, const char *); +SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Reason(struct soap*, struct SOAP_ENV__Reason **, const char*, const char*); +SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Reason(struct soap*, const char*, struct SOAP_ENV__Reason **, const char*); + +#endif + +#ifndef WITH_NOGLOBAL + +#ifndef SOAP_TYPE_PointerToSOAP_ENV__Detail +#define SOAP_TYPE_PointerToSOAP_ENV__Detail (1674) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Detail(struct soap*, const char *, int, struct SOAP_ENV__Detail *const*, const char *); +SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Detail(struct soap*, struct SOAP_ENV__Detail **, const char*, const char*); +SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Detail(struct soap*, const char*, struct SOAP_ENV__Detail **, const char*); + +#endif + +#ifndef WITH_NOGLOBAL + +#ifndef SOAP_TYPE_PointerToSOAP_ENV__Code +#define SOAP_TYPE_PointerToSOAP_ENV__Code (1670) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Code(struct soap*, const char *, int, struct SOAP_ENV__Code *const*, const char *); +SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Code(struct soap*, struct SOAP_ENV__Code **, const char*, const char*); +SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Code(struct soap*, const char*, struct SOAP_ENV__Code **, const char*); + +#endif + +#ifndef SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsResponse +#define SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsResponse (1663) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap*, _wcxs__GetWirelessSettingsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap*, _wcxs__GetWirelessSettingsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap*, const char *, int, _wcxs__GetWirelessSettingsResponse *const*, const char *); +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap*, _wcxs__GetWirelessSettingsResponse **, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap*, const char*, _wcxs__GetWirelessSettingsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsRequest +#define SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsRequest (1662) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap*, _wcxs__GetWirelessSettingsRequest *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap*, _wcxs__GetWirelessSettingsRequest *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap*, const char *, int, _wcxs__GetWirelessSettingsRequest *const*, const char *); +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap*, _wcxs__GetWirelessSettingsRequest **, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap*, const char*, _wcxs__GetWirelessSettingsRequest **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesResponse +#define SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesResponse (1659) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap*, _wcxs__GetWirelessCapabilitiesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap*, _wcxs__GetWirelessCapabilitiesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap*, const char *, int, _wcxs__GetWirelessCapabilitiesResponse *const*, const char *); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap*, _wcxs__GetWirelessCapabilitiesResponse **, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap*, const char*, _wcxs__GetWirelessCapabilitiesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesRequest +#define SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesRequest (1658) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap*, _wcxs__GetWirelessCapabilitiesRequest *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap*, _wcxs__GetWirelessCapabilitiesRequest *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap*, const char *, int, _wcxs__GetWirelessCapabilitiesRequest *const*, const char *); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap*, _wcxs__GetWirelessCapabilitiesRequest **, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap*, const char*, _wcxs__GetWirelessCapabilitiesRequest **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesResponse +#define SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesResponse (1655) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap*, _wcxs__EnumerateWirelessProfilesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap*, _wcxs__EnumerateWirelessProfilesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap*, const char *, int, _wcxs__EnumerateWirelessProfilesResponse *const*, const char *); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap*, _wcxs__EnumerateWirelessProfilesResponse **, const char*, const char*); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap*, const char*, _wcxs__EnumerateWirelessProfilesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesRequest +#define SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesRequest (1654) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap*, _wcxs__EnumerateWirelessProfilesRequest *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap*, _wcxs__EnumerateWirelessProfilesRequest *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap*, const char *, int, _wcxs__EnumerateWirelessProfilesRequest *const*, const char *); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap*, _wcxs__EnumerateWirelessProfilesRequest **, const char*, const char*); +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap*, const char*, _wcxs__EnumerateWirelessProfilesRequest **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileResponse +#define SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileResponse (1651) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap*, _wcxs__UpdateWirelessProfileResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap*, _wcxs__UpdateWirelessProfileResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap*, const char *, int, _wcxs__UpdateWirelessProfileResponse *const*, const char *); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap*, _wcxs__UpdateWirelessProfileResponse **, const char*, const char*); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap*, const char*, _wcxs__UpdateWirelessProfileResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileRequest +#define SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileRequest (1650) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap*, _wcxs__UpdateWirelessProfileRequest *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap*, _wcxs__UpdateWirelessProfileRequest *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap*, const char *, int, _wcxs__UpdateWirelessProfileRequest *const*, const char *); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap*, _wcxs__UpdateWirelessProfileRequest **, const char*, const char*); +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap*, const char*, _wcxs__UpdateWirelessProfileRequest **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileResponse +#define SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileResponse (1647) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap*, _wcxs__RemoveWirelessProfileResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap*, _wcxs__RemoveWirelessProfileResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap*, const char *, int, _wcxs__RemoveWirelessProfileResponse *const*, const char *); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap*, _wcxs__RemoveWirelessProfileResponse **, const char*, const char*); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap*, const char*, _wcxs__RemoveWirelessProfileResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileRequest +#define SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileRequest (1646) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap*, _wcxs__RemoveWirelessProfileRequest *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap*, _wcxs__RemoveWirelessProfileRequest *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap*, const char *, int, _wcxs__RemoveWirelessProfileRequest *const*, const char *); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap*, _wcxs__RemoveWirelessProfileRequest **, const char*, const char*); +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap*, const char*, _wcxs__RemoveWirelessProfileRequest **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileResponse +#define SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileResponse (1643) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessProfileResponse(struct soap*, _wcxs__GetWirelessProfileResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessProfileResponse(struct soap*, _wcxs__GetWirelessProfileResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessProfileResponse(struct soap*, const char *, int, _wcxs__GetWirelessProfileResponse *const*, const char *); +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessProfileResponse(struct soap*, _wcxs__GetWirelessProfileResponse **, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessProfileResponse(struct soap*, const char*, _wcxs__GetWirelessProfileResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileRequest +#define SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileRequest (1642) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessProfileRequest(struct soap*, _wcxs__GetWirelessProfileRequest *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessProfileRequest(struct soap*, _wcxs__GetWirelessProfileRequest *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessProfileRequest(struct soap*, const char *, int, _wcxs__GetWirelessProfileRequest *const*, const char *); +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessProfileRequest(struct soap*, _wcxs__GetWirelessProfileRequest **, const char*, const char*); +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessProfileRequest(struct soap*, const char*, _wcxs__GetWirelessProfileRequest **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileResponse +#define SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileResponse (1639) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__AddWirelessProfileResponse(struct soap*, _wcxs__AddWirelessProfileResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__AddWirelessProfileResponse(struct soap*, _wcxs__AddWirelessProfileResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__AddWirelessProfileResponse(struct soap*, const char *, int, _wcxs__AddWirelessProfileResponse *const*, const char *); +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__AddWirelessProfileResponse(struct soap*, _wcxs__AddWirelessProfileResponse **, const char*, const char*); +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__AddWirelessProfileResponse(struct soap*, const char*, _wcxs__AddWirelessProfileResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileRequest +#define SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileRequest (1638) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__AddWirelessProfileRequest(struct soap*, _wcxs__AddWirelessProfileRequest *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__AddWirelessProfileRequest(struct soap*, _wcxs__AddWirelessProfileRequest *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__AddWirelessProfileRequest(struct soap*, const char *, int, _wcxs__AddWirelessProfileRequest *const*, const char *); +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__AddWirelessProfileRequest(struct soap*, _wcxs__AddWirelessProfileRequest **, const char*, const char*); +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__AddWirelessProfileRequest(struct soap*, const char*, _wcxs__AddWirelessProfileRequest **, const char*); + +#ifndef SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynchResponse +#define SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynchResponse (1635) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap*, _tim__SetHighAccuracyTimeSynchResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap*, _tim__SetHighAccuracyTimeSynchResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap*, const char *, int, _tim__SetHighAccuracyTimeSynchResponse *const*, const char *); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse ** SOAP_FMAC4 soap_get_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap*, _tim__SetHighAccuracyTimeSynchResponse **, const char*, const char*); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse ** SOAP_FMAC4 soap_in_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap*, const char*, _tim__SetHighAccuracyTimeSynchResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynch +#define SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynch (1634) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap*, _tim__SetHighAccuracyTimeSynch *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap*, _tim__SetHighAccuracyTimeSynch *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap*, const char *, int, _tim__SetHighAccuracyTimeSynch *const*, const char *); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch ** SOAP_FMAC4 soap_get_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap*, _tim__SetHighAccuracyTimeSynch **, const char*, const char*); +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch ** SOAP_FMAC4 soap_in_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap*, const char*, _tim__SetHighAccuracyTimeSynch **, const char*); + +#ifndef SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynchResponse +#define SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynchResponse (1631) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap*, _tim__GetLowAccuracyTimeSynchResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap*, _tim__GetLowAccuracyTimeSynchResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap*, const char *, int, _tim__GetLowAccuracyTimeSynchResponse *const*, const char *); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse ** SOAP_FMAC4 soap_get_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap*, _tim__GetLowAccuracyTimeSynchResponse **, const char*, const char*); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse ** SOAP_FMAC4 soap_in_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap*, const char*, _tim__GetLowAccuracyTimeSynchResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynch +#define SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynch (1630) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap*, _tim__GetLowAccuracyTimeSynch *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap*, _tim__GetLowAccuracyTimeSynch *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap*, const char *, int, _tim__GetLowAccuracyTimeSynch *const*, const char *); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch ** SOAP_FMAC4 soap_get_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap*, _tim__GetLowAccuracyTimeSynch **, const char*, const char*); +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch ** SOAP_FMAC4 soap_in_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap*, const char*, _tim__GetLowAccuracyTimeSynch **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntryResponse +#define SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntryResponse (1627) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap*, _stra__RemoveStorageFpaclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap*, _stra__RemoveStorageFpaclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap*, const char *, int, _stra__RemoveStorageFpaclEntryResponse *const*, const char *); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap*, _stra__RemoveStorageFpaclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap*, const char*, _stra__RemoveStorageFpaclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntry +#define SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntry (1626) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__RemoveStorageFpaclEntry(struct soap*, _stra__RemoveStorageFpaclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__RemoveStorageFpaclEntry(struct soap*, _stra__RemoveStorageFpaclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__RemoveStorageFpaclEntry(struct soap*, const char *, int, _stra__RemoveStorageFpaclEntry *const*, const char *); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__RemoveStorageFpaclEntry(struct soap*, _stra__RemoveStorageFpaclEntry **, const char*, const char*); +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__RemoveStorageFpaclEntry(struct soap*, const char*, _stra__RemoveStorageFpaclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntryResponse +#define SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntryResponse (1623) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap*, _stra__UpdateStorageFpaclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap*, _stra__UpdateStorageFpaclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap*, const char *, int, _stra__UpdateStorageFpaclEntryResponse *const*, const char *); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap*, _stra__UpdateStorageFpaclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap*, const char*, _stra__UpdateStorageFpaclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntry +#define SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntry (1622) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__UpdateStorageFpaclEntry(struct soap*, _stra__UpdateStorageFpaclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__UpdateStorageFpaclEntry(struct soap*, _stra__UpdateStorageFpaclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__UpdateStorageFpaclEntry(struct soap*, const char *, int, _stra__UpdateStorageFpaclEntry *const*, const char *); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__UpdateStorageFpaclEntry(struct soap*, _stra__UpdateStorageFpaclEntry **, const char*, const char*); +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__UpdateStorageFpaclEntry(struct soap*, const char*, _stra__UpdateStorageFpaclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__GetStorageAllocEntryResponse +#define SOAP_TYPE_PointerTo_stra__GetStorageAllocEntryResponse (1619) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetStorageAllocEntryResponse(struct soap*, _stra__GetStorageAllocEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetStorageAllocEntryResponse(struct soap*, _stra__GetStorageAllocEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetStorageAllocEntryResponse(struct soap*, const char *, int, _stra__GetStorageAllocEntryResponse *const*, const char *); +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__GetStorageAllocEntryResponse(struct soap*, _stra__GetStorageAllocEntryResponse **, const char*, const char*); +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__GetStorageAllocEntryResponse(struct soap*, const char*, _stra__GetStorageAllocEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__GetStorageAllocEntry +#define SOAP_TYPE_PointerTo_stra__GetStorageAllocEntry (1618) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetStorageAllocEntry(struct soap*, _stra__GetStorageAllocEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetStorageAllocEntry(struct soap*, _stra__GetStorageAllocEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetStorageAllocEntry(struct soap*, const char *, int, _stra__GetStorageAllocEntry *const*, const char *); +SOAP_FMAC3 _stra__GetStorageAllocEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__GetStorageAllocEntry(struct soap*, _stra__GetStorageAllocEntry **, const char*, const char*); +SOAP_FMAC3 _stra__GetStorageAllocEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__GetStorageAllocEntry(struct soap*, const char*, _stra__GetStorageAllocEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntriesResponse +#define SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntriesResponse (1615) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap*, _stra__EnumerateStorageAllocEntriesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap*, _stra__EnumerateStorageAllocEntriesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap*, const char *, int, _stra__EnumerateStorageAllocEntriesResponse *const*, const char *); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap*, _stra__EnumerateStorageAllocEntriesResponse **, const char*, const char*); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap*, const char*, _stra__EnumerateStorageAllocEntriesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntries +#define SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntries (1614) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__EnumerateStorageAllocEntries(struct soap*, _stra__EnumerateStorageAllocEntries *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__EnumerateStorageAllocEntries(struct soap*, _stra__EnumerateStorageAllocEntries *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__EnumerateStorageAllocEntries(struct soap*, const char *, int, _stra__EnumerateStorageAllocEntries *const*, const char *); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries ** SOAP_FMAC4 soap_get_PointerTo_stra__EnumerateStorageAllocEntries(struct soap*, _stra__EnumerateStorageAllocEntries **, const char*, const char*); +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries ** SOAP_FMAC4 soap_in_PointerTo_stra__EnumerateStorageAllocEntries(struct soap*, const char*, _stra__EnumerateStorageAllocEntries **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntryResponse +#define SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntryResponse (1611) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap*, _stra__AddStorageFpaclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap*, _stra__AddStorageFpaclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap*, const char *, int, _stra__AddStorageFpaclEntryResponse *const*, const char *); +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap*, _stra__AddStorageFpaclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap*, const char*, _stra__AddStorageFpaclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntry +#define SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntry (1610) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AddStorageFpaclEntry(struct soap*, _stra__AddStorageFpaclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AddStorageFpaclEntry(struct soap*, _stra__AddStorageFpaclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AddStorageFpaclEntry(struct soap*, const char *, int, _stra__AddStorageFpaclEntry *const*, const char *); +SOAP_FMAC3 _stra__AddStorageFpaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__AddStorageFpaclEntry(struct soap*, _stra__AddStorageFpaclEntry **, const char*, const char*); +SOAP_FMAC3 _stra__AddStorageFpaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__AddStorageFpaclEntry(struct soap*, const char*, _stra__AddStorageFpaclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntryResponse +#define SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntryResponse (1607) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap*, _stra__RemoveStorageEaclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap*, _stra__RemoveStorageEaclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap*, const char *, int, _stra__RemoveStorageEaclEntryResponse *const*, const char *); +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap*, _stra__RemoveStorageEaclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap*, const char*, _stra__RemoveStorageEaclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntry +#define SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntry (1606) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__RemoveStorageEaclEntry(struct soap*, _stra__RemoveStorageEaclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__RemoveStorageEaclEntry(struct soap*, _stra__RemoveStorageEaclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__RemoveStorageEaclEntry(struct soap*, const char *, int, _stra__RemoveStorageEaclEntry *const*, const char *); +SOAP_FMAC3 _stra__RemoveStorageEaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__RemoveStorageEaclEntry(struct soap*, _stra__RemoveStorageEaclEntry **, const char*, const char*); +SOAP_FMAC3 _stra__RemoveStorageEaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__RemoveStorageEaclEntry(struct soap*, const char*, _stra__RemoveStorageEaclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__GetStorageEaclEntryResponse +#define SOAP_TYPE_PointerTo_stra__GetStorageEaclEntryResponse (1603) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetStorageEaclEntryResponse(struct soap*, _stra__GetStorageEaclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetStorageEaclEntryResponse(struct soap*, _stra__GetStorageEaclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetStorageEaclEntryResponse(struct soap*, const char *, int, _stra__GetStorageEaclEntryResponse *const*, const char *); +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__GetStorageEaclEntryResponse(struct soap*, _stra__GetStorageEaclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__GetStorageEaclEntryResponse(struct soap*, const char*, _stra__GetStorageEaclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__GetStorageEaclEntry +#define SOAP_TYPE_PointerTo_stra__GetStorageEaclEntry (1602) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetStorageEaclEntry(struct soap*, _stra__GetStorageEaclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetStorageEaclEntry(struct soap*, _stra__GetStorageEaclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetStorageEaclEntry(struct soap*, const char *, int, _stra__GetStorageEaclEntry *const*, const char *); +SOAP_FMAC3 _stra__GetStorageEaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__GetStorageEaclEntry(struct soap*, _stra__GetStorageEaclEntry **, const char*, const char*); +SOAP_FMAC3 _stra__GetStorageEaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__GetStorageEaclEntry(struct soap*, const char*, _stra__GetStorageEaclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntriesResponse +#define SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntriesResponse (1599) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap*, _stra__EnumerateStorageEaclEntriesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap*, _stra__EnumerateStorageEaclEntriesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap*, const char *, int, _stra__EnumerateStorageEaclEntriesResponse *const*, const char *); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap*, _stra__EnumerateStorageEaclEntriesResponse **, const char*, const char*); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap*, const char*, _stra__EnumerateStorageEaclEntriesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntries +#define SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntries (1598) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__EnumerateStorageEaclEntries(struct soap*, _stra__EnumerateStorageEaclEntries *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__EnumerateStorageEaclEntries(struct soap*, _stra__EnumerateStorageEaclEntries *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__EnumerateStorageEaclEntries(struct soap*, const char *, int, _stra__EnumerateStorageEaclEntries *const*, const char *); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries ** SOAP_FMAC4 soap_get_PointerTo_stra__EnumerateStorageEaclEntries(struct soap*, _stra__EnumerateStorageEaclEntries **, const char*, const char*); +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries ** SOAP_FMAC4 soap_in_PointerTo_stra__EnumerateStorageEaclEntries(struct soap*, const char*, _stra__EnumerateStorageEaclEntries **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AddStorageEaclEntryResponse +#define SOAP_TYPE_PointerTo_stra__AddStorageEaclEntryResponse (1595) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AddStorageEaclEntryResponse(struct soap*, _stra__AddStorageEaclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AddStorageEaclEntryResponse(struct soap*, _stra__AddStorageEaclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AddStorageEaclEntryResponse(struct soap*, const char *, int, _stra__AddStorageEaclEntryResponse *const*, const char *); +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AddStorageEaclEntryResponse(struct soap*, _stra__AddStorageEaclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AddStorageEaclEntryResponse(struct soap*, const char*, _stra__AddStorageEaclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AddStorageEaclEntry +#define SOAP_TYPE_PointerTo_stra__AddStorageEaclEntry (1594) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AddStorageEaclEntry(struct soap*, _stra__AddStorageEaclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AddStorageEaclEntry(struct soap*, _stra__AddStorageEaclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AddStorageEaclEntry(struct soap*, const char *, int, _stra__AddStorageEaclEntry *const*, const char *); +SOAP_FMAC3 _stra__AddStorageEaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__AddStorageEaclEntry(struct soap*, _stra__AddStorageEaclEntry **, const char*, const char*); +SOAP_FMAC3 _stra__AddStorageEaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__AddStorageEaclEntry(struct soap*, const char*, _stra__AddStorageEaclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AdminRemoveApplicationResponse +#define SOAP_TYPE_PointerTo_stra__AdminRemoveApplicationResponse (1591) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminRemoveApplicationResponse(struct soap*, _stra__AdminRemoveApplicationResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminRemoveApplicationResponse(struct soap*, _stra__AdminRemoveApplicationResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminRemoveApplicationResponse(struct soap*, const char *, int, _stra__AdminRemoveApplicationResponse *const*, const char *); +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminRemoveApplicationResponse(struct soap*, _stra__AdminRemoveApplicationResponse **, const char*, const char*); +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminRemoveApplicationResponse(struct soap*, const char*, _stra__AdminRemoveApplicationResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AdminRemoveApplication +#define SOAP_TYPE_PointerTo_stra__AdminRemoveApplication (1590) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminRemoveApplication(struct soap*, _stra__AdminRemoveApplication *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminRemoveApplication(struct soap*, _stra__AdminRemoveApplication *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminRemoveApplication(struct soap*, const char *, int, _stra__AdminRemoveApplication *const*, const char *); +SOAP_FMAC3 _stra__AdminRemoveApplication ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminRemoveApplication(struct soap*, _stra__AdminRemoveApplication **, const char*, const char*); +SOAP_FMAC3 _stra__AdminRemoveApplication ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminRemoveApplication(struct soap*, const char*, _stra__AdminRemoveApplication **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributesResponse +#define SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributesResponse (1587) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap*, _stra__AdminGetApplicationAttributesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap*, _stra__AdminGetApplicationAttributesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap*, const char *, int, _stra__AdminGetApplicationAttributesResponse *const*, const char *); +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap*, _stra__AdminGetApplicationAttributesResponse **, const char*, const char*); +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap*, const char*, _stra__AdminGetApplicationAttributesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributes +#define SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributes (1586) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminGetApplicationAttributes(struct soap*, _stra__AdminGetApplicationAttributes *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminGetApplicationAttributes(struct soap*, _stra__AdminGetApplicationAttributes *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminGetApplicationAttributes(struct soap*, const char *, int, _stra__AdminGetApplicationAttributes *const*, const char *); +SOAP_FMAC3 _stra__AdminGetApplicationAttributes ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminGetApplicationAttributes(struct soap*, _stra__AdminGetApplicationAttributes **, const char*, const char*); +SOAP_FMAC3 _stra__AdminGetApplicationAttributes ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminGetApplicationAttributes(struct soap*, const char*, _stra__AdminGetApplicationAttributes **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplicationsResponse +#define SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplicationsResponse (1583) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap*, _stra__AdminGetRegisteredApplicationsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap*, _stra__AdminGetRegisteredApplicationsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap*, const char *, int, _stra__AdminGetRegisteredApplicationsResponse *const*, const char *); +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap*, _stra__AdminGetRegisteredApplicationsResponse **, const char*, const char*); +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap*, const char*, _stra__AdminGetRegisteredApplicationsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplications +#define SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplications (1582) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminGetRegisteredApplications(struct soap*, _stra__AdminGetRegisteredApplications *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminGetRegisteredApplications(struct soap*, _stra__AdminGetRegisteredApplications *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminGetRegisteredApplications(struct soap*, const char *, int, _stra__AdminGetRegisteredApplications *const*, const char *); +SOAP_FMAC3 _stra__AdminGetRegisteredApplications ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminGetRegisteredApplications(struct soap*, _stra__AdminGetRegisteredApplications **, const char*, const char*); +SOAP_FMAC3 _stra__AdminGetRegisteredApplications ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminGetRegisteredApplications(struct soap*, const char*, _stra__AdminGetRegisteredApplications **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributesResponse +#define SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributesResponse (1579) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap*, _stra__SetGlobalStorageAttributesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap*, _stra__SetGlobalStorageAttributesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap*, const char *, int, _stra__SetGlobalStorageAttributesResponse *const*, const char *); +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap*, _stra__SetGlobalStorageAttributesResponse **, const char*, const char*); +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap*, const char*, _stra__SetGlobalStorageAttributesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributes +#define SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributes (1578) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__SetGlobalStorageAttributes(struct soap*, _stra__SetGlobalStorageAttributes *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__SetGlobalStorageAttributes(struct soap*, _stra__SetGlobalStorageAttributes *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__SetGlobalStorageAttributes(struct soap*, const char *, int, _stra__SetGlobalStorageAttributes *const*, const char *); +SOAP_FMAC3 _stra__SetGlobalStorageAttributes ** SOAP_FMAC4 soap_get_PointerTo_stra__SetGlobalStorageAttributes(struct soap*, _stra__SetGlobalStorageAttributes **, const char*, const char*); +SOAP_FMAC3 _stra__SetGlobalStorageAttributes ** SOAP_FMAC4 soap_in_PointerTo_stra__SetGlobalStorageAttributes(struct soap*, const char*, _stra__SetGlobalStorageAttributes **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributesResponse +#define SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributesResponse (1575) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap*, _stra__GetGlobalStorageAttributesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap*, _stra__GetGlobalStorageAttributesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap*, const char *, int, _stra__GetGlobalStorageAttributesResponse *const*, const char *); +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap*, _stra__GetGlobalStorageAttributesResponse **, const char*, const char*); +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap*, const char*, _stra__GetGlobalStorageAttributesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributes +#define SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributes (1574) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetGlobalStorageAttributes(struct soap*, _stra__GetGlobalStorageAttributes *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetGlobalStorageAttributes(struct soap*, _stra__GetGlobalStorageAttributes *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetGlobalStorageAttributes(struct soap*, const char *, int, _stra__GetGlobalStorageAttributes *const*, const char *); +SOAP_FMAC3 _stra__GetGlobalStorageAttributes ** SOAP_FMAC4 soap_get_PointerTo_stra__GetGlobalStorageAttributes(struct soap*, _stra__GetGlobalStorageAttributes **, const char*, const char*); +SOAP_FMAC3 _stra__GetGlobalStorageAttributes ** SOAP_FMAC4 soap_in_PointerTo_stra__GetGlobalStorageAttributes(struct soap*, const char*, _stra__GetGlobalStorageAttributes **, const char*); + +#ifndef SOAP_TYPE_PointerTo_str__ExecuteStorageOperationResponse +#define SOAP_TYPE_PointerTo_str__ExecuteStorageOperationResponse (1571) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_str__ExecuteStorageOperationResponse(struct soap*, _str__ExecuteStorageOperationResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_str__ExecuteStorageOperationResponse(struct soap*, _str__ExecuteStorageOperationResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_str__ExecuteStorageOperationResponse(struct soap*, const char *, int, _str__ExecuteStorageOperationResponse *const*, const char *); +SOAP_FMAC3 _str__ExecuteStorageOperationResponse ** SOAP_FMAC4 soap_get_PointerTo_str__ExecuteStorageOperationResponse(struct soap*, _str__ExecuteStorageOperationResponse **, const char*, const char*); +SOAP_FMAC3 _str__ExecuteStorageOperationResponse ** SOAP_FMAC4 soap_in_PointerTo_str__ExecuteStorageOperationResponse(struct soap*, const char*, _str__ExecuteStorageOperationResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_str__ExecuteStorageOperation +#define SOAP_TYPE_PointerTo_str__ExecuteStorageOperation (1570) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_str__ExecuteStorageOperation(struct soap*, _str__ExecuteStorageOperation *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_str__ExecuteStorageOperation(struct soap*, _str__ExecuteStorageOperation *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_str__ExecuteStorageOperation(struct soap*, const char *, int, _str__ExecuteStorageOperation *const*, const char *); +SOAP_FMAC3 _str__ExecuteStorageOperation ** SOAP_FMAC4 soap_get_PointerTo_str__ExecuteStorageOperation(struct soap*, _str__ExecuteStorageOperation **, const char*, const char*); +SOAP_FMAC3 _str__ExecuteStorageOperation ** SOAP_FMAC4 soap_in_PointerTo_str__ExecuteStorageOperation(struct soap*, const char*, _str__ExecuteStorageOperation **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetAclEnabledStateResponse +#define SOAP_TYPE_PointerTo_sai__GetAclEnabledStateResponse (1567) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetAclEnabledStateResponse(struct soap*, _sai__GetAclEnabledStateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetAclEnabledStateResponse(struct soap*, _sai__GetAclEnabledStateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetAclEnabledStateResponse(struct soap*, const char *, int, _sai__GetAclEnabledStateResponse *const*, const char *); +SOAP_FMAC3 _sai__GetAclEnabledStateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetAclEnabledStateResponse(struct soap*, _sai__GetAclEnabledStateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetAclEnabledStateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetAclEnabledStateResponse(struct soap*, const char*, _sai__GetAclEnabledStateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetAclEnabledState +#define SOAP_TYPE_PointerTo_sai__GetAclEnabledState (1566) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetAclEnabledState(struct soap*, _sai__GetAclEnabledState *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetAclEnabledState(struct soap*, _sai__GetAclEnabledState *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetAclEnabledState(struct soap*, const char *, int, _sai__GetAclEnabledState *const*, const char *); +SOAP_FMAC3 _sai__GetAclEnabledState ** SOAP_FMAC4 soap_get_PointerTo_sai__GetAclEnabledState(struct soap*, _sai__GetAclEnabledState **, const char*, const char*); +SOAP_FMAC3 _sai__GetAclEnabledState ** SOAP_FMAC4 soap_in_PointerTo_sai__GetAclEnabledState(struct soap*, const char*, _sai__GetAclEnabledState **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetAclEnabledStateResponse +#define SOAP_TYPE_PointerTo_sai__SetAclEnabledStateResponse (1563) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAclEnabledStateResponse(struct soap*, _sai__SetAclEnabledStateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAclEnabledStateResponse(struct soap*, _sai__SetAclEnabledStateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAclEnabledStateResponse(struct soap*, const char *, int, _sai__SetAclEnabledStateResponse *const*, const char *); +SOAP_FMAC3 _sai__SetAclEnabledStateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAclEnabledStateResponse(struct soap*, _sai__SetAclEnabledStateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetAclEnabledStateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAclEnabledStateResponse(struct soap*, const char*, _sai__SetAclEnabledStateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetAclEnabledState +#define SOAP_TYPE_PointerTo_sai__SetAclEnabledState (1562) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAclEnabledState(struct soap*, _sai__SetAclEnabledState *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAclEnabledState(struct soap*, _sai__SetAclEnabledState *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAclEnabledState(struct soap*, const char *, int, _sai__SetAclEnabledState *const*, const char *); +SOAP_FMAC3 _sai__SetAclEnabledState ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAclEnabledState(struct soap*, _sai__SetAclEnabledState **, const char*, const char*); +SOAP_FMAC3 _sai__SetAclEnabledState ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAclEnabledState(struct soap*, const char*, _sai__SetAclEnabledState **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDNResponse +#define SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDNResponse (1559) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap*, _sai__SetConfigurationServerFQDNResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap*, _sai__SetConfigurationServerFQDNResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap*, const char *, int, _sai__SetConfigurationServerFQDNResponse *const*, const char *); +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap*, _sai__SetConfigurationServerFQDNResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap*, const char*, _sai__SetConfigurationServerFQDNResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDN +#define SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDN (1558) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetConfigurationServerFQDN(struct soap*, _sai__SetConfigurationServerFQDN *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetConfigurationServerFQDN(struct soap*, _sai__SetConfigurationServerFQDN *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetConfigurationServerFQDN(struct soap*, const char *, int, _sai__SetConfigurationServerFQDN *const*, const char *); +SOAP_FMAC3 _sai__SetConfigurationServerFQDN ** SOAP_FMAC4 soap_get_PointerTo_sai__SetConfigurationServerFQDN(struct soap*, _sai__SetConfigurationServerFQDN **, const char*, const char*); +SOAP_FMAC3 _sai__SetConfigurationServerFQDN ** SOAP_FMAC4 soap_in_PointerTo_sai__SetConfigurationServerFQDN(struct soap*, const char*, _sai__SetConfigurationServerFQDN **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDNResponse +#define SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDNResponse (1555) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap*, _sai__GetConfigurationServerFQDNResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap*, _sai__GetConfigurationServerFQDNResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap*, const char *, int, _sai__GetConfigurationServerFQDNResponse *const*, const char *); +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap*, _sai__GetConfigurationServerFQDNResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap*, const char*, _sai__GetConfigurationServerFQDNResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDN +#define SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDN (1554) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetConfigurationServerFQDN(struct soap*, _sai__GetConfigurationServerFQDN *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetConfigurationServerFQDN(struct soap*, _sai__GetConfigurationServerFQDN *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetConfigurationServerFQDN(struct soap*, const char *, int, _sai__GetConfigurationServerFQDN *const*, const char *); +SOAP_FMAC3 _sai__GetConfigurationServerFQDN ** SOAP_FMAC4 soap_get_PointerTo_sai__GetConfigurationServerFQDN(struct soap*, _sai__GetConfigurationServerFQDN **, const char*, const char*); +SOAP_FMAC3 _sai__GetConfigurationServerFQDN ** SOAP_FMAC4 soap_in_PointerTo_sai__GetConfigurationServerFQDN(struct soap*, const char*, _sai__GetConfigurationServerFQDN **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnableVpnRoutingResponse +#define SOAP_TYPE_PointerTo_sai__EnableVpnRoutingResponse (1551) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnableVpnRoutingResponse(struct soap*, _sai__EnableVpnRoutingResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnableVpnRoutingResponse(struct soap*, _sai__EnableVpnRoutingResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnableVpnRoutingResponse(struct soap*, const char *, int, _sai__EnableVpnRoutingResponse *const*, const char *); +SOAP_FMAC3 _sai__EnableVpnRoutingResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnableVpnRoutingResponse(struct soap*, _sai__EnableVpnRoutingResponse **, const char*, const char*); +SOAP_FMAC3 _sai__EnableVpnRoutingResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnableVpnRoutingResponse(struct soap*, const char*, _sai__EnableVpnRoutingResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnableVpnRouting +#define SOAP_TYPE_PointerTo_sai__EnableVpnRouting (1550) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnableVpnRouting(struct soap*, _sai__EnableVpnRouting *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnableVpnRouting(struct soap*, _sai__EnableVpnRouting *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnableVpnRouting(struct soap*, const char *, int, _sai__EnableVpnRouting *const*, const char *); +SOAP_FMAC3 _sai__EnableVpnRouting ** SOAP_FMAC4 soap_get_PointerTo_sai__EnableVpnRouting(struct soap*, _sai__EnableVpnRouting **, const char*, const char*); +SOAP_FMAC3 _sai__EnableVpnRouting ** SOAP_FMAC4 soap_in_PointerTo_sai__EnableVpnRouting(struct soap*, const char*, _sai__EnableVpnRouting **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTLSCredentialsResponse +#define SOAP_TYPE_PointerTo_sai__GetTLSCredentialsResponse (1547) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTLSCredentialsResponse(struct soap*, _sai__GetTLSCredentialsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTLSCredentialsResponse(struct soap*, _sai__GetTLSCredentialsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTLSCredentialsResponse(struct soap*, const char *, int, _sai__GetTLSCredentialsResponse *const*, const char *); +SOAP_FMAC3 _sai__GetTLSCredentialsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTLSCredentialsResponse(struct soap*, _sai__GetTLSCredentialsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetTLSCredentialsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTLSCredentialsResponse(struct soap*, const char*, _sai__GetTLSCredentialsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTLSCredentials +#define SOAP_TYPE_PointerTo_sai__GetTLSCredentials (1546) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTLSCredentials(struct soap*, _sai__GetTLSCredentials *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTLSCredentials(struct soap*, _sai__GetTLSCredentials *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTLSCredentials(struct soap*, const char *, int, _sai__GetTLSCredentials *const*, const char *); +SOAP_FMAC3 _sai__GetTLSCredentials ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTLSCredentials(struct soap*, _sai__GetTLSCredentials **, const char*, const char*); +SOAP_FMAC3 _sai__GetTLSCredentials ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTLSCredentials(struct soap*, const char*, _sai__GetTLSCredentials **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTLSCredentialsResponse +#define SOAP_TYPE_PointerTo_sai__SetTLSCredentialsResponse (1543) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSCredentialsResponse(struct soap*, _sai__SetTLSCredentialsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSCredentialsResponse(struct soap*, _sai__SetTLSCredentialsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSCredentialsResponse(struct soap*, const char *, int, _sai__SetTLSCredentialsResponse *const*, const char *); +SOAP_FMAC3 _sai__SetTLSCredentialsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSCredentialsResponse(struct soap*, _sai__SetTLSCredentialsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSCredentialsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSCredentialsResponse(struct soap*, const char*, _sai__SetTLSCredentialsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTLSCredentials +#define SOAP_TYPE_PointerTo_sai__SetTLSCredentials (1542) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSCredentials(struct soap*, _sai__SetTLSCredentials *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSCredentials(struct soap*, _sai__SetTLSCredentials *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSCredentials(struct soap*, const char *, int, _sai__SetTLSCredentials *const*, const char *); +SOAP_FMAC3 _sai__SetTLSCredentials ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSCredentials(struct soap*, _sai__SetTLSCredentials **, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSCredentials ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSCredentials(struct soap*, const char*, _sai__SetTLSCredentials **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificateResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificateResponse (1539) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap*, _sai__CertStoreUpdateCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap*, _sai__CertStoreUpdateCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap*, const char *, int, _sai__CertStoreUpdateCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap*, _sai__CertStoreUpdateCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap*, const char*, _sai__CertStoreUpdateCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificate +#define SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificate (1538) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreUpdateCertificate(struct soap*, _sai__CertStoreUpdateCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreUpdateCertificate(struct soap*, _sai__CertStoreUpdateCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreUpdateCertificate(struct soap*, const char *, int, _sai__CertStoreUpdateCertificate *const*, const char *); +SOAP_FMAC3 _sai__CertStoreUpdateCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreUpdateCertificate(struct soap*, _sai__CertStoreUpdateCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreUpdateCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreUpdateCertificate(struct soap*, const char*, _sai__CertStoreUpdateCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10RequestResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10RequestResponse (1535) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap*, _sai__CertStoreGetPKCS10RequestResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap*, _sai__CertStoreGetPKCS10RequestResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap*, const char *, int, _sai__CertStoreGetPKCS10RequestResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap*, _sai__CertStoreGetPKCS10RequestResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap*, const char*, _sai__CertStoreGetPKCS10RequestResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10Request +#define SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10Request (1534) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetPKCS10Request(struct soap*, _sai__CertStoreGetPKCS10Request *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetPKCS10Request(struct soap*, _sai__CertStoreGetPKCS10Request *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetPKCS10Request(struct soap*, const char *, int, _sai__CertStoreGetPKCS10Request *const*, const char *); +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetPKCS10Request(struct soap*, _sai__CertStoreGetPKCS10Request **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetPKCS10Request(struct soap*, const char*, _sai__CertStoreGetPKCS10Request **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificateResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificateResponse (1531) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap*, _sai__CertStoreRemoveCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap*, _sai__CertStoreRemoveCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap*, const char *, int, _sai__CertStoreRemoveCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap*, _sai__CertStoreRemoveCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap*, const char*, _sai__CertStoreRemoveCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificate +#define SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificate (1530) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreRemoveCertificate(struct soap*, _sai__CertStoreRemoveCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreRemoveCertificate(struct soap*, _sai__CertStoreRemoveCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreRemoveCertificate(struct soap*, const char *, int, _sai__CertStoreRemoveCertificate *const*, const char *); +SOAP_FMAC3 _sai__CertStoreRemoveCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreRemoveCertificate(struct soap*, _sai__CertStoreRemoveCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreRemoveCertificate(struct soap*, const char*, _sai__CertStoreRemoveCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificatesResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificatesResponse (1527) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap*, _sai__CertStoreEnumerateCertificatesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap*, _sai__CertStoreEnumerateCertificatesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap*, const char *, int, _sai__CertStoreEnumerateCertificatesResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap*, _sai__CertStoreEnumerateCertificatesResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap*, const char*, _sai__CertStoreEnumerateCertificatesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificates +#define SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificates (1526) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreEnumerateCertificates(struct soap*, _sai__CertStoreEnumerateCertificates *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreEnumerateCertificates(struct soap*, _sai__CertStoreEnumerateCertificates *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreEnumerateCertificates(struct soap*, const char *, int, _sai__CertStoreEnumerateCertificates *const*, const char *); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreEnumerateCertificates(struct soap*, _sai__CertStoreEnumerateCertificates **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreEnumerateCertificates(struct soap*, const char*, _sai__CertStoreEnumerateCertificates **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreGetCertificateResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreGetCertificateResponse (1523) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetCertificateResponse(struct soap*, _sai__CertStoreGetCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetCertificateResponse(struct soap*, _sai__CertStoreGetCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetCertificateResponse(struct soap*, const char *, int, _sai__CertStoreGetCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetCertificateResponse(struct soap*, _sai__CertStoreGetCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetCertificateResponse(struct soap*, const char*, _sai__CertStoreGetCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreGetCertificate +#define SOAP_TYPE_PointerTo_sai__CertStoreGetCertificate (1522) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetCertificate(struct soap*, _sai__CertStoreGetCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetCertificate(struct soap*, _sai__CertStoreGetCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetCertificate(struct soap*, const char *, int, _sai__CertStoreGetCertificate *const*, const char *); +SOAP_FMAC3 _sai__CertStoreGetCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetCertificate(struct soap*, _sai__CertStoreGetCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetCertificate(struct soap*, const char*, _sai__CertStoreGetCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreAddCertificateResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreAddCertificateResponse (1519) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreAddCertificateResponse(struct soap*, _sai__CertStoreAddCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreAddCertificateResponse(struct soap*, _sai__CertStoreAddCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreAddCertificateResponse(struct soap*, const char *, int, _sai__CertStoreAddCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreAddCertificateResponse(struct soap*, _sai__CertStoreAddCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreAddCertificateResponse(struct soap*, const char*, _sai__CertStoreAddCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreAddCertificate +#define SOAP_TYPE_PointerTo_sai__CertStoreAddCertificate (1518) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreAddCertificate(struct soap*, _sai__CertStoreAddCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreAddCertificate(struct soap*, _sai__CertStoreAddCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreAddCertificate(struct soap*, const char *, int, _sai__CertStoreAddCertificate *const*, const char *); +SOAP_FMAC3 _sai__CertStoreAddCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreAddCertificate(struct soap*, _sai__CertStoreAddCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreAddCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreAddCertificate(struct soap*, const char*, _sai__CertStoreAddCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreRemoveKeyResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreRemoveKeyResponse (1515) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap*, _sai__CertStoreRemoveKeyResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap*, _sai__CertStoreRemoveKeyResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap*, const char *, int, _sai__CertStoreRemoveKeyResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap*, _sai__CertStoreRemoveKeyResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap*, const char*, _sai__CertStoreRemoveKeyResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreRemoveKey +#define SOAP_TYPE_PointerTo_sai__CertStoreRemoveKey (1514) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreRemoveKey(struct soap*, _sai__CertStoreRemoveKey *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreRemoveKey(struct soap*, _sai__CertStoreRemoveKey *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreRemoveKey(struct soap*, const char *, int, _sai__CertStoreRemoveKey *const*, const char *); +SOAP_FMAC3 _sai__CertStoreRemoveKey ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreRemoveKey(struct soap*, _sai__CertStoreRemoveKey **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreRemoveKey ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreRemoveKey(struct soap*, const char*, _sai__CertStoreRemoveKey **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreGetKeyResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreGetKeyResponse (1511) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetKeyResponse(struct soap*, _sai__CertStoreGetKeyResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetKeyResponse(struct soap*, _sai__CertStoreGetKeyResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetKeyResponse(struct soap*, const char *, int, _sai__CertStoreGetKeyResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreGetKeyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetKeyResponse(struct soap*, _sai__CertStoreGetKeyResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetKeyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetKeyResponse(struct soap*, const char*, _sai__CertStoreGetKeyResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreGetKey +#define SOAP_TYPE_PointerTo_sai__CertStoreGetKey (1510) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetKey(struct soap*, _sai__CertStoreGetKey *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetKey(struct soap*, _sai__CertStoreGetKey *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetKey(struct soap*, const char *, int, _sai__CertStoreGetKey *const*, const char *); +SOAP_FMAC3 _sai__CertStoreGetKey ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetKey(struct soap*, _sai__CertStoreGetKey **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreGetKey ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetKey(struct soap*, const char*, _sai__CertStoreGetKey **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeysResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeysResponse (1507) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap*, _sai__CertStoreEnumerateKeysResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap*, _sai__CertStoreEnumerateKeysResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap*, const char *, int, _sai__CertStoreEnumerateKeysResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap*, _sai__CertStoreEnumerateKeysResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap*, const char*, _sai__CertStoreEnumerateKeysResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeys +#define SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeys (1506) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreEnumerateKeys(struct soap*, _sai__CertStoreEnumerateKeys *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreEnumerateKeys(struct soap*, _sai__CertStoreEnumerateKeys *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreEnumerateKeys(struct soap*, const char *, int, _sai__CertStoreEnumerateKeys *const*, const char *); +SOAP_FMAC3 _sai__CertStoreEnumerateKeys ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreEnumerateKeys(struct soap*, _sai__CertStoreEnumerateKeys **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreEnumerateKeys ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreEnumerateKeys(struct soap*, const char*, _sai__CertStoreEnumerateKeys **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreAddKeyResponse +#define SOAP_TYPE_PointerTo_sai__CertStoreAddKeyResponse (1503) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreAddKeyResponse(struct soap*, _sai__CertStoreAddKeyResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreAddKeyResponse(struct soap*, _sai__CertStoreAddKeyResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreAddKeyResponse(struct soap*, const char *, int, _sai__CertStoreAddKeyResponse *const*, const char *); +SOAP_FMAC3 _sai__CertStoreAddKeyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreAddKeyResponse(struct soap*, _sai__CertStoreAddKeyResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreAddKeyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreAddKeyResponse(struct soap*, const char*, _sai__CertStoreAddKeyResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CertStoreAddKey +#define SOAP_TYPE_PointerTo_sai__CertStoreAddKey (1502) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreAddKey(struct soap*, _sai__CertStoreAddKey *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreAddKey(struct soap*, _sai__CertStoreAddKey *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreAddKey(struct soap*, const char *, int, _sai__CertStoreAddKey *const*, const char *); +SOAP_FMAC3 _sai__CertStoreAddKey ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreAddKey(struct soap*, _sai__CertStoreAddKey **, const char*, const char*); +SOAP_FMAC3 _sai__CertStoreAddKey ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreAddKey(struct soap*, const char*, _sai__CertStoreAddKey **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicyResponse +#define SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicyResponse (1499) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap*, _sai__GetGlobalPowerPolicyResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap*, _sai__GetGlobalPowerPolicyResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap*, const char *, int, _sai__GetGlobalPowerPolicyResponse *const*, const char *); +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap*, _sai__GetGlobalPowerPolicyResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap*, const char*, _sai__GetGlobalPowerPolicyResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicy +#define SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicy (1498) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetGlobalPowerPolicy(struct soap*, _sai__GetGlobalPowerPolicy *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetGlobalPowerPolicy(struct soap*, _sai__GetGlobalPowerPolicy *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetGlobalPowerPolicy(struct soap*, const char *, int, _sai__GetGlobalPowerPolicy *const*, const char *); +SOAP_FMAC3 _sai__GetGlobalPowerPolicy ** SOAP_FMAC4 soap_get_PointerTo_sai__GetGlobalPowerPolicy(struct soap*, _sai__GetGlobalPowerPolicy **, const char*, const char*); +SOAP_FMAC3 _sai__GetGlobalPowerPolicy ** SOAP_FMAC4 soap_in_PointerTo_sai__GetGlobalPowerPolicy(struct soap*, const char*, _sai__GetGlobalPowerPolicy **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicyResponse +#define SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicyResponse (1495) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap*, _sai__SetGlobalPowerPolicyResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap*, _sai__SetGlobalPowerPolicyResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap*, const char *, int, _sai__SetGlobalPowerPolicyResponse *const*, const char *); +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap*, _sai__SetGlobalPowerPolicyResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap*, const char*, _sai__SetGlobalPowerPolicyResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicy +#define SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicy (1494) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetGlobalPowerPolicy(struct soap*, _sai__SetGlobalPowerPolicy *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetGlobalPowerPolicy(struct soap*, _sai__SetGlobalPowerPolicy *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetGlobalPowerPolicy(struct soap*, const char *, int, _sai__SetGlobalPowerPolicy *const*, const char *); +SOAP_FMAC3 _sai__SetGlobalPowerPolicy ** SOAP_FMAC4 soap_get_PointerTo_sai__SetGlobalPowerPolicy(struct soap*, _sai__SetGlobalPowerPolicy **, const char*, const char*); +SOAP_FMAC3 _sai__SetGlobalPowerPolicy ** SOAP_FMAC4 soap_in_PointerTo_sai__SetGlobalPowerPolicy(struct soap*, const char*, _sai__SetGlobalPowerPolicy **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetActivePowerPackageResponse +#define SOAP_TYPE_PointerTo_sai__SetActivePowerPackageResponse (1491) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetActivePowerPackageResponse(struct soap*, _sai__SetActivePowerPackageResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetActivePowerPackageResponse(struct soap*, _sai__SetActivePowerPackageResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetActivePowerPackageResponse(struct soap*, const char *, int, _sai__SetActivePowerPackageResponse *const*, const char *); +SOAP_FMAC3 _sai__SetActivePowerPackageResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetActivePowerPackageResponse(struct soap*, _sai__SetActivePowerPackageResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetActivePowerPackageResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetActivePowerPackageResponse(struct soap*, const char*, _sai__SetActivePowerPackageResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetActivePowerPackage +#define SOAP_TYPE_PointerTo_sai__SetActivePowerPackage (1490) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetActivePowerPackage(struct soap*, _sai__SetActivePowerPackage *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetActivePowerPackage(struct soap*, _sai__SetActivePowerPackage *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetActivePowerPackage(struct soap*, const char *, int, _sai__SetActivePowerPackage *const*, const char *); +SOAP_FMAC3 _sai__SetActivePowerPackage ** SOAP_FMAC4 soap_get_PointerTo_sai__SetActivePowerPackage(struct soap*, _sai__SetActivePowerPackage **, const char*, const char*); +SOAP_FMAC3 _sai__SetActivePowerPackage ** SOAP_FMAC4 soap_in_PointerTo_sai__SetActivePowerPackage(struct soap*, const char*, _sai__SetActivePowerPackage **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetActivePowerPackageResponse +#define SOAP_TYPE_PointerTo_sai__GetActivePowerPackageResponse (1487) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetActivePowerPackageResponse(struct soap*, _sai__GetActivePowerPackageResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetActivePowerPackageResponse(struct soap*, _sai__GetActivePowerPackageResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetActivePowerPackageResponse(struct soap*, const char *, int, _sai__GetActivePowerPackageResponse *const*, const char *); +SOAP_FMAC3 _sai__GetActivePowerPackageResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetActivePowerPackageResponse(struct soap*, _sai__GetActivePowerPackageResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetActivePowerPackageResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetActivePowerPackageResponse(struct soap*, const char*, _sai__GetActivePowerPackageResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetActivePowerPackage +#define SOAP_TYPE_PointerTo_sai__GetActivePowerPackage (1486) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetActivePowerPackage(struct soap*, _sai__GetActivePowerPackage *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetActivePowerPackage(struct soap*, _sai__GetActivePowerPackage *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetActivePowerPackage(struct soap*, const char *, int, _sai__GetActivePowerPackage *const*, const char *); +SOAP_FMAC3 _sai__GetActivePowerPackage ** SOAP_FMAC4 soap_get_PointerTo_sai__GetActivePowerPackage(struct soap*, _sai__GetActivePowerPackage **, const char*, const char*); +SOAP_FMAC3 _sai__GetActivePowerPackage ** SOAP_FMAC4 soap_in_PointerTo_sai__GetActivePowerPackage(struct soap*, const char*, _sai__GetActivePowerPackage **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetPowerPackageResponse +#define SOAP_TYPE_PointerTo_sai__GetPowerPackageResponse (1483) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPowerPackageResponse(struct soap*, _sai__GetPowerPackageResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPowerPackageResponse(struct soap*, _sai__GetPowerPackageResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPowerPackageResponse(struct soap*, const char *, int, _sai__GetPowerPackageResponse *const*, const char *); +SOAP_FMAC3 _sai__GetPowerPackageResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPowerPackageResponse(struct soap*, _sai__GetPowerPackageResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetPowerPackageResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPowerPackageResponse(struct soap*, const char*, _sai__GetPowerPackageResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetPowerPackage +#define SOAP_TYPE_PointerTo_sai__GetPowerPackage (1482) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPowerPackage(struct soap*, _sai__GetPowerPackage *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPowerPackage(struct soap*, _sai__GetPowerPackage *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPowerPackage(struct soap*, const char *, int, _sai__GetPowerPackage *const*, const char *); +SOAP_FMAC3 _sai__GetPowerPackage ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPowerPackage(struct soap*, _sai__GetPowerPackage **, const char*, const char*); +SOAP_FMAC3 _sai__GetPowerPackage ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPowerPackage(struct soap*, const char*, _sai__GetPowerPackage **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnumeratePowerPackagesResponse +#define SOAP_TYPE_PointerTo_sai__EnumeratePowerPackagesResponse (1479) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap*, _sai__EnumeratePowerPackagesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap*, _sai__EnumeratePowerPackagesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap*, const char *, int, _sai__EnumeratePowerPackagesResponse *const*, const char *); +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap*, _sai__EnumeratePowerPackagesResponse **, const char*, const char*); +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap*, const char*, _sai__EnumeratePowerPackagesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnumeratePowerPackages +#define SOAP_TYPE_PointerTo_sai__EnumeratePowerPackages (1478) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumeratePowerPackages(struct soap*, _sai__EnumeratePowerPackages *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumeratePowerPackages(struct soap*, _sai__EnumeratePowerPackages *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumeratePowerPackages(struct soap*, const char *, int, _sai__EnumeratePowerPackages *const*, const char *); +SOAP_FMAC3 _sai__EnumeratePowerPackages ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumeratePowerPackages(struct soap*, _sai__EnumeratePowerPackages **, const char*, const char*); +SOAP_FMAC3 _sai__EnumeratePowerPackages ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumeratePowerPackages(struct soap*, const char*, _sai__EnumeratePowerPackages **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetEnvironmentDetectionResponse +#define SOAP_TYPE_PointerTo_sai__GetEnvironmentDetectionResponse (1475) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap*, _sai__GetEnvironmentDetectionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap*, _sai__GetEnvironmentDetectionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap*, const char *, int, _sai__GetEnvironmentDetectionResponse *const*, const char *); +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap*, _sai__GetEnvironmentDetectionResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap*, const char*, _sai__GetEnvironmentDetectionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetEnvironmentDetection +#define SOAP_TYPE_PointerTo_sai__GetEnvironmentDetection (1474) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetEnvironmentDetection(struct soap*, _sai__GetEnvironmentDetection *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetEnvironmentDetection(struct soap*, _sai__GetEnvironmentDetection *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetEnvironmentDetection(struct soap*, const char *, int, _sai__GetEnvironmentDetection *const*, const char *); +SOAP_FMAC3 _sai__GetEnvironmentDetection ** SOAP_FMAC4 soap_get_PointerTo_sai__GetEnvironmentDetection(struct soap*, _sai__GetEnvironmentDetection **, const char*, const char*); +SOAP_FMAC3 _sai__GetEnvironmentDetection ** SOAP_FMAC4 soap_in_PointerTo_sai__GetEnvironmentDetection(struct soap*, const char*, _sai__GetEnvironmentDetection **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetEnvironmentDetectionResponse +#define SOAP_TYPE_PointerTo_sai__SetEnvironmentDetectionResponse (1471) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap*, _sai__SetEnvironmentDetectionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap*, _sai__SetEnvironmentDetectionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap*, const char *, int, _sai__SetEnvironmentDetectionResponse *const*, const char *); +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap*, _sai__SetEnvironmentDetectionResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap*, const char*, _sai__SetEnvironmentDetectionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetEnvironmentDetection +#define SOAP_TYPE_PointerTo_sai__SetEnvironmentDetection (1470) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetEnvironmentDetection(struct soap*, _sai__SetEnvironmentDetection *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetEnvironmentDetection(struct soap*, _sai__SetEnvironmentDetection *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetEnvironmentDetection(struct soap*, const char *, int, _sai__SetEnvironmentDetection *const*, const char *); +SOAP_FMAC3 _sai__SetEnvironmentDetection ** SOAP_FMAC4 soap_get_PointerTo_sai__SetEnvironmentDetection(struct soap*, _sai__SetEnvironmentDetection **, const char*, const char*); +SOAP_FMAC3 _sai__SetEnvironmentDetection ** SOAP_FMAC4 soap_in_PointerTo_sai__SetEnvironmentDetection(struct soap*, const char*, _sai__SetEnvironmentDetection **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetRealmAuthOptionsResponse +#define SOAP_TYPE_PointerTo_sai__SetRealmAuthOptionsResponse (1467) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap*, _sai__SetRealmAuthOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap*, _sai__SetRealmAuthOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap*, const char *, int, _sai__SetRealmAuthOptionsResponse *const*, const char *); +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap*, _sai__SetRealmAuthOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap*, const char*, _sai__SetRealmAuthOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetRealmAuthOptions +#define SOAP_TYPE_PointerTo_sai__SetRealmAuthOptions (1466) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetRealmAuthOptions(struct soap*, _sai__SetRealmAuthOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetRealmAuthOptions(struct soap*, _sai__SetRealmAuthOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetRealmAuthOptions(struct soap*, const char *, int, _sai__SetRealmAuthOptions *const*, const char *); +SOAP_FMAC3 _sai__SetRealmAuthOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__SetRealmAuthOptions(struct soap*, _sai__SetRealmAuthOptions **, const char*, const char*); +SOAP_FMAC3 _sai__SetRealmAuthOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__SetRealmAuthOptions(struct soap*, const char*, _sai__SetRealmAuthOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetRealmAuthOptionsResponse +#define SOAP_TYPE_PointerTo_sai__GetRealmAuthOptionsResponse (1463) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap*, _sai__GetRealmAuthOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap*, _sai__GetRealmAuthOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap*, const char *, int, _sai__GetRealmAuthOptionsResponse *const*, const char *); +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap*, _sai__GetRealmAuthOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap*, const char*, _sai__GetRealmAuthOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetRealmAuthOptions +#define SOAP_TYPE_PointerTo_sai__GetRealmAuthOptions (1462) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetRealmAuthOptions(struct soap*, _sai__GetRealmAuthOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetRealmAuthOptions(struct soap*, _sai__GetRealmAuthOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetRealmAuthOptions(struct soap*, const char *, int, _sai__GetRealmAuthOptions *const*, const char *); +SOAP_FMAC3 _sai__GetRealmAuthOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__GetRealmAuthOptions(struct soap*, _sai__GetRealmAuthOptions **, const char*, const char*); +SOAP_FMAC3 _sai__GetRealmAuthOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__GetRealmAuthOptions(struct soap*, const char*, _sai__GetRealmAuthOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriodResponse +#define SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriodResponse (1459) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap*, _sai__ExtendProvisioningPeriodResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap*, _sai__ExtendProvisioningPeriodResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap*, const char *, int, _sai__ExtendProvisioningPeriodResponse *const*, const char *); +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap*, _sai__ExtendProvisioningPeriodResponse **, const char*, const char*); +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap*, const char*, _sai__ExtendProvisioningPeriodResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriod +#define SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriod (1458) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__ExtendProvisioningPeriod(struct soap*, _sai__ExtendProvisioningPeriod *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__ExtendProvisioningPeriod(struct soap*, _sai__ExtendProvisioningPeriod *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__ExtendProvisioningPeriod(struct soap*, const char *, int, _sai__ExtendProvisioningPeriod *const*, const char *); +SOAP_FMAC3 _sai__ExtendProvisioningPeriod ** SOAP_FMAC4 soap_get_PointerTo_sai__ExtendProvisioningPeriod(struct soap*, _sai__ExtendProvisioningPeriod **, const char*, const char*); +SOAP_FMAC3 _sai__ExtendProvisioningPeriod ** SOAP_FMAC4 soap_in_PointerTo_sai__ExtendProvisioningPeriod(struct soap*, const char*, _sai__ExtendProvisioningPeriod **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetProvisioningPIDResponse +#define SOAP_TYPE_PointerTo_sai__GetProvisioningPIDResponse (1455) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningPIDResponse(struct soap*, _sai__GetProvisioningPIDResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningPIDResponse(struct soap*, _sai__GetProvisioningPIDResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningPIDResponse(struct soap*, const char *, int, _sai__GetProvisioningPIDResponse *const*, const char *); +SOAP_FMAC3 _sai__GetProvisioningPIDResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningPIDResponse(struct soap*, _sai__GetProvisioningPIDResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningPIDResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningPIDResponse(struct soap*, const char*, _sai__GetProvisioningPIDResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetProvisioningPID +#define SOAP_TYPE_PointerTo_sai__GetProvisioningPID (1454) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningPID(struct soap*, _sai__GetProvisioningPID *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningPID(struct soap*, _sai__GetProvisioningPID *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningPID(struct soap*, const char *, int, _sai__GetProvisioningPID *const*, const char *); +SOAP_FMAC3 _sai__GetProvisioningPID ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningPID(struct soap*, _sai__GetProvisioningPID **, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningPID ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningPID(struct soap*, const char*, _sai__GetProvisioningPID **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecordResponse +#define SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecordResponse (1451) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap*, _sai__GetProvisioningAuditRecordResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap*, _sai__GetProvisioningAuditRecordResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap*, const char *, int, _sai__GetProvisioningAuditRecordResponse *const*, const char *); +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap*, _sai__GetProvisioningAuditRecordResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap*, const char*, _sai__GetProvisioningAuditRecordResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecord +#define SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecord (1450) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningAuditRecord(struct soap*, _sai__GetProvisioningAuditRecord *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningAuditRecord(struct soap*, _sai__GetProvisioningAuditRecord *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningAuditRecord(struct soap*, const char *, int, _sai__GetProvisioningAuditRecord *const*, const char *); +SOAP_FMAC3 _sai__GetProvisioningAuditRecord ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningAuditRecord(struct soap*, _sai__GetProvisioningAuditRecord **, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningAuditRecord ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningAuditRecord(struct soap*, const char*, _sai__GetProvisioningAuditRecord **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationModeResponse +#define SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationModeResponse (1447) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap*, _sai__SetZeroTouchConfigurationModeResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap*, _sai__SetZeroTouchConfigurationModeResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap*, const char *, int, _sai__SetZeroTouchConfigurationModeResponse *const*, const char *); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap*, _sai__SetZeroTouchConfigurationModeResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap*, const char*, _sai__SetZeroTouchConfigurationModeResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationMode +#define SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationMode (1446) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap*, _sai__SetZeroTouchConfigurationMode *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap*, _sai__SetZeroTouchConfigurationMode *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap*, const char *, int, _sai__SetZeroTouchConfigurationMode *const*, const char *); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode ** SOAP_FMAC4 soap_get_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap*, _sai__SetZeroTouchConfigurationMode **, const char*, const char*); +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode ** SOAP_FMAC4 soap_in_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap*, const char*, _sai__SetZeroTouchConfigurationMode **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationModeResponse +#define SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationModeResponse (1443) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap*, _sai__GetZeroTouchConfigurationModeResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap*, _sai__GetZeroTouchConfigurationModeResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap*, const char *, int, _sai__GetZeroTouchConfigurationModeResponse *const*, const char *); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap*, _sai__GetZeroTouchConfigurationModeResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap*, const char*, _sai__GetZeroTouchConfigurationModeResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationMode +#define SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationMode (1442) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap*, _sai__GetZeroTouchConfigurationMode *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap*, _sai__GetZeroTouchConfigurationMode *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap*, const char *, int, _sai__GetZeroTouchConfigurationMode *const*, const char *); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode ** SOAP_FMAC4 soap_get_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap*, _sai__GetZeroTouchConfigurationMode **, const char*, const char*); +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode ** SOAP_FMAC4 soap_in_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap*, const char*, _sai__GetZeroTouchConfigurationMode **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntryResponse +#define SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntryResponse (1439) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap*, _sai__EnableCertificateHashEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap*, _sai__EnableCertificateHashEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap*, const char *, int, _sai__EnableCertificateHashEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap*, _sai__EnableCertificateHashEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap*, const char*, _sai__EnableCertificateHashEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntry +#define SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntry (1438) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnableCertificateHashEntry(struct soap*, _sai__EnableCertificateHashEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnableCertificateHashEntry(struct soap*, _sai__EnableCertificateHashEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnableCertificateHashEntry(struct soap*, const char *, int, _sai__EnableCertificateHashEntry *const*, const char *); +SOAP_FMAC3 _sai__EnableCertificateHashEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__EnableCertificateHashEntry(struct soap*, _sai__EnableCertificateHashEntry **, const char*, const char*); +SOAP_FMAC3 _sai__EnableCertificateHashEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__EnableCertificateHashEntry(struct soap*, const char*, _sai__EnableCertificateHashEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntryResponse +#define SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntryResponse (1435) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap*, _sai__DeleteCertificateHashEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap*, _sai__DeleteCertificateHashEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap*, const char *, int, _sai__DeleteCertificateHashEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap*, _sai__DeleteCertificateHashEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap*, const char*, _sai__DeleteCertificateHashEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntry +#define SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntry (1434) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__DeleteCertificateHashEntry(struct soap*, _sai__DeleteCertificateHashEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__DeleteCertificateHashEntry(struct soap*, _sai__DeleteCertificateHashEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__DeleteCertificateHashEntry(struct soap*, const char *, int, _sai__DeleteCertificateHashEntry *const*, const char *); +SOAP_FMAC3 _sai__DeleteCertificateHashEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__DeleteCertificateHashEntry(struct soap*, _sai__DeleteCertificateHashEntry **, const char*, const char*); +SOAP_FMAC3 _sai__DeleteCertificateHashEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__DeleteCertificateHashEntry(struct soap*, const char*, _sai__DeleteCertificateHashEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__AddCertificateHashEntryResponse +#define SOAP_TYPE_PointerTo_sai__AddCertificateHashEntryResponse (1431) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddCertificateHashEntryResponse(struct soap*, _sai__AddCertificateHashEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddCertificateHashEntryResponse(struct soap*, _sai__AddCertificateHashEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddCertificateHashEntryResponse(struct soap*, const char *, int, _sai__AddCertificateHashEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__AddCertificateHashEntryResponse(struct soap*, _sai__AddCertificateHashEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__AddCertificateHashEntryResponse(struct soap*, const char*, _sai__AddCertificateHashEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__AddCertificateHashEntry +#define SOAP_TYPE_PointerTo_sai__AddCertificateHashEntry (1430) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddCertificateHashEntry(struct soap*, _sai__AddCertificateHashEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddCertificateHashEntry(struct soap*, _sai__AddCertificateHashEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddCertificateHashEntry(struct soap*, const char *, int, _sai__AddCertificateHashEntry *const*, const char *); +SOAP_FMAC3 _sai__AddCertificateHashEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__AddCertificateHashEntry(struct soap*, _sai__AddCertificateHashEntry **, const char*, const char*); +SOAP_FMAC3 _sai__AddCertificateHashEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__AddCertificateHashEntry(struct soap*, const char*, _sai__AddCertificateHashEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetCertificateHashEntryResponse +#define SOAP_TYPE_PointerTo_sai__GetCertificateHashEntryResponse (1427) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCertificateHashEntryResponse(struct soap*, _sai__GetCertificateHashEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCertificateHashEntryResponse(struct soap*, _sai__GetCertificateHashEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCertificateHashEntryResponse(struct soap*, const char *, int, _sai__GetCertificateHashEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCertificateHashEntryResponse(struct soap*, _sai__GetCertificateHashEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCertificateHashEntryResponse(struct soap*, const char*, _sai__GetCertificateHashEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetCertificateHashEntry +#define SOAP_TYPE_PointerTo_sai__GetCertificateHashEntry (1426) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCertificateHashEntry(struct soap*, _sai__GetCertificateHashEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCertificateHashEntry(struct soap*, _sai__GetCertificateHashEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCertificateHashEntry(struct soap*, const char *, int, _sai__GetCertificateHashEntry *const*, const char *); +SOAP_FMAC3 _sai__GetCertificateHashEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCertificateHashEntry(struct soap*, _sai__GetCertificateHashEntry **, const char*, const char*); +SOAP_FMAC3 _sai__GetCertificateHashEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCertificateHashEntry(struct soap*, const char*, _sai__GetCertificateHashEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntriesResponse +#define SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntriesResponse (1423) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap*, _sai__EnumerateCertificateHashEntriesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap*, _sai__EnumerateCertificateHashEntriesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap*, const char *, int, _sai__EnumerateCertificateHashEntriesResponse *const*, const char *); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap*, _sai__EnumerateCertificateHashEntriesResponse **, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap*, const char*, _sai__EnumerateCertificateHashEntriesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntries +#define SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntries (1422) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateCertificateHashEntries(struct soap*, _sai__EnumerateCertificateHashEntries *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateCertificateHashEntries(struct soap*, _sai__EnumerateCertificateHashEntries *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateCertificateHashEntries(struct soap*, const char *, int, _sai__EnumerateCertificateHashEntries *const*, const char *); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateCertificateHashEntries(struct soap*, _sai__EnumerateCertificateHashEntries **, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateCertificateHashEntries(struct soap*, const char*, _sai__EnumerateCertificateHashEntries **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTPResponse +#define SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTPResponse (1419) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap*, _sai__GetProvisioningServerOTPResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap*, _sai__GetProvisioningServerOTPResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap*, const char *, int, _sai__GetProvisioningServerOTPResponse *const*, const char *); +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap*, _sai__GetProvisioningServerOTPResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap*, const char*, _sai__GetProvisioningServerOTPResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTP +#define SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTP (1418) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningServerOTP(struct soap*, _sai__GetProvisioningServerOTP *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningServerOTP(struct soap*, _sai__GetProvisioningServerOTP *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningServerOTP(struct soap*, const char *, int, _sai__GetProvisioningServerOTP *const*, const char *); +SOAP_FMAC3 _sai__GetProvisioningServerOTP ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningServerOTP(struct soap*, _sai__GetProvisioningServerOTP **, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningServerOTP ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningServerOTP(struct soap*, const char*, _sai__GetProvisioningServerOTP **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTPResponse +#define SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTPResponse (1415) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap*, _sai__SetProvisioningServerOTPResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap*, _sai__SetProvisioningServerOTPResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap*, const char *, int, _sai__SetProvisioningServerOTPResponse *const*, const char *); +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap*, _sai__SetProvisioningServerOTPResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap*, const char*, _sai__SetProvisioningServerOTPResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTP +#define SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTP (1414) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetProvisioningServerOTP(struct soap*, _sai__SetProvisioningServerOTP *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetProvisioningServerOTP(struct soap*, _sai__SetProvisioningServerOTP *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetProvisioningServerOTP(struct soap*, const char *, int, _sai__SetProvisioningServerOTP *const*, const char *); +SOAP_FMAC3 _sai__SetProvisioningServerOTP ** SOAP_FMAC4 soap_get_PointerTo_sai__SetProvisioningServerOTP(struct soap*, _sai__SetProvisioningServerOTP **, const char*, const char*); +SOAP_FMAC3 _sai__SetProvisioningServerOTP ** SOAP_FMAC4 soap_in_PointerTo_sai__SetProvisioningServerOTP(struct soap*, const char*, _sai__SetProvisioningServerOTP **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetMEBxPasswordResponse +#define SOAP_TYPE_PointerTo_sai__SetMEBxPasswordResponse (1411) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetMEBxPasswordResponse(struct soap*, _sai__SetMEBxPasswordResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetMEBxPasswordResponse(struct soap*, _sai__SetMEBxPasswordResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetMEBxPasswordResponse(struct soap*, const char *, int, _sai__SetMEBxPasswordResponse *const*, const char *); +SOAP_FMAC3 _sai__SetMEBxPasswordResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetMEBxPasswordResponse(struct soap*, _sai__SetMEBxPasswordResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetMEBxPasswordResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetMEBxPasswordResponse(struct soap*, const char*, _sai__SetMEBxPasswordResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetMEBxPassword +#define SOAP_TYPE_PointerTo_sai__SetMEBxPassword (1410) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetMEBxPassword(struct soap*, _sai__SetMEBxPassword *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetMEBxPassword(struct soap*, _sai__SetMEBxPassword *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetMEBxPassword(struct soap*, const char *, int, _sai__SetMEBxPassword *const*, const char *); +SOAP_FMAC3 _sai__SetMEBxPassword ** SOAP_FMAC4 soap_get_PointerTo_sai__SetMEBxPassword(struct soap*, _sai__SetMEBxPassword **, const char*, const char*); +SOAP_FMAC3 _sai__SetMEBxPassword ** SOAP_FMAC4 soap_in_PointerTo_sai__SetMEBxPassword(struct soap*, const char*, _sai__SetMEBxPassword **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__PartialUnprovisionResponse +#define SOAP_TYPE_PointerTo_sai__PartialUnprovisionResponse (1407) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__PartialUnprovisionResponse(struct soap*, _sai__PartialUnprovisionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__PartialUnprovisionResponse(struct soap*, _sai__PartialUnprovisionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__PartialUnprovisionResponse(struct soap*, const char *, int, _sai__PartialUnprovisionResponse *const*, const char *); +SOAP_FMAC3 _sai__PartialUnprovisionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__PartialUnprovisionResponse(struct soap*, _sai__PartialUnprovisionResponse **, const char*, const char*); +SOAP_FMAC3 _sai__PartialUnprovisionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__PartialUnprovisionResponse(struct soap*, const char*, _sai__PartialUnprovisionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__PartialUnprovision +#define SOAP_TYPE_PointerTo_sai__PartialUnprovision (1406) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__PartialUnprovision(struct soap*, _sai__PartialUnprovision *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__PartialUnprovision(struct soap*, _sai__PartialUnprovision *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__PartialUnprovision(struct soap*, const char *, int, _sai__PartialUnprovision *const*, const char *); +SOAP_FMAC3 _sai__PartialUnprovision ** SOAP_FMAC4 soap_get_PointerTo_sai__PartialUnprovision(struct soap*, _sai__PartialUnprovision **, const char*, const char*); +SOAP_FMAC3 _sai__PartialUnprovision ** SOAP_FMAC4 soap_in_PointerTo_sai__PartialUnprovision(struct soap*, const char*, _sai__PartialUnprovision **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTLSPSKResponse +#define SOAP_TYPE_PointerTo_sai__SetTLSPSKResponse (1403) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSPSKResponse(struct soap*, _sai__SetTLSPSKResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSPSKResponse(struct soap*, _sai__SetTLSPSKResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSPSKResponse(struct soap*, const char *, int, _sai__SetTLSPSKResponse *const*, const char *); +SOAP_FMAC3 _sai__SetTLSPSKResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSPSKResponse(struct soap*, _sai__SetTLSPSKResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSPSKResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSPSKResponse(struct soap*, const char*, _sai__SetTLSPSKResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTLSPSK +#define SOAP_TYPE_PointerTo_sai__SetTLSPSK (1402) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSPSK(struct soap*, _sai__SetTLSPSK *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSPSK(struct soap*, _sai__SetTLSPSK *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSPSK(struct soap*, const char *, int, _sai__SetTLSPSK *const*, const char *); +SOAP_FMAC3 _sai__SetTLSPSK ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSPSK(struct soap*, _sai__SetTLSPSK **, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSPSK ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSPSK(struct soap*, const char*, _sai__SetTLSPSK **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetPowerSavingOptionsResponse +#define SOAP_TYPE_PointerTo_sai__GetPowerSavingOptionsResponse (1399) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap*, _sai__GetPowerSavingOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap*, _sai__GetPowerSavingOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap*, const char *, int, _sai__GetPowerSavingOptionsResponse *const*, const char *); +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap*, _sai__GetPowerSavingOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap*, const char*, _sai__GetPowerSavingOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetPowerSavingOptions +#define SOAP_TYPE_PointerTo_sai__GetPowerSavingOptions (1398) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPowerSavingOptions(struct soap*, _sai__GetPowerSavingOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPowerSavingOptions(struct soap*, _sai__GetPowerSavingOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPowerSavingOptions(struct soap*, const char *, int, _sai__GetPowerSavingOptions *const*, const char *); +SOAP_FMAC3 _sai__GetPowerSavingOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPowerSavingOptions(struct soap*, _sai__GetPowerSavingOptions **, const char*, const char*); +SOAP_FMAC3 _sai__GetPowerSavingOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPowerSavingOptions(struct soap*, const char*, _sai__GetPowerSavingOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetPowerSavingOptionsResponse +#define SOAP_TYPE_PointerTo_sai__SetPowerSavingOptionsResponse (1395) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap*, _sai__SetPowerSavingOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap*, _sai__SetPowerSavingOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap*, const char *, int, _sai__SetPowerSavingOptionsResponse *const*, const char *); +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap*, _sai__SetPowerSavingOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap*, const char*, _sai__SetPowerSavingOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetPowerSavingOptions +#define SOAP_TYPE_PointerTo_sai__SetPowerSavingOptions (1394) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetPowerSavingOptions(struct soap*, _sai__SetPowerSavingOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetPowerSavingOptions(struct soap*, _sai__SetPowerSavingOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetPowerSavingOptions(struct soap*, const char *, int, _sai__SetPowerSavingOptions *const*, const char *); +SOAP_FMAC3 _sai__SetPowerSavingOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__SetPowerSavingOptions(struct soap*, _sai__SetPowerSavingOptions **, const char*, const char*); +SOAP_FMAC3 _sai__SetPowerSavingOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__SetPowerSavingOptions(struct soap*, const char*, _sai__SetPowerSavingOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetPkiCapabilitiesResponse +#define SOAP_TYPE_PointerTo_sai__GetPkiCapabilitiesResponse (1391) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap*, _sai__GetPkiCapabilitiesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap*, _sai__GetPkiCapabilitiesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap*, const char *, int, _sai__GetPkiCapabilitiesResponse *const*, const char *); +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap*, _sai__GetPkiCapabilitiesResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap*, const char*, _sai__GetPkiCapabilitiesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetPkiCapabilities +#define SOAP_TYPE_PointerTo_sai__GetPkiCapabilities (1390) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPkiCapabilities(struct soap*, _sai__GetPkiCapabilities *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPkiCapabilities(struct soap*, _sai__GetPkiCapabilities *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPkiCapabilities(struct soap*, const char *, int, _sai__GetPkiCapabilities *const*, const char *); +SOAP_FMAC3 _sai__GetPkiCapabilities ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPkiCapabilities(struct soap*, _sai__GetPkiCapabilities **, const char*, const char*); +SOAP_FMAC3 _sai__GetPkiCapabilities ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPkiCapabilities(struct soap*, const char*, _sai__GetPkiCapabilities **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetServerCertificateReqResponse +#define SOAP_TYPE_PointerTo_sai__GetServerCertificateReqResponse (1387) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetServerCertificateReqResponse(struct soap*, _sai__GetServerCertificateReqResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetServerCertificateReqResponse(struct soap*, _sai__GetServerCertificateReqResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetServerCertificateReqResponse(struct soap*, const char *, int, _sai__GetServerCertificateReqResponse *const*, const char *); +SOAP_FMAC3 _sai__GetServerCertificateReqResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetServerCertificateReqResponse(struct soap*, _sai__GetServerCertificateReqResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetServerCertificateReqResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetServerCertificateReqResponse(struct soap*, const char*, _sai__GetServerCertificateReqResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetServerCertificateReq +#define SOAP_TYPE_PointerTo_sai__GetServerCertificateReq (1386) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetServerCertificateReq(struct soap*, _sai__GetServerCertificateReq *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetServerCertificateReq(struct soap*, _sai__GetServerCertificateReq *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetServerCertificateReq(struct soap*, const char *, int, _sai__GetServerCertificateReq *const*, const char *); +SOAP_FMAC3 _sai__GetServerCertificateReq ** SOAP_FMAC4 soap_get_PointerTo_sai__GetServerCertificateReq(struct soap*, _sai__GetServerCertificateReq **, const char*, const char*); +SOAP_FMAC3 _sai__GetServerCertificateReq ** SOAP_FMAC4 soap_in_PointerTo_sai__GetServerCertificateReq(struct soap*, const char*, _sai__GetServerCertificateReq **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetCRLResponse +#define SOAP_TYPE_PointerTo_sai__GetCRLResponse (1383) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCRLResponse(struct soap*, _sai__GetCRLResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCRLResponse(struct soap*, _sai__GetCRLResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCRLResponse(struct soap*, const char *, int, _sai__GetCRLResponse *const*, const char *); +SOAP_FMAC3 _sai__GetCRLResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCRLResponse(struct soap*, _sai__GetCRLResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetCRLResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCRLResponse(struct soap*, const char*, _sai__GetCRLResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetCRL +#define SOAP_TYPE_PointerTo_sai__GetCRL (1382) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCRL(struct soap*, _sai__GetCRL *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCRL(struct soap*, _sai__GetCRL *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCRL(struct soap*, const char *, int, _sai__GetCRL *const*, const char *); +SOAP_FMAC3 _sai__GetCRL ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCRL(struct soap*, _sai__GetCRL **, const char*, const char*); +SOAP_FMAC3 _sai__GetCRL ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCRL(struct soap*, const char*, _sai__GetCRL **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetCRLResponse +#define SOAP_TYPE_PointerTo_sai__SetCRLResponse (1379) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetCRLResponse(struct soap*, _sai__SetCRLResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetCRLResponse(struct soap*, _sai__SetCRLResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetCRLResponse(struct soap*, const char *, int, _sai__SetCRLResponse *const*, const char *); +SOAP_FMAC3 _sai__SetCRLResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetCRLResponse(struct soap*, _sai__SetCRLResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetCRLResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetCRLResponse(struct soap*, const char*, _sai__SetCRLResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetCRL +#define SOAP_TYPE_PointerTo_sai__SetCRL (1378) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetCRL(struct soap*, _sai__SetCRL *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetCRL(struct soap*, _sai__SetCRL *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetCRL(struct soap*, const char *, int, _sai__SetCRL *const*, const char *); +SOAP_FMAC3 _sai__SetCRL ** SOAP_FMAC4 soap_get_PointerTo_sai__SetCRL(struct soap*, _sai__SetCRL **, const char*, const char*); +SOAP_FMAC3 _sai__SetCRL ** SOAP_FMAC4 soap_in_PointerTo_sai__SetCRL(struct soap*, const char*, _sai__SetCRL **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCNResponse +#define SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCNResponse (1375) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap*, _sai__GetTrustedFqdnCNResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap*, _sai__GetTrustedFqdnCNResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap*, const char *, int, _sai__GetTrustedFqdnCNResponse *const*, const char *); +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap*, _sai__GetTrustedFqdnCNResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap*, const char*, _sai__GetTrustedFqdnCNResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCN +#define SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCN (1374) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTrustedFqdnCN(struct soap*, _sai__GetTrustedFqdnCN *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTrustedFqdnCN(struct soap*, _sai__GetTrustedFqdnCN *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTrustedFqdnCN(struct soap*, const char *, int, _sai__GetTrustedFqdnCN *const*, const char *); +SOAP_FMAC3 _sai__GetTrustedFqdnCN ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTrustedFqdnCN(struct soap*, _sai__GetTrustedFqdnCN **, const char*, const char*); +SOAP_FMAC3 _sai__GetTrustedFqdnCN ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTrustedFqdnCN(struct soap*, const char*, _sai__GetTrustedFqdnCN **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCNResponse +#define SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCNResponse (1371) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap*, _sai__SetTrustedFqdnCNResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap*, _sai__SetTrustedFqdnCNResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap*, const char *, int, _sai__SetTrustedFqdnCNResponse *const*, const char *); +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap*, _sai__SetTrustedFqdnCNResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap*, const char*, _sai__SetTrustedFqdnCNResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCN +#define SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCN (1370) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTrustedFqdnCN(struct soap*, _sai__SetTrustedFqdnCN *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTrustedFqdnCN(struct soap*, _sai__SetTrustedFqdnCN *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTrustedFqdnCN(struct soap*, const char *, int, _sai__SetTrustedFqdnCN *const*, const char *); +SOAP_FMAC3 _sai__SetTrustedFqdnCN ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTrustedFqdnCN(struct soap*, _sai__SetTrustedFqdnCN **, const char*, const char*); +SOAP_FMAC3 _sai__SetTrustedFqdnCN ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTrustedFqdnCN(struct soap*, const char*, _sai__SetTrustedFqdnCN **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificatesResponse +#define SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificatesResponse (1367) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap*, _sai__EnumerateTrustedRootCertificatesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap*, _sai__EnumerateTrustedRootCertificatesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap*, const char *, int, _sai__EnumerateTrustedRootCertificatesResponse *const*, const char *); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap*, _sai__EnumerateTrustedRootCertificatesResponse **, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap*, const char*, _sai__EnumerateTrustedRootCertificatesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificates +#define SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificates (1366) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap*, _sai__EnumerateTrustedRootCertificates *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap*, _sai__EnumerateTrustedRootCertificates *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap*, const char *, int, _sai__EnumerateTrustedRootCertificates *const*, const char *); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap*, _sai__EnumerateTrustedRootCertificates **, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap*, const char*, _sai__EnumerateTrustedRootCertificates **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificateResponse +#define SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificateResponse (1363) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap*, _sai__DeleteTrustedRootCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap*, _sai__DeleteTrustedRootCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap*, const char *, int, _sai__DeleteTrustedRootCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap*, _sai__DeleteTrustedRootCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap*, const char*, _sai__DeleteTrustedRootCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificate +#define SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificate (1362) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__DeleteTrustedRootCertificate(struct soap*, _sai__DeleteTrustedRootCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__DeleteTrustedRootCertificate(struct soap*, _sai__DeleteTrustedRootCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__DeleteTrustedRootCertificate(struct soap*, const char *, int, _sai__DeleteTrustedRootCertificate *const*, const char *); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__DeleteTrustedRootCertificate(struct soap*, _sai__DeleteTrustedRootCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__DeleteTrustedRootCertificate(struct soap*, const char*, _sai__DeleteTrustedRootCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificateResponse +#define SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificateResponse (1359) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap*, _sai__GetTrustedRootCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap*, _sai__GetTrustedRootCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap*, const char *, int, _sai__GetTrustedRootCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap*, _sai__GetTrustedRootCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap*, const char*, _sai__GetTrustedRootCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificate +#define SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificate (1358) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTrustedRootCertificate(struct soap*, _sai__GetTrustedRootCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTrustedRootCertificate(struct soap*, _sai__GetTrustedRootCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTrustedRootCertificate(struct soap*, const char *, int, _sai__GetTrustedRootCertificate *const*, const char *); +SOAP_FMAC3 _sai__GetTrustedRootCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTrustedRootCertificate(struct soap*, _sai__GetTrustedRootCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__GetTrustedRootCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTrustedRootCertificate(struct soap*, const char*, _sai__GetTrustedRootCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificateResponse +#define SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificateResponse (1355) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap*, _sai__AddTrustedRootCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap*, _sai__AddTrustedRootCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap*, const char *, int, _sai__AddTrustedRootCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap*, _sai__AddTrustedRootCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap*, const char*, _sai__AddTrustedRootCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificate +#define SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificate (1354) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddTrustedRootCertificate(struct soap*, _sai__AddTrustedRootCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddTrustedRootCertificate(struct soap*, _sai__AddTrustedRootCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddTrustedRootCertificate(struct soap*, const char *, int, _sai__AddTrustedRootCertificate *const*, const char *); +SOAP_FMAC3 _sai__AddTrustedRootCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__AddTrustedRootCertificate(struct soap*, _sai__AddTrustedRootCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__AddTrustedRootCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__AddTrustedRootCertificate(struct soap*, const char*, _sai__AddTrustedRootCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTlsOptionsResponse +#define SOAP_TYPE_PointerTo_sai__GetTlsOptionsResponse (1351) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTlsOptionsResponse(struct soap*, _sai__GetTlsOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTlsOptionsResponse(struct soap*, _sai__GetTlsOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTlsOptionsResponse(struct soap*, const char *, int, _sai__GetTlsOptionsResponse *const*, const char *); +SOAP_FMAC3 _sai__GetTlsOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTlsOptionsResponse(struct soap*, _sai__GetTlsOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetTlsOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTlsOptionsResponse(struct soap*, const char*, _sai__GetTlsOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTlsOptions +#define SOAP_TYPE_PointerTo_sai__GetTlsOptions (1350) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTlsOptions(struct soap*, _sai__GetTlsOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTlsOptions(struct soap*, _sai__GetTlsOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTlsOptions(struct soap*, const char *, int, _sai__GetTlsOptions *const*, const char *); +SOAP_FMAC3 _sai__GetTlsOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTlsOptions(struct soap*, _sai__GetTlsOptions **, const char*, const char*); +SOAP_FMAC3 _sai__GetTlsOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTlsOptions(struct soap*, const char*, _sai__GetTlsOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTlsOptionsResponse +#define SOAP_TYPE_PointerTo_sai__SetTlsOptionsResponse (1347) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTlsOptionsResponse(struct soap*, _sai__SetTlsOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTlsOptionsResponse(struct soap*, _sai__SetTlsOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTlsOptionsResponse(struct soap*, const char *, int, _sai__SetTlsOptionsResponse *const*, const char *); +SOAP_FMAC3 _sai__SetTlsOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTlsOptionsResponse(struct soap*, _sai__SetTlsOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetTlsOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTlsOptionsResponse(struct soap*, const char*, _sai__SetTlsOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTlsOptions +#define SOAP_TYPE_PointerTo_sai__SetTlsOptions (1346) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTlsOptions(struct soap*, _sai__SetTlsOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTlsOptions(struct soap*, _sai__SetTlsOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTlsOptions(struct soap*, const char *, int, _sai__SetTlsOptions *const*, const char *); +SOAP_FMAC3 _sai__SetTlsOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTlsOptions(struct soap*, _sai__SetTlsOptions **, const char*, const char*); +SOAP_FMAC3 _sai__SetTlsOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTlsOptions(struct soap*, const char*, _sai__SetTlsOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetEnabledInterfacesResponse +#define SOAP_TYPE_PointerTo_sai__GetEnabledInterfacesResponse (1343) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetEnabledInterfacesResponse(struct soap*, _sai__GetEnabledInterfacesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetEnabledInterfacesResponse(struct soap*, _sai__GetEnabledInterfacesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetEnabledInterfacesResponse(struct soap*, const char *, int, _sai__GetEnabledInterfacesResponse *const*, const char *); +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetEnabledInterfacesResponse(struct soap*, _sai__GetEnabledInterfacesResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetEnabledInterfacesResponse(struct soap*, const char*, _sai__GetEnabledInterfacesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetEnabledInterfaces +#define SOAP_TYPE_PointerTo_sai__GetEnabledInterfaces (1342) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetEnabledInterfaces(struct soap*, _sai__GetEnabledInterfaces *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetEnabledInterfaces(struct soap*, _sai__GetEnabledInterfaces *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetEnabledInterfaces(struct soap*, const char *, int, _sai__GetEnabledInterfaces *const*, const char *); +SOAP_FMAC3 _sai__GetEnabledInterfaces ** SOAP_FMAC4 soap_get_PointerTo_sai__GetEnabledInterfaces(struct soap*, _sai__GetEnabledInterfaces **, const char*, const char*); +SOAP_FMAC3 _sai__GetEnabledInterfaces ** SOAP_FMAC4 soap_in_PointerTo_sai__GetEnabledInterfaces(struct soap*, const char*, _sai__GetEnabledInterfaces **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetEnabledInterfacesResponse +#define SOAP_TYPE_PointerTo_sai__SetEnabledInterfacesResponse (1339) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetEnabledInterfacesResponse(struct soap*, _sai__SetEnabledInterfacesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetEnabledInterfacesResponse(struct soap*, _sai__SetEnabledInterfacesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetEnabledInterfacesResponse(struct soap*, const char *, int, _sai__SetEnabledInterfacesResponse *const*, const char *); +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetEnabledInterfacesResponse(struct soap*, _sai__SetEnabledInterfacesResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetEnabledInterfacesResponse(struct soap*, const char*, _sai__SetEnabledInterfacesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetEnabledInterfaces +#define SOAP_TYPE_PointerTo_sai__SetEnabledInterfaces (1338) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetEnabledInterfaces(struct soap*, _sai__SetEnabledInterfaces *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetEnabledInterfaces(struct soap*, _sai__SetEnabledInterfaces *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetEnabledInterfaces(struct soap*, const char *, int, _sai__SetEnabledInterfaces *const*, const char *); +SOAP_FMAC3 _sai__SetEnabledInterfaces ** SOAP_FMAC4 soap_get_PointerTo_sai__SetEnabledInterfaces(struct soap*, _sai__SetEnabledInterfaces **, const char*, const char*); +SOAP_FMAC3 _sai__SetEnabledInterfaces ** SOAP_FMAC4 soap_in_PointerTo_sai__SetEnabledInterfaces(struct soap*, const char*, _sai__SetEnabledInterfaces **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetKerberosOptionsResponse +#define SOAP_TYPE_PointerTo_sai__GetKerberosOptionsResponse (1335) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetKerberosOptionsResponse(struct soap*, _sai__GetKerberosOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetKerberosOptionsResponse(struct soap*, _sai__GetKerberosOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetKerberosOptionsResponse(struct soap*, const char *, int, _sai__GetKerberosOptionsResponse *const*, const char *); +SOAP_FMAC3 _sai__GetKerberosOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetKerberosOptionsResponse(struct soap*, _sai__GetKerberosOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetKerberosOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetKerberosOptionsResponse(struct soap*, const char*, _sai__GetKerberosOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetKerberosOptions +#define SOAP_TYPE_PointerTo_sai__GetKerberosOptions (1334) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetKerberosOptions(struct soap*, _sai__GetKerberosOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetKerberosOptions(struct soap*, _sai__GetKerberosOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetKerberosOptions(struct soap*, const char *, int, _sai__GetKerberosOptions *const*, const char *); +SOAP_FMAC3 _sai__GetKerberosOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__GetKerberosOptions(struct soap*, _sai__GetKerberosOptions **, const char*, const char*); +SOAP_FMAC3 _sai__GetKerberosOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__GetKerberosOptions(struct soap*, const char*, _sai__GetKerberosOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetKerberosOptionsResponse +#define SOAP_TYPE_PointerTo_sai__SetKerberosOptionsResponse (1331) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetKerberosOptionsResponse(struct soap*, _sai__SetKerberosOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetKerberosOptionsResponse(struct soap*, _sai__SetKerberosOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetKerberosOptionsResponse(struct soap*, const char *, int, _sai__SetKerberosOptionsResponse *const*, const char *); +SOAP_FMAC3 _sai__SetKerberosOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetKerberosOptionsResponse(struct soap*, _sai__SetKerberosOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetKerberosOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetKerberosOptionsResponse(struct soap*, const char*, _sai__SetKerberosOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetKerberosOptions +#define SOAP_TYPE_PointerTo_sai__SetKerberosOptions (1330) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetKerberosOptions(struct soap*, _sai__SetKerberosOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetKerberosOptions(struct soap*, _sai__SetKerberosOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetKerberosOptions(struct soap*, const char *, int, _sai__SetKerberosOptions *const*, const char *); +SOAP_FMAC3 _sai__SetKerberosOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__SetKerberosOptions(struct soap*, _sai__SetKerberosOptions **, const char*, const char*); +SOAP_FMAC3 _sai__SetKerberosOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__SetKerberosOptions(struct soap*, const char*, _sai__SetKerberosOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetDigestRealmResponse +#define SOAP_TYPE_PointerTo_sai__GetDigestRealmResponse (1327) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetDigestRealmResponse(struct soap*, _sai__GetDigestRealmResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetDigestRealmResponse(struct soap*, _sai__GetDigestRealmResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetDigestRealmResponse(struct soap*, const char *, int, _sai__GetDigestRealmResponse *const*, const char *); +SOAP_FMAC3 _sai__GetDigestRealmResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetDigestRealmResponse(struct soap*, _sai__GetDigestRealmResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetDigestRealmResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetDigestRealmResponse(struct soap*, const char*, _sai__GetDigestRealmResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetDigestRealm +#define SOAP_TYPE_PointerTo_sai__GetDigestRealm (1326) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetDigestRealm(struct soap*, _sai__GetDigestRealm *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetDigestRealm(struct soap*, _sai__GetDigestRealm *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetDigestRealm(struct soap*, const char *, int, _sai__GetDigestRealm *const*, const char *); +SOAP_FMAC3 _sai__GetDigestRealm ** SOAP_FMAC4 soap_get_PointerTo_sai__GetDigestRealm(struct soap*, _sai__GetDigestRealm **, const char*, const char*); +SOAP_FMAC3 _sai__GetDigestRealm ** SOAP_FMAC4 soap_in_PointerTo_sai__GetDigestRealm(struct soap*, const char*, _sai__GetDigestRealm **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetAdminAclEntryExResponse +#define SOAP_TYPE_PointerTo_sai__SetAdminAclEntryExResponse (1323) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAdminAclEntryExResponse(struct soap*, _sai__SetAdminAclEntryExResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAdminAclEntryExResponse(struct soap*, _sai__SetAdminAclEntryExResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAdminAclEntryExResponse(struct soap*, const char *, int, _sai__SetAdminAclEntryExResponse *const*, const char *); +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAdminAclEntryExResponse(struct soap*, _sai__SetAdminAclEntryExResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAdminAclEntryExResponse(struct soap*, const char*, _sai__SetAdminAclEntryExResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetAdminAclEntryEx +#define SOAP_TYPE_PointerTo_sai__SetAdminAclEntryEx (1322) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAdminAclEntryEx(struct soap*, _sai__SetAdminAclEntryEx *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAdminAclEntryEx(struct soap*, _sai__SetAdminAclEntryEx *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAdminAclEntryEx(struct soap*, const char *, int, _sai__SetAdminAclEntryEx *const*, const char *); +SOAP_FMAC3 _sai__SetAdminAclEntryEx ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAdminAclEntryEx(struct soap*, _sai__SetAdminAclEntryEx **, const char*, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntryEx ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAdminAclEntryEx(struct soap*, const char*, _sai__SetAdminAclEntryEx **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryExResponse +#define SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryExResponse (1319) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap*, _sai__UpdateUserAclEntryExResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap*, _sai__UpdateUserAclEntryExResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap*, const char *, int, _sai__UpdateUserAclEntryExResponse *const*, const char *); +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap*, _sai__UpdateUserAclEntryExResponse **, const char*, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap*, const char*, _sai__UpdateUserAclEntryExResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryEx +#define SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryEx (1318) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateUserAclEntryEx(struct soap*, _sai__UpdateUserAclEntryEx *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateUserAclEntryEx(struct soap*, _sai__UpdateUserAclEntryEx *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateUserAclEntryEx(struct soap*, const char *, int, _sai__UpdateUserAclEntryEx *const*, const char *); +SOAP_FMAC3 _sai__UpdateUserAclEntryEx ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateUserAclEntryEx(struct soap*, _sai__UpdateUserAclEntryEx **, const char*, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntryEx ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateUserAclEntryEx(struct soap*, const char*, _sai__UpdateUserAclEntryEx **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetUserAclEntryExResponse +#define SOAP_TYPE_PointerTo_sai__GetUserAclEntryExResponse (1315) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetUserAclEntryExResponse(struct soap*, _sai__GetUserAclEntryExResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetUserAclEntryExResponse(struct soap*, _sai__GetUserAclEntryExResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetUserAclEntryExResponse(struct soap*, const char *, int, _sai__GetUserAclEntryExResponse *const*, const char *); +SOAP_FMAC3 _sai__GetUserAclEntryExResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetUserAclEntryExResponse(struct soap*, _sai__GetUserAclEntryExResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetUserAclEntryExResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetUserAclEntryExResponse(struct soap*, const char*, _sai__GetUserAclEntryExResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetUserAclEntryEx +#define SOAP_TYPE_PointerTo_sai__GetUserAclEntryEx (1314) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetUserAclEntryEx(struct soap*, _sai__GetUserAclEntryEx *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetUserAclEntryEx(struct soap*, _sai__GetUserAclEntryEx *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetUserAclEntryEx(struct soap*, const char *, int, _sai__GetUserAclEntryEx *const*, const char *); +SOAP_FMAC3 _sai__GetUserAclEntryEx ** SOAP_FMAC4 soap_get_PointerTo_sai__GetUserAclEntryEx(struct soap*, _sai__GetUserAclEntryEx **, const char*, const char*); +SOAP_FMAC3 _sai__GetUserAclEntryEx ** SOAP_FMAC4 soap_in_PointerTo_sai__GetUserAclEntryEx(struct soap*, const char*, _sai__GetUserAclEntryEx **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__AddUserAclEntryExResponse +#define SOAP_TYPE_PointerTo_sai__AddUserAclEntryExResponse (1311) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddUserAclEntryExResponse(struct soap*, _sai__AddUserAclEntryExResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddUserAclEntryExResponse(struct soap*, _sai__AddUserAclEntryExResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddUserAclEntryExResponse(struct soap*, const char *, int, _sai__AddUserAclEntryExResponse *const*, const char *); +SOAP_FMAC3 _sai__AddUserAclEntryExResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__AddUserAclEntryExResponse(struct soap*, _sai__AddUserAclEntryExResponse **, const char*, const char*); +SOAP_FMAC3 _sai__AddUserAclEntryExResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__AddUserAclEntryExResponse(struct soap*, const char*, _sai__AddUserAclEntryExResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__AddUserAclEntryEx +#define SOAP_TYPE_PointerTo_sai__AddUserAclEntryEx (1310) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddUserAclEntryEx(struct soap*, _sai__AddUserAclEntryEx *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddUserAclEntryEx(struct soap*, _sai__AddUserAclEntryEx *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddUserAclEntryEx(struct soap*, const char *, int, _sai__AddUserAclEntryEx *const*, const char *); +SOAP_FMAC3 _sai__AddUserAclEntryEx ** SOAP_FMAC4 soap_get_PointerTo_sai__AddUserAclEntryEx(struct soap*, _sai__AddUserAclEntryEx **, const char*, const char*); +SOAP_FMAC3 _sai__AddUserAclEntryEx ** SOAP_FMAC4 soap_in_PointerTo_sai__AddUserAclEntryEx(struct soap*, const char*, _sai__AddUserAclEntryEx **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetCoreVersionResponse +#define SOAP_TYPE_PointerTo_sai__GetCoreVersionResponse (1307) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCoreVersionResponse(struct soap*, _sai__GetCoreVersionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCoreVersionResponse(struct soap*, _sai__GetCoreVersionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCoreVersionResponse(struct soap*, const char *, int, _sai__GetCoreVersionResponse *const*, const char *); +SOAP_FMAC3 _sai__GetCoreVersionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCoreVersionResponse(struct soap*, _sai__GetCoreVersionResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetCoreVersionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCoreVersionResponse(struct soap*, const char*, _sai__GetCoreVersionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetCoreVersion +#define SOAP_TYPE_PointerTo_sai__GetCoreVersion (1306) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCoreVersion(struct soap*, _sai__GetCoreVersion *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCoreVersion(struct soap*, _sai__GetCoreVersion *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCoreVersion(struct soap*, const char *, int, _sai__GetCoreVersion *const*, const char *); +SOAP_FMAC3 _sai__GetCoreVersion ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCoreVersion(struct soap*, _sai__GetCoreVersion **, const char*, const char*); +SOAP_FMAC3 _sai__GetCoreVersion ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCoreVersion(struct soap*, const char*, _sai__GetCoreVersion **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CommitChangesResponse +#define SOAP_TYPE_PointerTo_sai__CommitChangesResponse (1303) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CommitChangesResponse(struct soap*, _sai__CommitChangesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CommitChangesResponse(struct soap*, _sai__CommitChangesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CommitChangesResponse(struct soap*, const char *, int, _sai__CommitChangesResponse *const*, const char *); +SOAP_FMAC3 _sai__CommitChangesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CommitChangesResponse(struct soap*, _sai__CommitChangesResponse **, const char*, const char*); +SOAP_FMAC3 _sai__CommitChangesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CommitChangesResponse(struct soap*, const char*, _sai__CommitChangesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__CommitChanges +#define SOAP_TYPE_PointerTo_sai__CommitChanges (1302) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CommitChanges(struct soap*, _sai__CommitChanges *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CommitChanges(struct soap*, _sai__CommitChanges *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CommitChanges(struct soap*, const char *, int, _sai__CommitChanges *const*, const char *); +SOAP_FMAC3 _sai__CommitChanges ** SOAP_FMAC4 soap_get_PointerTo_sai__CommitChanges(struct soap*, _sai__CommitChanges **, const char*, const char*); +SOAP_FMAC3 _sai__CommitChanges ** SOAP_FMAC4 soap_in_PointerTo_sai__CommitChanges(struct soap*, const char*, _sai__CommitChanges **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__UnprovisionResponse +#define SOAP_TYPE_PointerTo_sai__UnprovisionResponse (1299) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UnprovisionResponse(struct soap*, _sai__UnprovisionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UnprovisionResponse(struct soap*, _sai__UnprovisionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UnprovisionResponse(struct soap*, const char *, int, _sai__UnprovisionResponse *const*, const char *); +SOAP_FMAC3 _sai__UnprovisionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__UnprovisionResponse(struct soap*, _sai__UnprovisionResponse **, const char*, const char*); +SOAP_FMAC3 _sai__UnprovisionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__UnprovisionResponse(struct soap*, const char*, _sai__UnprovisionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__Unprovision +#define SOAP_TYPE_PointerTo_sai__Unprovision (1298) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__Unprovision(struct soap*, _sai__Unprovision *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__Unprovision(struct soap*, _sai__Unprovision *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__Unprovision(struct soap*, const char *, int, _sai__Unprovision *const*, const char *); +SOAP_FMAC3 _sai__Unprovision ** SOAP_FMAC4 soap_get_PointerTo_sai__Unprovision(struct soap*, _sai__Unprovision **, const char*, const char*); +SOAP_FMAC3 _sai__Unprovision ** SOAP_FMAC4 soap_in_PointerTo_sai__Unprovision(struct soap*, const char*, _sai__Unprovision **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetProvisioningModeResponse +#define SOAP_TYPE_PointerTo_sai__SetProvisioningModeResponse (1295) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetProvisioningModeResponse(struct soap*, _sai__SetProvisioningModeResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetProvisioningModeResponse(struct soap*, _sai__SetProvisioningModeResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetProvisioningModeResponse(struct soap*, const char *, int, _sai__SetProvisioningModeResponse *const*, const char *); +SOAP_FMAC3 _sai__SetProvisioningModeResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetProvisioningModeResponse(struct soap*, _sai__SetProvisioningModeResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetProvisioningModeResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetProvisioningModeResponse(struct soap*, const char*, _sai__SetProvisioningModeResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetProvisioningMode +#define SOAP_TYPE_PointerTo_sai__SetProvisioningMode (1294) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetProvisioningMode(struct soap*, _sai__SetProvisioningMode *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetProvisioningMode(struct soap*, _sai__SetProvisioningMode *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetProvisioningMode(struct soap*, const char *, int, _sai__SetProvisioningMode *const*, const char *); +SOAP_FMAC3 _sai__SetProvisioningMode ** SOAP_FMAC4 soap_get_PointerTo_sai__SetProvisioningMode(struct soap*, _sai__SetProvisioningMode **, const char*, const char*); +SOAP_FMAC3 _sai__SetProvisioningMode ** SOAP_FMAC4 soap_in_PointerTo_sai__SetProvisioningMode(struct soap*, const char*, _sai__SetProvisioningMode **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetProvisioningModeResponse +#define SOAP_TYPE_PointerTo_sai__GetProvisioningModeResponse (1291) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningModeResponse(struct soap*, _sai__GetProvisioningModeResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningModeResponse(struct soap*, _sai__GetProvisioningModeResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningModeResponse(struct soap*, const char *, int, _sai__GetProvisioningModeResponse *const*, const char *); +SOAP_FMAC3 _sai__GetProvisioningModeResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningModeResponse(struct soap*, _sai__GetProvisioningModeResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningModeResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningModeResponse(struct soap*, const char*, _sai__GetProvisioningModeResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetProvisioningMode +#define SOAP_TYPE_PointerTo_sai__GetProvisioningMode (1290) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningMode(struct soap*, _sai__GetProvisioningMode *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningMode(struct soap*, _sai__GetProvisioningMode *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningMode(struct soap*, const char *, int, _sai__GetProvisioningMode *const*, const char *); +SOAP_FMAC3 _sai__GetProvisioningMode ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningMode(struct soap*, _sai__GetProvisioningMode **, const char*, const char*); +SOAP_FMAC3 _sai__GetProvisioningMode ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningMode(struct soap*, const char*, _sai__GetProvisioningMode **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrlResponse +#define SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrlResponse (1287) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap*, _sai__UpdateCoreFromUrlResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap*, _sai__UpdateCoreFromUrlResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap*, const char *, int, _sai__UpdateCoreFromUrlResponse *const*, const char *); +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap*, _sai__UpdateCoreFromUrlResponse **, const char*, const char*); +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap*, const char*, _sai__UpdateCoreFromUrlResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrl +#define SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrl (1286) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateCoreFromUrl(struct soap*, _sai__UpdateCoreFromUrl *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateCoreFromUrl(struct soap*, _sai__UpdateCoreFromUrl *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateCoreFromUrl(struct soap*, const char *, int, _sai__UpdateCoreFromUrl *const*, const char *); +SOAP_FMAC3 _sai__UpdateCoreFromUrl ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateCoreFromUrl(struct soap*, _sai__UpdateCoreFromUrl **, const char*, const char*); +SOAP_FMAC3 _sai__UpdateCoreFromUrl ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateCoreFromUrl(struct soap*, const char*, _sai__UpdateCoreFromUrl **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTLSCertificateResponse +#define SOAP_TYPE_PointerTo_sai__GetTLSCertificateResponse (1283) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTLSCertificateResponse(struct soap*, _sai__GetTLSCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTLSCertificateResponse(struct soap*, _sai__GetTLSCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTLSCertificateResponse(struct soap*, const char *, int, _sai__GetTLSCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__GetTLSCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTLSCertificateResponse(struct soap*, _sai__GetTLSCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetTLSCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTLSCertificateResponse(struct soap*, const char*, _sai__GetTLSCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetTLSCertificate +#define SOAP_TYPE_PointerTo_sai__GetTLSCertificate (1282) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTLSCertificate(struct soap*, _sai__GetTLSCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTLSCertificate(struct soap*, _sai__GetTLSCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTLSCertificate(struct soap*, const char *, int, _sai__GetTLSCertificate *const*, const char *); +SOAP_FMAC3 _sai__GetTLSCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTLSCertificate(struct soap*, _sai__GetTLSCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__GetTLSCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTLSCertificate(struct soap*, const char*, _sai__GetTLSCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTLSCertificateResponse +#define SOAP_TYPE_PointerTo_sai__SetTLSCertificateResponse (1279) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSCertificateResponse(struct soap*, _sai__SetTLSCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSCertificateResponse(struct soap*, _sai__SetTLSCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSCertificateResponse(struct soap*, const char *, int, _sai__SetTLSCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__SetTLSCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSCertificateResponse(struct soap*, _sai__SetTLSCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSCertificateResponse(struct soap*, const char*, _sai__SetTLSCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTLSCertificate +#define SOAP_TYPE_PointerTo_sai__SetTLSCertificate (1278) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSCertificate(struct soap*, _sai__SetTLSCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSCertificate(struct soap*, _sai__SetTLSCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSCertificate(struct soap*, const char *, int, _sai__SetTLSCertificate *const*, const char *); +SOAP_FMAC3 _sai__SetTLSCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSCertificate(struct soap*, _sai__SetTLSCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSCertificate(struct soap*, const char*, _sai__SetTLSCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificateResponse +#define SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificateResponse (1275) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap*, _sai__SetTLSKeyAndCertificateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap*, _sai__SetTLSKeyAndCertificateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap*, const char *, int, _sai__SetTLSKeyAndCertificateResponse *const*, const char *); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap*, _sai__SetTLSKeyAndCertificateResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap*, const char*, _sai__SetTLSKeyAndCertificateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificate +#define SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificate (1274) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSKeyAndCertificate(struct soap*, _sai__SetTLSKeyAndCertificate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSKeyAndCertificate(struct soap*, _sai__SetTLSKeyAndCertificate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSKeyAndCertificate(struct soap*, const char *, int, _sai__SetTLSKeyAndCertificate *const*, const char *); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSKeyAndCertificate(struct soap*, _sai__SetTLSKeyAndCertificate **, const char*, const char*); +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSKeyAndCertificate(struct soap*, const char*, _sai__SetTLSKeyAndCertificate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetRngKeyResponse +#define SOAP_TYPE_PointerTo_sai__SetRngKeyResponse (1271) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetRngKeyResponse(struct soap*, _sai__SetRngKeyResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetRngKeyResponse(struct soap*, _sai__SetRngKeyResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetRngKeyResponse(struct soap*, const char *, int, _sai__SetRngKeyResponse *const*, const char *); +SOAP_FMAC3 _sai__SetRngKeyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetRngKeyResponse(struct soap*, _sai__SetRngKeyResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetRngKeyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetRngKeyResponse(struct soap*, const char*, _sai__SetRngKeyResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetRngKey +#define SOAP_TYPE_PointerTo_sai__SetRngKey (1270) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetRngKey(struct soap*, _sai__SetRngKey *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetRngKey(struct soap*, _sai__SetRngKey *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetRngKey(struct soap*, const char *, int, _sai__SetRngKey *const*, const char *); +SOAP_FMAC3 _sai__SetRngKey ** SOAP_FMAC4 soap_get_PointerTo_sai__SetRngKey(struct soap*, _sai__SetRngKey **, const char*, const char*); +SOAP_FMAC3 _sai__SetRngKey ** SOAP_FMAC4 soap_in_PointerTo_sai__SetRngKey(struct soap*, const char*, _sai__SetRngKey **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTlsEnabledResponse +#define SOAP_TYPE_PointerTo_sai__SetTlsEnabledResponse (1267) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTlsEnabledResponse(struct soap*, _sai__SetTlsEnabledResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTlsEnabledResponse(struct soap*, _sai__SetTlsEnabledResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTlsEnabledResponse(struct soap*, const char *, int, _sai__SetTlsEnabledResponse *const*, const char *); +SOAP_FMAC3 _sai__SetTlsEnabledResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTlsEnabledResponse(struct soap*, _sai__SetTlsEnabledResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetTlsEnabledResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTlsEnabledResponse(struct soap*, const char*, _sai__SetTlsEnabledResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetTlsEnabled +#define SOAP_TYPE_PointerTo_sai__SetTlsEnabled (1266) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTlsEnabled(struct soap*, _sai__SetTlsEnabled *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTlsEnabled(struct soap*, _sai__SetTlsEnabled *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTlsEnabled(struct soap*, const char *, int, _sai__SetTlsEnabled *const*, const char *); +SOAP_FMAC3 _sai__SetTlsEnabled ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTlsEnabled(struct soap*, _sai__SetTlsEnabled **, const char*, const char*); +SOAP_FMAC3 _sai__SetTlsEnabled ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTlsEnabled(struct soap*, const char*, _sai__SetTlsEnabled **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__RemoveUserAclEntryResponse +#define SOAP_TYPE_PointerTo_sai__RemoveUserAclEntryResponse (1263) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__RemoveUserAclEntryResponse(struct soap*, _sai__RemoveUserAclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__RemoveUserAclEntryResponse(struct soap*, _sai__RemoveUserAclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__RemoveUserAclEntryResponse(struct soap*, const char *, int, _sai__RemoveUserAclEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__RemoveUserAclEntryResponse(struct soap*, _sai__RemoveUserAclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__RemoveUserAclEntryResponse(struct soap*, const char*, _sai__RemoveUserAclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__RemoveUserAclEntry +#define SOAP_TYPE_PointerTo_sai__RemoveUserAclEntry (1262) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__RemoveUserAclEntry(struct soap*, _sai__RemoveUserAclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__RemoveUserAclEntry(struct soap*, _sai__RemoveUserAclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__RemoveUserAclEntry(struct soap*, const char *, int, _sai__RemoveUserAclEntry *const*, const char *); +SOAP_FMAC3 _sai__RemoveUserAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__RemoveUserAclEntry(struct soap*, _sai__RemoveUserAclEntry **, const char*, const char*); +SOAP_FMAC3 _sai__RemoveUserAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__RemoveUserAclEntry(struct soap*, const char*, _sai__RemoveUserAclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryResponse +#define SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryResponse (1259) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateUserAclEntryResponse(struct soap*, _sai__UpdateUserAclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateUserAclEntryResponse(struct soap*, _sai__UpdateUserAclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateUserAclEntryResponse(struct soap*, const char *, int, _sai__UpdateUserAclEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateUserAclEntryResponse(struct soap*, _sai__UpdateUserAclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateUserAclEntryResponse(struct soap*, const char*, _sai__UpdateUserAclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__UpdateUserAclEntry +#define SOAP_TYPE_PointerTo_sai__UpdateUserAclEntry (1258) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateUserAclEntry(struct soap*, _sai__UpdateUserAclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateUserAclEntry(struct soap*, _sai__UpdateUserAclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateUserAclEntry(struct soap*, const char *, int, _sai__UpdateUserAclEntry *const*, const char *); +SOAP_FMAC3 _sai__UpdateUserAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateUserAclEntry(struct soap*, _sai__UpdateUserAclEntry **, const char*, const char*); +SOAP_FMAC3 _sai__UpdateUserAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateUserAclEntry(struct soap*, const char*, _sai__UpdateUserAclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetUserAclEntryResponse +#define SOAP_TYPE_PointerTo_sai__GetUserAclEntryResponse (1255) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetUserAclEntryResponse(struct soap*, _sai__GetUserAclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetUserAclEntryResponse(struct soap*, _sai__GetUserAclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetUserAclEntryResponse(struct soap*, const char *, int, _sai__GetUserAclEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__GetUserAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetUserAclEntryResponse(struct soap*, _sai__GetUserAclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetUserAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetUserAclEntryResponse(struct soap*, const char*, _sai__GetUserAclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetUserAclEntry +#define SOAP_TYPE_PointerTo_sai__GetUserAclEntry (1254) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetUserAclEntry(struct soap*, _sai__GetUserAclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetUserAclEntry(struct soap*, _sai__GetUserAclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetUserAclEntry(struct soap*, const char *, int, _sai__GetUserAclEntry *const*, const char *); +SOAP_FMAC3 _sai__GetUserAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__GetUserAclEntry(struct soap*, _sai__GetUserAclEntry **, const char*, const char*); +SOAP_FMAC3 _sai__GetUserAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__GetUserAclEntry(struct soap*, const char*, _sai__GetUserAclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntriesResponse +#define SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntriesResponse (1251) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap*, _sai__EnumerateUserAclEntriesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap*, _sai__EnumerateUserAclEntriesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap*, const char *, int, _sai__EnumerateUserAclEntriesResponse *const*, const char *); +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap*, _sai__EnumerateUserAclEntriesResponse **, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap*, const char*, _sai__EnumerateUserAclEntriesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntries +#define SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntries (1250) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateUserAclEntries(struct soap*, _sai__EnumerateUserAclEntries *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateUserAclEntries(struct soap*, _sai__EnumerateUserAclEntries *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateUserAclEntries(struct soap*, const char *, int, _sai__EnumerateUserAclEntries *const*, const char *); +SOAP_FMAC3 _sai__EnumerateUserAclEntries ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateUserAclEntries(struct soap*, _sai__EnumerateUserAclEntries **, const char*, const char*); +SOAP_FMAC3 _sai__EnumerateUserAclEntries ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateUserAclEntries(struct soap*, const char*, _sai__EnumerateUserAclEntries **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__AddUserAclEntryResponse +#define SOAP_TYPE_PointerTo_sai__AddUserAclEntryResponse (1247) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddUserAclEntryResponse(struct soap*, _sai__AddUserAclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddUserAclEntryResponse(struct soap*, _sai__AddUserAclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddUserAclEntryResponse(struct soap*, const char *, int, _sai__AddUserAclEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__AddUserAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__AddUserAclEntryResponse(struct soap*, _sai__AddUserAclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__AddUserAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__AddUserAclEntryResponse(struct soap*, const char*, _sai__AddUserAclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__AddUserAclEntry +#define SOAP_TYPE_PointerTo_sai__AddUserAclEntry (1246) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddUserAclEntry(struct soap*, _sai__AddUserAclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddUserAclEntry(struct soap*, _sai__AddUserAclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddUserAclEntry(struct soap*, const char *, int, _sai__AddUserAclEntry *const*, const char *); +SOAP_FMAC3 _sai__AddUserAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__AddUserAclEntry(struct soap*, _sai__AddUserAclEntry **, const char*, const char*); +SOAP_FMAC3 _sai__AddUserAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__AddUserAclEntry(struct soap*, const char*, _sai__AddUserAclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetAdminAclEntryResponse +#define SOAP_TYPE_PointerTo_sai__SetAdminAclEntryResponse (1243) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAdminAclEntryResponse(struct soap*, _sai__SetAdminAclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAdminAclEntryResponse(struct soap*, _sai__SetAdminAclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAdminAclEntryResponse(struct soap*, const char *, int, _sai__SetAdminAclEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__SetAdminAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAdminAclEntryResponse(struct soap*, _sai__SetAdminAclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAdminAclEntryResponse(struct soap*, const char*, _sai__SetAdminAclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__SetAdminAclEntry +#define SOAP_TYPE_PointerTo_sai__SetAdminAclEntry (1242) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAdminAclEntry(struct soap*, _sai__SetAdminAclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAdminAclEntry(struct soap*, _sai__SetAdminAclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAdminAclEntry(struct soap*, const char *, int, _sai__SetAdminAclEntry *const*, const char *); +SOAP_FMAC3 _sai__SetAdminAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAdminAclEntry(struct soap*, _sai__SetAdminAclEntry **, const char*, const char*); +SOAP_FMAC3 _sai__SetAdminAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAdminAclEntry(struct soap*, const char*, _sai__SetAdminAclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetAdminAclEntryResponse +#define SOAP_TYPE_PointerTo_sai__GetAdminAclEntryResponse (1239) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetAdminAclEntryResponse(struct soap*, _sai__GetAdminAclEntryResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetAdminAclEntryResponse(struct soap*, _sai__GetAdminAclEntryResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetAdminAclEntryResponse(struct soap*, const char *, int, _sai__GetAdminAclEntryResponse *const*, const char *); +SOAP_FMAC3 _sai__GetAdminAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetAdminAclEntryResponse(struct soap*, _sai__GetAdminAclEntryResponse **, const char*, const char*); +SOAP_FMAC3 _sai__GetAdminAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetAdminAclEntryResponse(struct soap*, const char*, _sai__GetAdminAclEntryResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__GetAdminAclEntry +#define SOAP_TYPE_PointerTo_sai__GetAdminAclEntry (1238) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetAdminAclEntry(struct soap*, _sai__GetAdminAclEntry *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetAdminAclEntry(struct soap*, _sai__GetAdminAclEntry *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetAdminAclEntry(struct soap*, const char *, int, _sai__GetAdminAclEntry *const*, const char *); +SOAP_FMAC3 _sai__GetAdminAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__GetAdminAclEntry(struct soap*, _sai__GetAdminAclEntry **, const char*, const char*); +SOAP_FMAC3 _sai__GetAdminAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__GetAdminAclEntry(struct soap*, const char*, _sai__GetAdminAclEntry **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtectionResponse +#define SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtectionResponse (1235) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap*, _sai__ResetFlashWearOutProtectionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap*, _sai__ResetFlashWearOutProtectionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap*, const char *, int, _sai__ResetFlashWearOutProtectionResponse *const*, const char *); +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap*, _sai__ResetFlashWearOutProtectionResponse **, const char*, const char*); +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap*, const char*, _sai__ResetFlashWearOutProtectionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtection +#define SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtection (1234) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__ResetFlashWearOutProtection(struct soap*, _sai__ResetFlashWearOutProtection *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__ResetFlashWearOutProtection(struct soap*, _sai__ResetFlashWearOutProtection *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__ResetFlashWearOutProtection(struct soap*, const char *, int, _sai__ResetFlashWearOutProtection *const*, const char *); +SOAP_FMAC3 _sai__ResetFlashWearOutProtection ** SOAP_FMAC4 soap_get_PointerTo_sai__ResetFlashWearOutProtection(struct soap*, _sai__ResetFlashWearOutProtection **, const char*, const char*); +SOAP_FMAC3 _sai__ResetFlashWearOutProtection ** SOAP_FMAC4 soap_in_PointerTo_sai__ResetFlashWearOutProtection(struct soap*, const char*, _sai__ResetFlashWearOutProtection **, const char*); + +#ifndef SOAP_TYPE_PointerTo_rci__GetSystemPowerStateResponse +#define SOAP_TYPE_PointerTo_rci__GetSystemPowerStateResponse (1231) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__GetSystemPowerStateResponse(struct soap*, _rci__GetSystemPowerStateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__GetSystemPowerStateResponse(struct soap*, _rci__GetSystemPowerStateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__GetSystemPowerStateResponse(struct soap*, const char *, int, _rci__GetSystemPowerStateResponse *const*, const char *); +SOAP_FMAC3 _rci__GetSystemPowerStateResponse ** SOAP_FMAC4 soap_get_PointerTo_rci__GetSystemPowerStateResponse(struct soap*, _rci__GetSystemPowerStateResponse **, const char*, const char*); +SOAP_FMAC3 _rci__GetSystemPowerStateResponse ** SOAP_FMAC4 soap_in_PointerTo_rci__GetSystemPowerStateResponse(struct soap*, const char*, _rci__GetSystemPowerStateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_rci__GetSystemPowerState +#define SOAP_TYPE_PointerTo_rci__GetSystemPowerState (1230) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__GetSystemPowerState(struct soap*, _rci__GetSystemPowerState *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__GetSystemPowerState(struct soap*, _rci__GetSystemPowerState *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__GetSystemPowerState(struct soap*, const char *, int, _rci__GetSystemPowerState *const*, const char *); +SOAP_FMAC3 _rci__GetSystemPowerState ** SOAP_FMAC4 soap_get_PointerTo_rci__GetSystemPowerState(struct soap*, _rci__GetSystemPowerState **, const char*, const char*); +SOAP_FMAC3 _rci__GetSystemPowerState ** SOAP_FMAC4 soap_in_PointerTo_rci__GetSystemPowerState(struct soap*, const char*, _rci__GetSystemPowerState **, const char*); + +#ifndef SOAP_TYPE_PointerTo_rci__RemoteControlResponse +#define SOAP_TYPE_PointerTo_rci__RemoteControlResponse (1227) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__RemoteControlResponse(struct soap*, _rci__RemoteControlResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__RemoteControlResponse(struct soap*, _rci__RemoteControlResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__RemoteControlResponse(struct soap*, const char *, int, _rci__RemoteControlResponse *const*, const char *); +SOAP_FMAC3 _rci__RemoteControlResponse ** SOAP_FMAC4 soap_get_PointerTo_rci__RemoteControlResponse(struct soap*, _rci__RemoteControlResponse **, const char*, const char*); +SOAP_FMAC3 _rci__RemoteControlResponse ** SOAP_FMAC4 soap_in_PointerTo_rci__RemoteControlResponse(struct soap*, const char*, _rci__RemoteControlResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_rci__RemoteControl +#define SOAP_TYPE_PointerTo_rci__RemoteControl (1226) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__RemoteControl(struct soap*, _rci__RemoteControl *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__RemoteControl(struct soap*, _rci__RemoteControl *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__RemoteControl(struct soap*, const char *, int, _rci__RemoteControl *const*, const char *); +SOAP_FMAC3 _rci__RemoteControl ** SOAP_FMAC4 soap_get_PointerTo_rci__RemoteControl(struct soap*, _rci__RemoteControl **, const char*, const char*); +SOAP_FMAC3 _rci__RemoteControl ** SOAP_FMAC4 soap_in_PointerTo_rci__RemoteControl(struct soap*, const char*, _rci__RemoteControl **, const char*); + +#ifndef SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilitiesResponse +#define SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilitiesResponse (1223) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap*, _rci__GetRemoteControlCapabilitiesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap*, _rci__GetRemoteControlCapabilitiesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap*, const char *, int, _rci__GetRemoteControlCapabilitiesResponse *const*, const char *); +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap*, _rci__GetRemoteControlCapabilitiesResponse **, const char*, const char*); +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap*, const char*, _rci__GetRemoteControlCapabilitiesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilities +#define SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilities (1222) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__GetRemoteControlCapabilities(struct soap*, _rci__GetRemoteControlCapabilities *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__GetRemoteControlCapabilities(struct soap*, _rci__GetRemoteControlCapabilities *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__GetRemoteControlCapabilities(struct soap*, const char *, int, _rci__GetRemoteControlCapabilities *const*, const char *); +SOAP_FMAC3 _rci__GetRemoteControlCapabilities ** SOAP_FMAC4 soap_get_PointerTo_rci__GetRemoteControlCapabilities(struct soap*, _rci__GetRemoteControlCapabilities **, const char*, const char*); +SOAP_FMAC3 _rci__GetRemoteControlCapabilities ** SOAP_FMAC4 soap_in_PointerTo_rci__GetRemoteControlCapabilities(struct soap*, const char*, _rci__GetRemoteControlCapabilities **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Get8021XPxeTimeoutResponse +#define SOAP_TYPE_PointerTo_net__Get8021XPxeTimeoutResponse (1219) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap*, _net__Get8021XPxeTimeoutResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap*, _net__Get8021XPxeTimeoutResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap*, const char *, int, _net__Get8021XPxeTimeoutResponse *const*, const char *); +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap*, _net__Get8021XPxeTimeoutResponse **, const char*, const char*); +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap*, const char*, _net__Get8021XPxeTimeoutResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Get8021XPxeTimeout +#define SOAP_TYPE_PointerTo_net__Get8021XPxeTimeout (1218) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XPxeTimeout(struct soap*, _net__Get8021XPxeTimeout *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XPxeTimeout(struct soap*, _net__Get8021XPxeTimeout *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XPxeTimeout(struct soap*, const char *, int, _net__Get8021XPxeTimeout *const*, const char *); +SOAP_FMAC3 _net__Get8021XPxeTimeout ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XPxeTimeout(struct soap*, _net__Get8021XPxeTimeout **, const char*, const char*); +SOAP_FMAC3 _net__Get8021XPxeTimeout ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XPxeTimeout(struct soap*, const char*, _net__Get8021XPxeTimeout **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Set8021XPxeTimeoutResponse +#define SOAP_TYPE_PointerTo_net__Set8021XPxeTimeoutResponse (1215) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap*, _net__Set8021XPxeTimeoutResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap*, _net__Set8021XPxeTimeoutResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap*, const char *, int, _net__Set8021XPxeTimeoutResponse *const*, const char *); +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap*, _net__Set8021XPxeTimeoutResponse **, const char*, const char*); +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap*, const char*, _net__Set8021XPxeTimeoutResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Set8021XPxeTimeout +#define SOAP_TYPE_PointerTo_net__Set8021XPxeTimeout (1214) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XPxeTimeout(struct soap*, _net__Set8021XPxeTimeout *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XPxeTimeout(struct soap*, _net__Set8021XPxeTimeout *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XPxeTimeout(struct soap*, const char *, int, _net__Set8021XPxeTimeout *const*, const char *); +SOAP_FMAC3 _net__Set8021XPxeTimeout ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XPxeTimeout(struct soap*, _net__Set8021XPxeTimeout **, const char*, const char*); +SOAP_FMAC3 _net__Set8021XPxeTimeout ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XPxeTimeout(struct soap*, const char*, _net__Set8021XPxeTimeout **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Get8021XActiveS0Response +#define SOAP_TYPE_PointerTo_net__Get8021XActiveS0Response (1211) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XActiveS0Response(struct soap*, _net__Get8021XActiveS0Response *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XActiveS0Response(struct soap*, _net__Get8021XActiveS0Response *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XActiveS0Response(struct soap*, const char *, int, _net__Get8021XActiveS0Response *const*, const char *); +SOAP_FMAC3 _net__Get8021XActiveS0Response ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XActiveS0Response(struct soap*, _net__Get8021XActiveS0Response **, const char*, const char*); +SOAP_FMAC3 _net__Get8021XActiveS0Response ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XActiveS0Response(struct soap*, const char*, _net__Get8021XActiveS0Response **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Get8021XActiveS0 +#define SOAP_TYPE_PointerTo_net__Get8021XActiveS0 (1210) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XActiveS0(struct soap*, _net__Get8021XActiveS0 *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XActiveS0(struct soap*, _net__Get8021XActiveS0 *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XActiveS0(struct soap*, const char *, int, _net__Get8021XActiveS0 *const*, const char *); +SOAP_FMAC3 _net__Get8021XActiveS0 ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XActiveS0(struct soap*, _net__Get8021XActiveS0 **, const char*, const char*); +SOAP_FMAC3 _net__Get8021XActiveS0 ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XActiveS0(struct soap*, const char*, _net__Get8021XActiveS0 **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Set8021XActiveS0Response +#define SOAP_TYPE_PointerTo_net__Set8021XActiveS0Response (1207) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XActiveS0Response(struct soap*, _net__Set8021XActiveS0Response *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XActiveS0Response(struct soap*, _net__Set8021XActiveS0Response *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XActiveS0Response(struct soap*, const char *, int, _net__Set8021XActiveS0Response *const*, const char *); +SOAP_FMAC3 _net__Set8021XActiveS0Response ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XActiveS0Response(struct soap*, _net__Set8021XActiveS0Response **, const char*, const char*); +SOAP_FMAC3 _net__Set8021XActiveS0Response ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XActiveS0Response(struct soap*, const char*, _net__Set8021XActiveS0Response **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Set8021XActiveS0 +#define SOAP_TYPE_PointerTo_net__Set8021XActiveS0 (1206) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XActiveS0(struct soap*, _net__Set8021XActiveS0 *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XActiveS0(struct soap*, _net__Set8021XActiveS0 *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XActiveS0(struct soap*, const char *, int, _net__Set8021XActiveS0 *const*, const char *); +SOAP_FMAC3 _net__Set8021XActiveS0 ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XActiveS0(struct soap*, _net__Set8021XActiveS0 **, const char*, const char*); +SOAP_FMAC3 _net__Set8021XActiveS0 ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XActiveS0(struct soap*, const char*, _net__Set8021XActiveS0 **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Get8021XWiredProfileResponse +#define SOAP_TYPE_PointerTo_net__Get8021XWiredProfileResponse (1203) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XWiredProfileResponse(struct soap*, _net__Get8021XWiredProfileResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XWiredProfileResponse(struct soap*, _net__Get8021XWiredProfileResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XWiredProfileResponse(struct soap*, const char *, int, _net__Get8021XWiredProfileResponse *const*, const char *); +SOAP_FMAC3 _net__Get8021XWiredProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XWiredProfileResponse(struct soap*, _net__Get8021XWiredProfileResponse **, const char*, const char*); +SOAP_FMAC3 _net__Get8021XWiredProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XWiredProfileResponse(struct soap*, const char*, _net__Get8021XWiredProfileResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Get8021XWiredProfile +#define SOAP_TYPE_PointerTo_net__Get8021XWiredProfile (1202) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XWiredProfile(struct soap*, _net__Get8021XWiredProfile *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XWiredProfile(struct soap*, _net__Get8021XWiredProfile *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XWiredProfile(struct soap*, const char *, int, _net__Get8021XWiredProfile *const*, const char *); +SOAP_FMAC3 _net__Get8021XWiredProfile ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XWiredProfile(struct soap*, _net__Get8021XWiredProfile **, const char*, const char*); +SOAP_FMAC3 _net__Get8021XWiredProfile ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XWiredProfile(struct soap*, const char*, _net__Get8021XWiredProfile **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Set8021XWiredProfileResponse +#define SOAP_TYPE_PointerTo_net__Set8021XWiredProfileResponse (1199) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XWiredProfileResponse(struct soap*, _net__Set8021XWiredProfileResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XWiredProfileResponse(struct soap*, _net__Set8021XWiredProfileResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XWiredProfileResponse(struct soap*, const char *, int, _net__Set8021XWiredProfileResponse *const*, const char *); +SOAP_FMAC3 _net__Set8021XWiredProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XWiredProfileResponse(struct soap*, _net__Set8021XWiredProfileResponse **, const char*, const char*); +SOAP_FMAC3 _net__Set8021XWiredProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XWiredProfileResponse(struct soap*, const char*, _net__Set8021XWiredProfileResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__Set8021XWiredProfile +#define SOAP_TYPE_PointerTo_net__Set8021XWiredProfile (1198) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XWiredProfile(struct soap*, _net__Set8021XWiredProfile *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XWiredProfile(struct soap*, _net__Set8021XWiredProfile *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XWiredProfile(struct soap*, const char *, int, _net__Set8021XWiredProfile *const*, const char *); +SOAP_FMAC3 _net__Set8021XWiredProfile ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XWiredProfile(struct soap*, _net__Set8021XWiredProfile **, const char*, const char*); +SOAP_FMAC3 _net__Set8021XWiredProfile ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XWiredProfile(struct soap*, const char*, _net__Set8021XWiredProfile **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetInterfaceSettingsResponse +#define SOAP_TYPE_PointerTo_net__SetInterfaceSettingsResponse (1195) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetInterfaceSettingsResponse(struct soap*, _net__SetInterfaceSettingsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetInterfaceSettingsResponse(struct soap*, _net__SetInterfaceSettingsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetInterfaceSettingsResponse(struct soap*, const char *, int, _net__SetInterfaceSettingsResponse *const*, const char *); +SOAP_FMAC3 _net__SetInterfaceSettingsResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetInterfaceSettingsResponse(struct soap*, _net__SetInterfaceSettingsResponse **, const char*, const char*); +SOAP_FMAC3 _net__SetInterfaceSettingsResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetInterfaceSettingsResponse(struct soap*, const char*, _net__SetInterfaceSettingsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetInterfaceSettings +#define SOAP_TYPE_PointerTo_net__SetInterfaceSettings (1194) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetInterfaceSettings(struct soap*, _net__SetInterfaceSettings *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetInterfaceSettings(struct soap*, _net__SetInterfaceSettings *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetInterfaceSettings(struct soap*, const char *, int, _net__SetInterfaceSettings *const*, const char *); +SOAP_FMAC3 _net__SetInterfaceSettings ** SOAP_FMAC4 soap_get_PointerTo_net__SetInterfaceSettings(struct soap*, _net__SetInterfaceSettings **, const char*, const char*); +SOAP_FMAC3 _net__SetInterfaceSettings ** SOAP_FMAC4 soap_in_PointerTo_net__SetInterfaceSettings(struct soap*, const char*, _net__SetInterfaceSettings **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetInterfaceSettingsResponse +#define SOAP_TYPE_PointerTo_net__GetInterfaceSettingsResponse (1191) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetInterfaceSettingsResponse(struct soap*, _net__GetInterfaceSettingsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetInterfaceSettingsResponse(struct soap*, _net__GetInterfaceSettingsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetInterfaceSettingsResponse(struct soap*, const char *, int, _net__GetInterfaceSettingsResponse *const*, const char *); +SOAP_FMAC3 _net__GetInterfaceSettingsResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetInterfaceSettingsResponse(struct soap*, _net__GetInterfaceSettingsResponse **, const char*, const char*); +SOAP_FMAC3 _net__GetInterfaceSettingsResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetInterfaceSettingsResponse(struct soap*, const char*, _net__GetInterfaceSettingsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetInterfaceSettings +#define SOAP_TYPE_PointerTo_net__GetInterfaceSettings (1190) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetInterfaceSettings(struct soap*, _net__GetInterfaceSettings *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetInterfaceSettings(struct soap*, _net__GetInterfaceSettings *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetInterfaceSettings(struct soap*, const char *, int, _net__GetInterfaceSettings *const*, const char *); +SOAP_FMAC3 _net__GetInterfaceSettings ** SOAP_FMAC4 soap_get_PointerTo_net__GetInterfaceSettings(struct soap*, _net__GetInterfaceSettings **, const char*, const char*); +SOAP_FMAC3 _net__GetInterfaceSettings ** SOAP_FMAC4 soap_in_PointerTo_net__GetInterfaceSettings(struct soap*, const char*, _net__GetInterfaceSettings **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__EnumerateInterfacesResponse +#define SOAP_TYPE_PointerTo_net__EnumerateInterfacesResponse (1187) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__EnumerateInterfacesResponse(struct soap*, _net__EnumerateInterfacesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__EnumerateInterfacesResponse(struct soap*, _net__EnumerateInterfacesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__EnumerateInterfacesResponse(struct soap*, const char *, int, _net__EnumerateInterfacesResponse *const*, const char *); +SOAP_FMAC3 _net__EnumerateInterfacesResponse ** SOAP_FMAC4 soap_get_PointerTo_net__EnumerateInterfacesResponse(struct soap*, _net__EnumerateInterfacesResponse **, const char*, const char*); +SOAP_FMAC3 _net__EnumerateInterfacesResponse ** SOAP_FMAC4 soap_in_PointerTo_net__EnumerateInterfacesResponse(struct soap*, const char*, _net__EnumerateInterfacesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__EnumerateInterfaces +#define SOAP_TYPE_PointerTo_net__EnumerateInterfaces (1186) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__EnumerateInterfaces(struct soap*, _net__EnumerateInterfaces *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__EnumerateInterfaces(struct soap*, _net__EnumerateInterfaces *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__EnumerateInterfaces(struct soap*, const char *, int, _net__EnumerateInterfaces *const*, const char *); +SOAP_FMAC3 _net__EnumerateInterfaces ** SOAP_FMAC4 soap_get_PointerTo_net__EnumerateInterfaces(struct soap*, _net__EnumerateInterfaces **, const char*, const char*); +SOAP_FMAC3 _net__EnumerateInterfaces ** SOAP_FMAC4 soap_in_PointerTo_net__EnumerateInterfaces(struct soap*, const char*, _net__EnumerateInterfaces **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetPingResponseResponse +#define SOAP_TYPE_PointerTo_net__GetPingResponseResponse (1183) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetPingResponseResponse(struct soap*, _net__GetPingResponseResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetPingResponseResponse(struct soap*, _net__GetPingResponseResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetPingResponseResponse(struct soap*, const char *, int, _net__GetPingResponseResponse *const*, const char *); +SOAP_FMAC3 _net__GetPingResponseResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetPingResponseResponse(struct soap*, _net__GetPingResponseResponse **, const char*, const char*); +SOAP_FMAC3 _net__GetPingResponseResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetPingResponseResponse(struct soap*, const char*, _net__GetPingResponseResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetPingResponse +#define SOAP_TYPE_PointerTo_net__GetPingResponse (1182) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetPingResponse(struct soap*, _net__GetPingResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetPingResponse(struct soap*, _net__GetPingResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetPingResponse(struct soap*, const char *, int, _net__GetPingResponse *const*, const char *); +SOAP_FMAC3 _net__GetPingResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetPingResponse(struct soap*, _net__GetPingResponse **, const char*, const char*); +SOAP_FMAC3 _net__GetPingResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetPingResponse(struct soap*, const char*, _net__GetPingResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetPingResponseResponse +#define SOAP_TYPE_PointerTo_net__SetPingResponseResponse (1179) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetPingResponseResponse(struct soap*, _net__SetPingResponseResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetPingResponseResponse(struct soap*, _net__SetPingResponseResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetPingResponseResponse(struct soap*, const char *, int, _net__SetPingResponseResponse *const*, const char *); +SOAP_FMAC3 _net__SetPingResponseResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetPingResponseResponse(struct soap*, _net__SetPingResponseResponse **, const char*, const char*); +SOAP_FMAC3 _net__SetPingResponseResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetPingResponseResponse(struct soap*, const char*, _net__SetPingResponseResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetPingResponse +#define SOAP_TYPE_PointerTo_net__SetPingResponse (1178) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetPingResponse(struct soap*, _net__SetPingResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetPingResponse(struct soap*, _net__SetPingResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetPingResponse(struct soap*, const char *, int, _net__SetPingResponse *const*, const char *); +SOAP_FMAC3 _net__SetPingResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetPingResponse(struct soap*, _net__SetPingResponse **, const char*, const char*); +SOAP_FMAC3 _net__SetPingResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetPingResponse(struct soap*, const char*, _net__SetPingResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetVlanParametersResponse +#define SOAP_TYPE_PointerTo_net__GetVlanParametersResponse (1175) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetVlanParametersResponse(struct soap*, _net__GetVlanParametersResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetVlanParametersResponse(struct soap*, _net__GetVlanParametersResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetVlanParametersResponse(struct soap*, const char *, int, _net__GetVlanParametersResponse *const*, const char *); +SOAP_FMAC3 _net__GetVlanParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetVlanParametersResponse(struct soap*, _net__GetVlanParametersResponse **, const char*, const char*); +SOAP_FMAC3 _net__GetVlanParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetVlanParametersResponse(struct soap*, const char*, _net__GetVlanParametersResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetVlanParameters +#define SOAP_TYPE_PointerTo_net__GetVlanParameters (1174) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetVlanParameters(struct soap*, _net__GetVlanParameters *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetVlanParameters(struct soap*, _net__GetVlanParameters *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetVlanParameters(struct soap*, const char *, int, _net__GetVlanParameters *const*, const char *); +SOAP_FMAC3 _net__GetVlanParameters ** SOAP_FMAC4 soap_get_PointerTo_net__GetVlanParameters(struct soap*, _net__GetVlanParameters **, const char*, const char*); +SOAP_FMAC3 _net__GetVlanParameters ** SOAP_FMAC4 soap_in_PointerTo_net__GetVlanParameters(struct soap*, const char*, _net__GetVlanParameters **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetVlanParametersResponse +#define SOAP_TYPE_PointerTo_net__SetVlanParametersResponse (1171) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetVlanParametersResponse(struct soap*, _net__SetVlanParametersResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetVlanParametersResponse(struct soap*, _net__SetVlanParametersResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetVlanParametersResponse(struct soap*, const char *, int, _net__SetVlanParametersResponse *const*, const char *); +SOAP_FMAC3 _net__SetVlanParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetVlanParametersResponse(struct soap*, _net__SetVlanParametersResponse **, const char*, const char*); +SOAP_FMAC3 _net__SetVlanParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetVlanParametersResponse(struct soap*, const char*, _net__SetVlanParametersResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetVlanParameters +#define SOAP_TYPE_PointerTo_net__SetVlanParameters (1170) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetVlanParameters(struct soap*, _net__SetVlanParameters *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetVlanParameters(struct soap*, _net__SetVlanParameters *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetVlanParameters(struct soap*, const char *, int, _net__SetVlanParameters *const*, const char *); +SOAP_FMAC3 _net__SetVlanParameters ** SOAP_FMAC4 soap_get_PointerTo_net__SetVlanParameters(struct soap*, _net__SetVlanParameters **, const char*, const char*); +SOAP_FMAC3 _net__SetVlanParameters ** SOAP_FMAC4 soap_in_PointerTo_net__SetVlanParameters(struct soap*, const char*, _net__SetVlanParameters **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetTcpIpParametersResponse +#define SOAP_TYPE_PointerTo_net__GetTcpIpParametersResponse (1167) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetTcpIpParametersResponse(struct soap*, _net__GetTcpIpParametersResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetTcpIpParametersResponse(struct soap*, _net__GetTcpIpParametersResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetTcpIpParametersResponse(struct soap*, const char *, int, _net__GetTcpIpParametersResponse *const*, const char *); +SOAP_FMAC3 _net__GetTcpIpParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetTcpIpParametersResponse(struct soap*, _net__GetTcpIpParametersResponse **, const char*, const char*); +SOAP_FMAC3 _net__GetTcpIpParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetTcpIpParametersResponse(struct soap*, const char*, _net__GetTcpIpParametersResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetTcpIpParameters +#define SOAP_TYPE_PointerTo_net__GetTcpIpParameters (1166) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetTcpIpParameters(struct soap*, _net__GetTcpIpParameters *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetTcpIpParameters(struct soap*, _net__GetTcpIpParameters *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetTcpIpParameters(struct soap*, const char *, int, _net__GetTcpIpParameters *const*, const char *); +SOAP_FMAC3 _net__GetTcpIpParameters ** SOAP_FMAC4 soap_get_PointerTo_net__GetTcpIpParameters(struct soap*, _net__GetTcpIpParameters **, const char*, const char*); +SOAP_FMAC3 _net__GetTcpIpParameters ** SOAP_FMAC4 soap_in_PointerTo_net__GetTcpIpParameters(struct soap*, const char*, _net__GetTcpIpParameters **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetTcpIpParametersResponse +#define SOAP_TYPE_PointerTo_net__SetTcpIpParametersResponse (1163) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetTcpIpParametersResponse(struct soap*, _net__SetTcpIpParametersResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetTcpIpParametersResponse(struct soap*, _net__SetTcpIpParametersResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetTcpIpParametersResponse(struct soap*, const char *, int, _net__SetTcpIpParametersResponse *const*, const char *); +SOAP_FMAC3 _net__SetTcpIpParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetTcpIpParametersResponse(struct soap*, _net__SetTcpIpParametersResponse **, const char*, const char*); +SOAP_FMAC3 _net__SetTcpIpParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetTcpIpParametersResponse(struct soap*, const char*, _net__SetTcpIpParametersResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetTcpIpParameters +#define SOAP_TYPE_PointerTo_net__SetTcpIpParameters (1162) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetTcpIpParameters(struct soap*, _net__SetTcpIpParameters *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetTcpIpParameters(struct soap*, _net__SetTcpIpParameters *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetTcpIpParameters(struct soap*, const char *, int, _net__SetTcpIpParameters *const*, const char *); +SOAP_FMAC3 _net__SetTcpIpParameters ** SOAP_FMAC4 soap_get_PointerTo_net__SetTcpIpParameters(struct soap*, _net__SetTcpIpParameters **, const char*, const char*); +SOAP_FMAC3 _net__SetTcpIpParameters ** SOAP_FMAC4 soap_in_PointerTo_net__SetTcpIpParameters(struct soap*, const char*, _net__SetTcpIpParameters **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetDomainNameResponse +#define SOAP_TYPE_PointerTo_net__GetDomainNameResponse (1159) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetDomainNameResponse(struct soap*, _net__GetDomainNameResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetDomainNameResponse(struct soap*, _net__GetDomainNameResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetDomainNameResponse(struct soap*, const char *, int, _net__GetDomainNameResponse *const*, const char *); +SOAP_FMAC3 _net__GetDomainNameResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetDomainNameResponse(struct soap*, _net__GetDomainNameResponse **, const char*, const char*); +SOAP_FMAC3 _net__GetDomainNameResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetDomainNameResponse(struct soap*, const char*, _net__GetDomainNameResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetDomainName +#define SOAP_TYPE_PointerTo_net__GetDomainName (1158) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetDomainName(struct soap*, _net__GetDomainName *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetDomainName(struct soap*, _net__GetDomainName *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetDomainName(struct soap*, const char *, int, _net__GetDomainName *const*, const char *); +SOAP_FMAC3 _net__GetDomainName ** SOAP_FMAC4 soap_get_PointerTo_net__GetDomainName(struct soap*, _net__GetDomainName **, const char*, const char*); +SOAP_FMAC3 _net__GetDomainName ** SOAP_FMAC4 soap_in_PointerTo_net__GetDomainName(struct soap*, const char*, _net__GetDomainName **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetDomainNameResponse +#define SOAP_TYPE_PointerTo_net__SetDomainNameResponse (1155) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetDomainNameResponse(struct soap*, _net__SetDomainNameResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetDomainNameResponse(struct soap*, _net__SetDomainNameResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetDomainNameResponse(struct soap*, const char *, int, _net__SetDomainNameResponse *const*, const char *); +SOAP_FMAC3 _net__SetDomainNameResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetDomainNameResponse(struct soap*, _net__SetDomainNameResponse **, const char*, const char*); +SOAP_FMAC3 _net__SetDomainNameResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetDomainNameResponse(struct soap*, const char*, _net__SetDomainNameResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetDomainName +#define SOAP_TYPE_PointerTo_net__SetDomainName (1154) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetDomainName(struct soap*, _net__SetDomainName *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetDomainName(struct soap*, _net__SetDomainName *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetDomainName(struct soap*, const char *, int, _net__SetDomainName *const*, const char *); +SOAP_FMAC3 _net__SetDomainName ** SOAP_FMAC4 soap_get_PointerTo_net__SetDomainName(struct soap*, _net__SetDomainName **, const char*, const char*); +SOAP_FMAC3 _net__SetDomainName ** SOAP_FMAC4 soap_in_PointerTo_net__SetDomainName(struct soap*, const char*, _net__SetDomainName **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetHostNameResponse +#define SOAP_TYPE_PointerTo_net__GetHostNameResponse (1151) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetHostNameResponse(struct soap*, _net__GetHostNameResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetHostNameResponse(struct soap*, _net__GetHostNameResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetHostNameResponse(struct soap*, const char *, int, _net__GetHostNameResponse *const*, const char *); +SOAP_FMAC3 _net__GetHostNameResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetHostNameResponse(struct soap*, _net__GetHostNameResponse **, const char*, const char*); +SOAP_FMAC3 _net__GetHostNameResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetHostNameResponse(struct soap*, const char*, _net__GetHostNameResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__GetHostName +#define SOAP_TYPE_PointerTo_net__GetHostName (1150) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetHostName(struct soap*, _net__GetHostName *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetHostName(struct soap*, _net__GetHostName *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetHostName(struct soap*, const char *, int, _net__GetHostName *const*, const char *); +SOAP_FMAC3 _net__GetHostName ** SOAP_FMAC4 soap_get_PointerTo_net__GetHostName(struct soap*, _net__GetHostName **, const char*, const char*); +SOAP_FMAC3 _net__GetHostName ** SOAP_FMAC4 soap_in_PointerTo_net__GetHostName(struct soap*, const char*, _net__GetHostName **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetHostNameResponse +#define SOAP_TYPE_PointerTo_net__SetHostNameResponse (1147) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetHostNameResponse(struct soap*, _net__SetHostNameResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetHostNameResponse(struct soap*, _net__SetHostNameResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetHostNameResponse(struct soap*, const char *, int, _net__SetHostNameResponse *const*, const char *); +SOAP_FMAC3 _net__SetHostNameResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetHostNameResponse(struct soap*, _net__SetHostNameResponse **, const char*, const char*); +SOAP_FMAC3 _net__SetHostNameResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetHostNameResponse(struct soap*, const char*, _net__SetHostNameResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_net__SetHostName +#define SOAP_TYPE_PointerTo_net__SetHostName (1146) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetHostName(struct soap*, _net__SetHostName *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetHostName(struct soap*, _net__SetHostName *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetHostName(struct soap*, const char *, int, _net__SetHostName *const*, const char *); +SOAP_FMAC3 _net__SetHostName ** SOAP_FMAC4 soap_get_PointerTo_net__SetHostName(struct soap*, _net__SetHostName **, const char*, const char*); +SOAP_FMAC3 _net__SetHostName ** SOAP_FMAC4 soap_in_PointerTo_net__SetHostName(struct soap*, const char*, _net__SetHostName **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetIderSessionLogResponse +#define SOAP_TYPE_PointerTo_inf__GetIderSessionLogResponse (1143) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetIderSessionLogResponse(struct soap*, _inf__GetIderSessionLogResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetIderSessionLogResponse(struct soap*, _inf__GetIderSessionLogResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetIderSessionLogResponse(struct soap*, const char *, int, _inf__GetIderSessionLogResponse *const*, const char *); +SOAP_FMAC3 _inf__GetIderSessionLogResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetIderSessionLogResponse(struct soap*, _inf__GetIderSessionLogResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetIderSessionLogResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetIderSessionLogResponse(struct soap*, const char*, _inf__GetIderSessionLogResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetIderSessionLog +#define SOAP_TYPE_PointerTo_inf__GetIderSessionLog (1142) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetIderSessionLog(struct soap*, _inf__GetIderSessionLog *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetIderSessionLog(struct soap*, _inf__GetIderSessionLog *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetIderSessionLog(struct soap*, const char *, int, _inf__GetIderSessionLog *const*, const char *); +SOAP_FMAC3 _inf__GetIderSessionLog ** SOAP_FMAC4 soap_get_PointerTo_inf__GetIderSessionLog(struct soap*, _inf__GetIderSessionLog **, const char*, const char*); +SOAP_FMAC3 _inf__GetIderSessionLog ** SOAP_FMAC4 soap_in_PointerTo_inf__GetIderSessionLog(struct soap*, const char*, _inf__GetIderSessionLog **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetSecurityParametersResponse +#define SOAP_TYPE_PointerTo_inf__GetSecurityParametersResponse (1139) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetSecurityParametersResponse(struct soap*, _inf__GetSecurityParametersResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetSecurityParametersResponse(struct soap*, _inf__GetSecurityParametersResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetSecurityParametersResponse(struct soap*, const char *, int, _inf__GetSecurityParametersResponse *const*, const char *); +SOAP_FMAC3 _inf__GetSecurityParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetSecurityParametersResponse(struct soap*, _inf__GetSecurityParametersResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetSecurityParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetSecurityParametersResponse(struct soap*, const char*, _inf__GetSecurityParametersResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetSecurityParameters +#define SOAP_TYPE_PointerTo_inf__GetSecurityParameters (1138) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetSecurityParameters(struct soap*, _inf__GetSecurityParameters *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetSecurityParameters(struct soap*, _inf__GetSecurityParameters *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetSecurityParameters(struct soap*, const char *, int, _inf__GetSecurityParameters *const*, const char *); +SOAP_FMAC3 _inf__GetSecurityParameters ** SOAP_FMAC4 soap_get_PointerTo_inf__GetSecurityParameters(struct soap*, _inf__GetSecurityParameters **, const char*, const char*); +SOAP_FMAC3 _inf__GetSecurityParameters ** SOAP_FMAC4 soap_in_PointerTo_inf__GetSecurityParameters(struct soap*, const char*, _inf__GetSecurityParameters **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetNetworkStateResponse +#define SOAP_TYPE_PointerTo_inf__GetNetworkStateResponse (1135) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetNetworkStateResponse(struct soap*, _inf__GetNetworkStateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetNetworkStateResponse(struct soap*, _inf__GetNetworkStateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetNetworkStateResponse(struct soap*, const char *, int, _inf__GetNetworkStateResponse *const*, const char *); +SOAP_FMAC3 _inf__GetNetworkStateResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetNetworkStateResponse(struct soap*, _inf__GetNetworkStateResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetNetworkStateResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetNetworkStateResponse(struct soap*, const char*, _inf__GetNetworkStateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetNetworkState +#define SOAP_TYPE_PointerTo_inf__GetNetworkState (1134) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetNetworkState(struct soap*, _inf__GetNetworkState *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetNetworkState(struct soap*, _inf__GetNetworkState *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetNetworkState(struct soap*, const char *, int, _inf__GetNetworkState *const*, const char *); +SOAP_FMAC3 _inf__GetNetworkState ** SOAP_FMAC4 soap_get_PointerTo_inf__GetNetworkState(struct soap*, _inf__GetNetworkState **, const char*, const char*); +SOAP_FMAC3 _inf__GetNetworkState ** SOAP_FMAC4 soap_in_PointerTo_inf__GetNetworkState(struct soap*, const char*, _inf__GetNetworkState **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetEnabledInterfacesResponse +#define SOAP_TYPE_PointerTo_inf__GetEnabledInterfacesResponse (1131) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetEnabledInterfacesResponse(struct soap*, _inf__GetEnabledInterfacesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetEnabledInterfacesResponse(struct soap*, _inf__GetEnabledInterfacesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetEnabledInterfacesResponse(struct soap*, const char *, int, _inf__GetEnabledInterfacesResponse *const*, const char *); +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetEnabledInterfacesResponse(struct soap*, _inf__GetEnabledInterfacesResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetEnabledInterfacesResponse(struct soap*, const char*, _inf__GetEnabledInterfacesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetEnabledInterfaces +#define SOAP_TYPE_PointerTo_inf__GetEnabledInterfaces (1130) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetEnabledInterfaces(struct soap*, _inf__GetEnabledInterfaces *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetEnabledInterfaces(struct soap*, _inf__GetEnabledInterfaces *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetEnabledInterfaces(struct soap*, const char *, int, _inf__GetEnabledInterfaces *const*, const char *); +SOAP_FMAC3 _inf__GetEnabledInterfaces ** SOAP_FMAC4 soap_get_PointerTo_inf__GetEnabledInterfaces(struct soap*, _inf__GetEnabledInterfaces **, const char*, const char*); +SOAP_FMAC3 _inf__GetEnabledInterfaces ** SOAP_FMAC4 soap_in_PointerTo_inf__GetEnabledInterfaces(struct soap*, const char*, _inf__GetEnabledInterfaces **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetPasswordModelResponse +#define SOAP_TYPE_PointerTo_inf__GetPasswordModelResponse (1127) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetPasswordModelResponse(struct soap*, _inf__GetPasswordModelResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetPasswordModelResponse(struct soap*, _inf__GetPasswordModelResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetPasswordModelResponse(struct soap*, const char *, int, _inf__GetPasswordModelResponse *const*, const char *); +SOAP_FMAC3 _inf__GetPasswordModelResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetPasswordModelResponse(struct soap*, _inf__GetPasswordModelResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetPasswordModelResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetPasswordModelResponse(struct soap*, const char*, _inf__GetPasswordModelResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetPasswordModel +#define SOAP_TYPE_PointerTo_inf__GetPasswordModel (1126) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetPasswordModel(struct soap*, _inf__GetPasswordModel *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetPasswordModel(struct soap*, _inf__GetPasswordModel *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetPasswordModel(struct soap*, const char *, int, _inf__GetPasswordModel *const*, const char *); +SOAP_FMAC3 _inf__GetPasswordModel ** SOAP_FMAC4 soap_get_PointerTo_inf__GetPasswordModel(struct soap*, _inf__GetPasswordModel **, const char*, const char*); +SOAP_FMAC3 _inf__GetPasswordModel ** SOAP_FMAC4 soap_in_PointerTo_inf__GetPasswordModel(struct soap*, const char*, _inf__GetPasswordModel **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatusResponse +#define SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatusResponse (1123) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap*, _inf__GetAdminNetAclEntryStatusResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap*, _inf__GetAdminNetAclEntryStatusResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap*, const char *, int, _inf__GetAdminNetAclEntryStatusResponse *const*, const char *); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap*, _inf__GetAdminNetAclEntryStatusResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap*, const char*, _inf__GetAdminNetAclEntryStatusResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatus +#define SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatus (1122) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap*, _inf__GetAdminNetAclEntryStatus *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap*, _inf__GetAdminNetAclEntryStatus *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap*, const char *, int, _inf__GetAdminNetAclEntryStatus *const*, const char *); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus ** SOAP_FMAC4 soap_get_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap*, _inf__GetAdminNetAclEntryStatus **, const char*, const char*); +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus ** SOAP_FMAC4 soap_in_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap*, const char*, _inf__GetAdminNetAclEntryStatus **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatusResponse +#define SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatusResponse (1119) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap*, _inf__GetAdminAclEntryStatusResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap*, _inf__GetAdminAclEntryStatusResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap*, const char *, int, _inf__GetAdminAclEntryStatusResponse *const*, const char *); +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap*, _inf__GetAdminAclEntryStatusResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap*, const char*, _inf__GetAdminAclEntryStatusResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatus +#define SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatus (1118) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetAdminAclEntryStatus(struct soap*, _inf__GetAdminAclEntryStatus *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetAdminAclEntryStatus(struct soap*, _inf__GetAdminAclEntryStatus *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetAdminAclEntryStatus(struct soap*, const char *, int, _inf__GetAdminAclEntryStatus *const*, const char *); +SOAP_FMAC3 _inf__GetAdminAclEntryStatus ** SOAP_FMAC4 soap_get_PointerTo_inf__GetAdminAclEntryStatus(struct soap*, _inf__GetAdminAclEntryStatus **, const char*, const char*); +SOAP_FMAC3 _inf__GetAdminAclEntryStatus ** SOAP_FMAC4 soap_in_PointerTo_inf__GetAdminAclEntryStatus(struct soap*, const char*, _inf__GetAdminAclEntryStatus **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetConfigServerInfoResponse +#define SOAP_TYPE_PointerTo_inf__GetConfigServerInfoResponse (1115) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetConfigServerInfoResponse(struct soap*, _inf__GetConfigServerInfoResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetConfigServerInfoResponse(struct soap*, _inf__GetConfigServerInfoResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetConfigServerInfoResponse(struct soap*, const char *, int, _inf__GetConfigServerInfoResponse *const*, const char *); +SOAP_FMAC3 _inf__GetConfigServerInfoResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetConfigServerInfoResponse(struct soap*, _inf__GetConfigServerInfoResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetConfigServerInfoResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetConfigServerInfoResponse(struct soap*, const char*, _inf__GetConfigServerInfoResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetConfigServerInfo +#define SOAP_TYPE_PointerTo_inf__GetConfigServerInfo (1114) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetConfigServerInfo(struct soap*, _inf__GetConfigServerInfo *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetConfigServerInfo(struct soap*, _inf__GetConfigServerInfo *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetConfigServerInfo(struct soap*, const char *, int, _inf__GetConfigServerInfo *const*, const char *); +SOAP_FMAC3 _inf__GetConfigServerInfo ** SOAP_FMAC4 soap_get_PointerTo_inf__GetConfigServerInfo(struct soap*, _inf__GetConfigServerInfo **, const char*, const char*); +SOAP_FMAC3 _inf__GetConfigServerInfo ** SOAP_FMAC4 soap_in_PointerTo_inf__GetConfigServerInfo(struct soap*, const char*, _inf__GetConfigServerInfo **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetHostNameResponse +#define SOAP_TYPE_PointerTo_inf__GetHostNameResponse (1111) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetHostNameResponse(struct soap*, _inf__GetHostNameResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetHostNameResponse(struct soap*, _inf__GetHostNameResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetHostNameResponse(struct soap*, const char *, int, _inf__GetHostNameResponse *const*, const char *); +SOAP_FMAC3 _inf__GetHostNameResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetHostNameResponse(struct soap*, _inf__GetHostNameResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetHostNameResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetHostNameResponse(struct soap*, const char*, _inf__GetHostNameResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetHostName +#define SOAP_TYPE_PointerTo_inf__GetHostName (1110) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetHostName(struct soap*, _inf__GetHostName *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetHostName(struct soap*, _inf__GetHostName *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetHostName(struct soap*, const char *, int, _inf__GetHostName *const*, const char *); +SOAP_FMAC3 _inf__GetHostName ** SOAP_FMAC4 soap_get_PointerTo_inf__GetHostName(struct soap*, _inf__GetHostName **, const char*, const char*); +SOAP_FMAC3 _inf__GetHostName ** SOAP_FMAC4 soap_in_PointerTo_inf__GetHostName(struct soap*, const char*, _inf__GetHostName **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetVlanParametersResponse +#define SOAP_TYPE_PointerTo_inf__GetVlanParametersResponse (1107) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetVlanParametersResponse(struct soap*, _inf__GetVlanParametersResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetVlanParametersResponse(struct soap*, _inf__GetVlanParametersResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetVlanParametersResponse(struct soap*, const char *, int, _inf__GetVlanParametersResponse *const*, const char *); +SOAP_FMAC3 _inf__GetVlanParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetVlanParametersResponse(struct soap*, _inf__GetVlanParametersResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetVlanParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetVlanParametersResponse(struct soap*, const char*, _inf__GetVlanParametersResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetVlanParameters +#define SOAP_TYPE_PointerTo_inf__GetVlanParameters (1106) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetVlanParameters(struct soap*, _inf__GetVlanParameters *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetVlanParameters(struct soap*, _inf__GetVlanParameters *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetVlanParameters(struct soap*, const char *, int, _inf__GetVlanParameters *const*, const char *); +SOAP_FMAC3 _inf__GetVlanParameters ** SOAP_FMAC4 soap_get_PointerTo_inf__GetVlanParameters(struct soap*, _inf__GetVlanParameters **, const char*, const char*); +SOAP_FMAC3 _inf__GetVlanParameters ** SOAP_FMAC4 soap_in_PointerTo_inf__GetVlanParameters(struct soap*, const char*, _inf__GetVlanParameters **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetProvisioningStateResponse +#define SOAP_TYPE_PointerTo_inf__GetProvisioningStateResponse (1103) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetProvisioningStateResponse(struct soap*, _inf__GetProvisioningStateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetProvisioningStateResponse(struct soap*, _inf__GetProvisioningStateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetProvisioningStateResponse(struct soap*, const char *, int, _inf__GetProvisioningStateResponse *const*, const char *); +SOAP_FMAC3 _inf__GetProvisioningStateResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetProvisioningStateResponse(struct soap*, _inf__GetProvisioningStateResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetProvisioningStateResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetProvisioningStateResponse(struct soap*, const char*, _inf__GetProvisioningStateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetProvisioningState +#define SOAP_TYPE_PointerTo_inf__GetProvisioningState (1102) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetProvisioningState(struct soap*, _inf__GetProvisioningState *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetProvisioningState(struct soap*, _inf__GetProvisioningState *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetProvisioningState(struct soap*, const char *, int, _inf__GetProvisioningState *const*, const char *); +SOAP_FMAC3 _inf__GetProvisioningState ** SOAP_FMAC4 soap_get_PointerTo_inf__GetProvisioningState(struct soap*, _inf__GetProvisioningState **, const char*, const char*); +SOAP_FMAC3 _inf__GetProvisioningState ** SOAP_FMAC4 soap_in_PointerTo_inf__GetProvisioningState(struct soap*, const char*, _inf__GetProvisioningState **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetProvisioningModeResponse +#define SOAP_TYPE_PointerTo_inf__GetProvisioningModeResponse (1099) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetProvisioningModeResponse(struct soap*, _inf__GetProvisioningModeResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetProvisioningModeResponse(struct soap*, _inf__GetProvisioningModeResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetProvisioningModeResponse(struct soap*, const char *, int, _inf__GetProvisioningModeResponse *const*, const char *); +SOAP_FMAC3 _inf__GetProvisioningModeResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetProvisioningModeResponse(struct soap*, _inf__GetProvisioningModeResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetProvisioningModeResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetProvisioningModeResponse(struct soap*, const char*, _inf__GetProvisioningModeResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetProvisioningMode +#define SOAP_TYPE_PointerTo_inf__GetProvisioningMode (1098) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetProvisioningMode(struct soap*, _inf__GetProvisioningMode *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetProvisioningMode(struct soap*, _inf__GetProvisioningMode *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetProvisioningMode(struct soap*, const char *, int, _inf__GetProvisioningMode *const*, const char *); +SOAP_FMAC3 _inf__GetProvisioningMode ** SOAP_FMAC4 soap_get_PointerTo_inf__GetProvisioningMode(struct soap*, _inf__GetProvisioningMode **, const char*, const char*); +SOAP_FMAC3 _inf__GetProvisioningMode ** SOAP_FMAC4 soap_in_PointerTo_inf__GetProvisioningMode(struct soap*, const char*, _inf__GetProvisioningMode **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetCodeVersionsResponse +#define SOAP_TYPE_PointerTo_inf__GetCodeVersionsResponse (1095) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetCodeVersionsResponse(struct soap*, _inf__GetCodeVersionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetCodeVersionsResponse(struct soap*, _inf__GetCodeVersionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetCodeVersionsResponse(struct soap*, const char *, int, _inf__GetCodeVersionsResponse *const*, const char *); +SOAP_FMAC3 _inf__GetCodeVersionsResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetCodeVersionsResponse(struct soap*, _inf__GetCodeVersionsResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetCodeVersionsResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetCodeVersionsResponse(struct soap*, const char*, _inf__GetCodeVersionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetCodeVersions +#define SOAP_TYPE_PointerTo_inf__GetCodeVersions (1094) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetCodeVersions(struct soap*, _inf__GetCodeVersions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetCodeVersions(struct soap*, _inf__GetCodeVersions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetCodeVersions(struct soap*, const char *, int, _inf__GetCodeVersions *const*, const char *); +SOAP_FMAC3 _inf__GetCodeVersions ** SOAP_FMAC4 soap_get_PointerTo_inf__GetCodeVersions(struct soap*, _inf__GetCodeVersions **, const char*, const char*); +SOAP_FMAC3 _inf__GetCodeVersions ** SOAP_FMAC4 soap_in_PointerTo_inf__GetCodeVersions(struct soap*, const char*, _inf__GetCodeVersions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetCoreVersionResponse +#define SOAP_TYPE_PointerTo_inf__GetCoreVersionResponse (1091) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetCoreVersionResponse(struct soap*, _inf__GetCoreVersionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetCoreVersionResponse(struct soap*, _inf__GetCoreVersionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetCoreVersionResponse(struct soap*, const char *, int, _inf__GetCoreVersionResponse *const*, const char *); +SOAP_FMAC3 _inf__GetCoreVersionResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetCoreVersionResponse(struct soap*, _inf__GetCoreVersionResponse **, const char*, const char*); +SOAP_FMAC3 _inf__GetCoreVersionResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetCoreVersionResponse(struct soap*, const char*, _inf__GetCoreVersionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_inf__GetCoreVersion +#define SOAP_TYPE_PointerTo_inf__GetCoreVersion (1090) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetCoreVersion(struct soap*, _inf__GetCoreVersion *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetCoreVersion(struct soap*, _inf__GetCoreVersion *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetCoreVersion(struct soap*, const char *, int, _inf__GetCoreVersion *const*, const char *); +SOAP_FMAC3 _inf__GetCoreVersion ** SOAP_FMAC4 soap_get_PointerTo_inf__GetCoreVersion(struct soap*, _inf__GetCoreVersion **, const char*, const char*); +SOAP_FMAC3 _inf__GetCoreVersion ** SOAP_FMAC4 soap_in_PointerTo_inf__GetCoreVersion(struct soap*, const char*, _inf__GetCoreVersion **, const char*); + +#ifndef SOAP_TYPE_PointerTo_idr__GetIderSessionLogResponse +#define SOAP_TYPE_PointerTo_idr__GetIderSessionLogResponse (1087) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__GetIderSessionLogResponse(struct soap*, _idr__GetIderSessionLogResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__GetIderSessionLogResponse(struct soap*, _idr__GetIderSessionLogResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__GetIderSessionLogResponse(struct soap*, const char *, int, _idr__GetIderSessionLogResponse *const*, const char *); +SOAP_FMAC3 _idr__GetIderSessionLogResponse ** SOAP_FMAC4 soap_get_PointerTo_idr__GetIderSessionLogResponse(struct soap*, _idr__GetIderSessionLogResponse **, const char*, const char*); +SOAP_FMAC3 _idr__GetIderSessionLogResponse ** SOAP_FMAC4 soap_in_PointerTo_idr__GetIderSessionLogResponse(struct soap*, const char*, _idr__GetIderSessionLogResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_idr__GetIderSessionLog +#define SOAP_TYPE_PointerTo_idr__GetIderSessionLog (1086) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__GetIderSessionLog(struct soap*, _idr__GetIderSessionLog *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__GetIderSessionLog(struct soap*, _idr__GetIderSessionLog *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__GetIderSessionLog(struct soap*, const char *, int, _idr__GetIderSessionLog *const*, const char *); +SOAP_FMAC3 _idr__GetIderSessionLog ** SOAP_FMAC4 soap_get_PointerTo_idr__GetIderSessionLog(struct soap*, _idr__GetIderSessionLog **, const char*, const char*); +SOAP_FMAC3 _idr__GetIderSessionLog ** SOAP_FMAC4 soap_in_PointerTo_idr__GetIderSessionLog(struct soap*, const char*, _idr__GetIderSessionLog **, const char*); + +#ifndef SOAP_TYPE_PointerTo_idr__GetRedirectionListenerStateResponse +#define SOAP_TYPE_PointerTo_idr__GetRedirectionListenerStateResponse (1083) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap*, _idr__GetRedirectionListenerStateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap*, _idr__GetRedirectionListenerStateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap*, const char *, int, _idr__GetRedirectionListenerStateResponse *const*, const char *); +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse ** SOAP_FMAC4 soap_get_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap*, _idr__GetRedirectionListenerStateResponse **, const char*, const char*); +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse ** SOAP_FMAC4 soap_in_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap*, const char*, _idr__GetRedirectionListenerStateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_idr__GetRedirectionListenerState +#define SOAP_TYPE_PointerTo_idr__GetRedirectionListenerState (1082) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__GetRedirectionListenerState(struct soap*, _idr__GetRedirectionListenerState *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__GetRedirectionListenerState(struct soap*, _idr__GetRedirectionListenerState *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__GetRedirectionListenerState(struct soap*, const char *, int, _idr__GetRedirectionListenerState *const*, const char *); +SOAP_FMAC3 _idr__GetRedirectionListenerState ** SOAP_FMAC4 soap_get_PointerTo_idr__GetRedirectionListenerState(struct soap*, _idr__GetRedirectionListenerState **, const char*, const char*); +SOAP_FMAC3 _idr__GetRedirectionListenerState ** SOAP_FMAC4 soap_in_PointerTo_idr__GetRedirectionListenerState(struct soap*, const char*, _idr__GetRedirectionListenerState **, const char*); + +#ifndef SOAP_TYPE_PointerTo_idr__SetRedirectionListenerStateResponse +#define SOAP_TYPE_PointerTo_idr__SetRedirectionListenerStateResponse (1079) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap*, _idr__SetRedirectionListenerStateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap*, _idr__SetRedirectionListenerStateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap*, const char *, int, _idr__SetRedirectionListenerStateResponse *const*, const char *); +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse ** SOAP_FMAC4 soap_get_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap*, _idr__SetRedirectionListenerStateResponse **, const char*, const char*); +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse ** SOAP_FMAC4 soap_in_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap*, const char*, _idr__SetRedirectionListenerStateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_idr__SetRedirectionListenerState +#define SOAP_TYPE_PointerTo_idr__SetRedirectionListenerState (1078) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__SetRedirectionListenerState(struct soap*, _idr__SetRedirectionListenerState *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__SetRedirectionListenerState(struct soap*, _idr__SetRedirectionListenerState *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__SetRedirectionListenerState(struct soap*, const char *, int, _idr__SetRedirectionListenerState *const*, const char *); +SOAP_FMAC3 _idr__SetRedirectionListenerState ** SOAP_FMAC4 soap_get_PointerTo_idr__SetRedirectionListenerState(struct soap*, _idr__SetRedirectionListenerState **, const char*, const char*); +SOAP_FMAC3 _idr__SetRedirectionListenerState ** SOAP_FMAC4 soap_in_PointerTo_idr__SetRedirectionListenerState(struct soap*, const char*, _idr__SetRedirectionListenerState **, const char*); + +#ifndef SOAP_TYPE_PointerTo_hwa__GetAssetDataResponse +#define SOAP_TYPE_PointerTo_hwa__GetAssetDataResponse (1075) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_hwa__GetAssetDataResponse(struct soap*, _hwa__GetAssetDataResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_hwa__GetAssetDataResponse(struct soap*, _hwa__GetAssetDataResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_hwa__GetAssetDataResponse(struct soap*, const char *, int, _hwa__GetAssetDataResponse *const*, const char *); +SOAP_FMAC3 _hwa__GetAssetDataResponse ** SOAP_FMAC4 soap_get_PointerTo_hwa__GetAssetDataResponse(struct soap*, _hwa__GetAssetDataResponse **, const char*, const char*); +SOAP_FMAC3 _hwa__GetAssetDataResponse ** SOAP_FMAC4 soap_in_PointerTo_hwa__GetAssetDataResponse(struct soap*, const char*, _hwa__GetAssetDataResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_hwa__GetAssetData +#define SOAP_TYPE_PointerTo_hwa__GetAssetData (1074) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_hwa__GetAssetData(struct soap*, _hwa__GetAssetData *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_hwa__GetAssetData(struct soap*, _hwa__GetAssetData *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_hwa__GetAssetData(struct soap*, const char *, int, _hwa__GetAssetData *const*, const char *); +SOAP_FMAC3 _hwa__GetAssetData ** SOAP_FMAC4 soap_get_PointerTo_hwa__GetAssetData(struct soap*, _hwa__GetAssetData **, const char*, const char*); +SOAP_FMAC3 _hwa__GetAssetData ** SOAP_FMAC4 soap_in_PointerTo_hwa__GetAssetData(struct soap*, const char*, _hwa__GetAssetData **, const char*); + +#ifndef SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypesResponse +#define SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypesResponse (1071) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap*, _hwa__EnumerateAssetTypesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap*, _hwa__EnumerateAssetTypesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap*, const char *, int, _hwa__EnumerateAssetTypesResponse *const*, const char *); +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse ** SOAP_FMAC4 soap_get_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap*, _hwa__EnumerateAssetTypesResponse **, const char*, const char*); +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse ** SOAP_FMAC4 soap_in_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap*, const char*, _hwa__EnumerateAssetTypesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypes +#define SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypes (1070) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_hwa__EnumerateAssetTypes(struct soap*, _hwa__EnumerateAssetTypes *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_hwa__EnumerateAssetTypes(struct soap*, _hwa__EnumerateAssetTypes *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_hwa__EnumerateAssetTypes(struct soap*, const char *, int, _hwa__EnumerateAssetTypes *const*, const char *); +SOAP_FMAC3 _hwa__EnumerateAssetTypes ** SOAP_FMAC4 soap_get_PointerTo_hwa__EnumerateAssetTypes(struct soap*, _hwa__EnumerateAssetTypes **, const char*, const char*); +SOAP_FMAC3 _hwa__EnumerateAssetTypes ** SOAP_FMAC4 soap_in_PointerTo_hwa__EnumerateAssetTypes(struct soap*, const char*, _hwa__EnumerateAssetTypes **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscriptionResponse +#define SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscriptionResponse (1067) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap*, _emi__GetGeneralAlertSubscriptionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap*, _emi__GetGeneralAlertSubscriptionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap*, const char *, int, _emi__GetGeneralAlertSubscriptionResponse *const*, const char *); +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap*, _emi__GetGeneralAlertSubscriptionResponse **, const char*, const char*); +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap*, const char*, _emi__GetGeneralAlertSubscriptionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscription +#define SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscription (1066) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetGeneralAlertSubscription(struct soap*, _emi__GetGeneralAlertSubscription *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetGeneralAlertSubscription(struct soap*, _emi__GetGeneralAlertSubscription *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetGeneralAlertSubscription(struct soap*, const char *, int, _emi__GetGeneralAlertSubscription *const*, const char *); +SOAP_FMAC3 _emi__GetGeneralAlertSubscription ** SOAP_FMAC4 soap_get_PointerTo_emi__GetGeneralAlertSubscription(struct soap*, _emi__GetGeneralAlertSubscription **, const char*, const char*); +SOAP_FMAC3 _emi__GetGeneralAlertSubscription ** SOAP_FMAC4 soap_in_PointerTo_emi__GetGeneralAlertSubscription(struct soap*, const char*, _emi__GetGeneralAlertSubscription **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse +#define SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse (1063) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, _emi__EnumerateGeneralAlertSubscriptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, _emi__EnumerateGeneralAlertSubscriptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, const char *, int, _emi__EnumerateGeneralAlertSubscriptionsResponse *const*, const char *); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, _emi__EnumerateGeneralAlertSubscriptionsResponse **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap*, const char*, _emi__EnumerateGeneralAlertSubscriptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptions +#define SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptions (1062) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap*, _emi__EnumerateGeneralAlertSubscriptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap*, _emi__EnumerateGeneralAlertSubscriptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap*, const char *, int, _emi__EnumerateGeneralAlertSubscriptions *const*, const char *); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap*, _emi__EnumerateGeneralAlertSubscriptions **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap*, const char*, _emi__EnumerateGeneralAlertSubscriptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlertResponse +#define SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlertResponse (1059) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap*, _emi__SubscribeForGeneralAlertResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap*, _emi__SubscribeForGeneralAlertResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap*, const char *, int, _emi__SubscribeForGeneralAlertResponse *const*, const char *); +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap*, _emi__SubscribeForGeneralAlertResponse **, const char*, const char*); +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap*, const char*, _emi__SubscribeForGeneralAlertResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlert +#define SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlert (1058) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SubscribeForGeneralAlert(struct soap*, _emi__SubscribeForGeneralAlert *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SubscribeForGeneralAlert(struct soap*, _emi__SubscribeForGeneralAlert *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SubscribeForGeneralAlert(struct soap*, const char *, int, _emi__SubscribeForGeneralAlert *const*, const char *); +SOAP_FMAC3 _emi__SubscribeForGeneralAlert ** SOAP_FMAC4 soap_get_PointerTo_emi__SubscribeForGeneralAlert(struct soap*, _emi__SubscribeForGeneralAlert **, const char*, const char*); +SOAP_FMAC3 _emi__SubscribeForGeneralAlert ** SOAP_FMAC4 soap_in_PointerTo_emi__SubscribeForGeneralAlert(struct soap*, const char*, _emi__SubscribeForGeneralAlert **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetSensorAttributesResponse +#define SOAP_TYPE_PointerTo_emi__GetSensorAttributesResponse (1055) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetSensorAttributesResponse(struct soap*, _emi__GetSensorAttributesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetSensorAttributesResponse(struct soap*, _emi__GetSensorAttributesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetSensorAttributesResponse(struct soap*, const char *, int, _emi__GetSensorAttributesResponse *const*, const char *); +SOAP_FMAC3 _emi__GetSensorAttributesResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetSensorAttributesResponse(struct soap*, _emi__GetSensorAttributesResponse **, const char*, const char*); +SOAP_FMAC3 _emi__GetSensorAttributesResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetSensorAttributesResponse(struct soap*, const char*, _emi__GetSensorAttributesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetSensorAttributes +#define SOAP_TYPE_PointerTo_emi__GetSensorAttributes (1054) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetSensorAttributes(struct soap*, _emi__GetSensorAttributes *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetSensorAttributes(struct soap*, _emi__GetSensorAttributes *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetSensorAttributes(struct soap*, const char *, int, _emi__GetSensorAttributes *const*, const char *); +SOAP_FMAC3 _emi__GetSensorAttributes ** SOAP_FMAC4 soap_get_PointerTo_emi__GetSensorAttributes(struct soap*, _emi__GetSensorAttributes **, const char*, const char*); +SOAP_FMAC3 _emi__GetSensorAttributes ** SOAP_FMAC4 soap_in_PointerTo_emi__GetSensorAttributes(struct soap*, const char*, _emi__GetSensorAttributes **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateSensorsResponse +#define SOAP_TYPE_PointerTo_emi__EnumerateSensorsResponse (1051) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateSensorsResponse(struct soap*, _emi__EnumerateSensorsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateSensorsResponse(struct soap*, _emi__EnumerateSensorsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateSensorsResponse(struct soap*, const char *, int, _emi__EnumerateSensorsResponse *const*, const char *); +SOAP_FMAC3 _emi__EnumerateSensorsResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateSensorsResponse(struct soap*, _emi__EnumerateSensorsResponse **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateSensorsResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateSensorsResponse(struct soap*, const char*, _emi__EnumerateSensorsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateSensors +#define SOAP_TYPE_PointerTo_emi__EnumerateSensors (1050) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateSensors(struct soap*, _emi__EnumerateSensors *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateSensors(struct soap*, _emi__EnumerateSensors *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateSensors(struct soap*, const char *, int, _emi__EnumerateSensors *const*, const char *); +SOAP_FMAC3 _emi__EnumerateSensors ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateSensors(struct soap*, _emi__EnumerateSensors **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateSensors ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateSensors(struct soap*, const char*, _emi__EnumerateSensors **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClockResponse +#define SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClockResponse (1047) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap*, _emi__GetEventLogTimestampClockResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap*, _emi__GetEventLogTimestampClockResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap*, const char *, int, _emi__GetEventLogTimestampClockResponse *const*, const char *); +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap*, _emi__GetEventLogTimestampClockResponse **, const char*, const char*); +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap*, const char*, _emi__GetEventLogTimestampClockResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClock +#define SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClock (1046) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventLogTimestampClock(struct soap*, _emi__GetEventLogTimestampClock *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventLogTimestampClock(struct soap*, _emi__GetEventLogTimestampClock *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventLogTimestampClock(struct soap*, const char *, int, _emi__GetEventLogTimestampClock *const*, const char *); +SOAP_FMAC3 _emi__GetEventLogTimestampClock ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventLogTimestampClock(struct soap*, _emi__GetEventLogTimestampClock **, const char*, const char*); +SOAP_FMAC3 _emi__GetEventLogTimestampClock ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventLogTimestampClock(struct soap*, const char*, _emi__GetEventLogTimestampClock **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClockResponse +#define SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClockResponse (1043) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap*, _emi__SetEventLogTimestampClockResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap*, _emi__SetEventLogTimestampClockResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap*, const char *, int, _emi__SetEventLogTimestampClockResponse *const*, const char *); +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap*, _emi__SetEventLogTimestampClockResponse **, const char*, const char*); +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap*, const char*, _emi__SetEventLogTimestampClockResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClock +#define SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClock (1042) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SetEventLogTimestampClock(struct soap*, _emi__SetEventLogTimestampClock *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SetEventLogTimestampClock(struct soap*, _emi__SetEventLogTimestampClock *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SetEventLogTimestampClock(struct soap*, const char *, int, _emi__SetEventLogTimestampClock *const*, const char *); +SOAP_FMAC3 _emi__SetEventLogTimestampClock ** SOAP_FMAC4 soap_get_PointerTo_emi__SetEventLogTimestampClock(struct soap*, _emi__SetEventLogTimestampClock **, const char*, const char*); +SOAP_FMAC3 _emi__SetEventLogTimestampClock ** SOAP_FMAC4 soap_in_PointerTo_emi__SetEventLogTimestampClock(struct soap*, const char*, _emi__SetEventLogTimestampClock **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__FreezeEventLogResponse +#define SOAP_TYPE_PointerTo_emi__FreezeEventLogResponse (1039) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__FreezeEventLogResponse(struct soap*, _emi__FreezeEventLogResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__FreezeEventLogResponse(struct soap*, _emi__FreezeEventLogResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__FreezeEventLogResponse(struct soap*, const char *, int, _emi__FreezeEventLogResponse *const*, const char *); +SOAP_FMAC3 _emi__FreezeEventLogResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__FreezeEventLogResponse(struct soap*, _emi__FreezeEventLogResponse **, const char*, const char*); +SOAP_FMAC3 _emi__FreezeEventLogResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__FreezeEventLogResponse(struct soap*, const char*, _emi__FreezeEventLogResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__FreezeEventLog +#define SOAP_TYPE_PointerTo_emi__FreezeEventLog (1038) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__FreezeEventLog(struct soap*, _emi__FreezeEventLog *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__FreezeEventLog(struct soap*, _emi__FreezeEventLog *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__FreezeEventLog(struct soap*, const char *, int, _emi__FreezeEventLog *const*, const char *); +SOAP_FMAC3 _emi__FreezeEventLog ** SOAP_FMAC4 soap_get_PointerTo_emi__FreezeEventLog(struct soap*, _emi__FreezeEventLog **, const char*, const char*); +SOAP_FMAC3 _emi__FreezeEventLog ** SOAP_FMAC4 soap_in_PointerTo_emi__FreezeEventLog(struct soap*, const char*, _emi__FreezeEventLog **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__ClearEventLogResponse +#define SOAP_TYPE_PointerTo_emi__ClearEventLogResponse (1035) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__ClearEventLogResponse(struct soap*, _emi__ClearEventLogResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__ClearEventLogResponse(struct soap*, _emi__ClearEventLogResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__ClearEventLogResponse(struct soap*, const char *, int, _emi__ClearEventLogResponse *const*, const char *); +SOAP_FMAC3 _emi__ClearEventLogResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__ClearEventLogResponse(struct soap*, _emi__ClearEventLogResponse **, const char*, const char*); +SOAP_FMAC3 _emi__ClearEventLogResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__ClearEventLogResponse(struct soap*, const char*, _emi__ClearEventLogResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__ClearEventLog +#define SOAP_TYPE_PointerTo_emi__ClearEventLog (1034) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__ClearEventLog(struct soap*, _emi__ClearEventLog *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__ClearEventLog(struct soap*, _emi__ClearEventLog *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__ClearEventLog(struct soap*, const char *, int, _emi__ClearEventLog *const*, const char *); +SOAP_FMAC3 _emi__ClearEventLog ** SOAP_FMAC4 soap_get_PointerTo_emi__ClearEventLog(struct soap*, _emi__ClearEventLog **, const char*, const char*); +SOAP_FMAC3 _emi__ClearEventLog ** SOAP_FMAC4 soap_in_PointerTo_emi__ClearEventLog(struct soap*, const char*, _emi__ClearEventLog **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__ReadEventLogRecordsResponse +#define SOAP_TYPE_PointerTo_emi__ReadEventLogRecordsResponse (1031) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__ReadEventLogRecordsResponse(struct soap*, _emi__ReadEventLogRecordsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__ReadEventLogRecordsResponse(struct soap*, _emi__ReadEventLogRecordsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__ReadEventLogRecordsResponse(struct soap*, const char *, int, _emi__ReadEventLogRecordsResponse *const*, const char *); +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__ReadEventLogRecordsResponse(struct soap*, _emi__ReadEventLogRecordsResponse **, const char*, const char*); +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__ReadEventLogRecordsResponse(struct soap*, const char*, _emi__ReadEventLogRecordsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__ReadEventLogRecords +#define SOAP_TYPE_PointerTo_emi__ReadEventLogRecords (1030) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__ReadEventLogRecords(struct soap*, _emi__ReadEventLogRecords *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__ReadEventLogRecords(struct soap*, _emi__ReadEventLogRecords *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__ReadEventLogRecords(struct soap*, const char *, int, _emi__ReadEventLogRecords *const*, const char *); +SOAP_FMAC3 _emi__ReadEventLogRecords ** SOAP_FMAC4 soap_get_PointerTo_emi__ReadEventLogRecords(struct soap*, _emi__ReadEventLogRecords **, const char*, const char*); +SOAP_FMAC3 _emi__ReadEventLogRecords ** SOAP_FMAC4 soap_in_PointerTo_emi__ReadEventLogRecords(struct soap*, const char*, _emi__ReadEventLogRecords **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetEventLogStatusResponse +#define SOAP_TYPE_PointerTo_emi__GetEventLogStatusResponse (1027) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventLogStatusResponse(struct soap*, _emi__GetEventLogStatusResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventLogStatusResponse(struct soap*, _emi__GetEventLogStatusResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventLogStatusResponse(struct soap*, const char *, int, _emi__GetEventLogStatusResponse *const*, const char *); +SOAP_FMAC3 _emi__GetEventLogStatusResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventLogStatusResponse(struct soap*, _emi__GetEventLogStatusResponse **, const char*, const char*); +SOAP_FMAC3 _emi__GetEventLogStatusResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventLogStatusResponse(struct soap*, const char*, _emi__GetEventLogStatusResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetEventLogStatus +#define SOAP_TYPE_PointerTo_emi__GetEventLogStatus (1026) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventLogStatus(struct soap*, _emi__GetEventLogStatus *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventLogStatus(struct soap*, _emi__GetEventLogStatus *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventLogStatus(struct soap*, const char *, int, _emi__GetEventLogStatus *const*, const char *); +SOAP_FMAC3 _emi__GetEventLogStatus ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventLogStatus(struct soap*, _emi__GetEventLogStatus **, const char*, const char*); +SOAP_FMAC3 _emi__GetEventLogStatus ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventLogStatus(struct soap*, const char*, _emi__GetEventLogStatus **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__RemoveEventFilterResponse +#define SOAP_TYPE_PointerTo_emi__RemoveEventFilterResponse (1023) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__RemoveEventFilterResponse(struct soap*, _emi__RemoveEventFilterResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__RemoveEventFilterResponse(struct soap*, _emi__RemoveEventFilterResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__RemoveEventFilterResponse(struct soap*, const char *, int, _emi__RemoveEventFilterResponse *const*, const char *); +SOAP_FMAC3 _emi__RemoveEventFilterResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__RemoveEventFilterResponse(struct soap*, _emi__RemoveEventFilterResponse **, const char*, const char*); +SOAP_FMAC3 _emi__RemoveEventFilterResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__RemoveEventFilterResponse(struct soap*, const char*, _emi__RemoveEventFilterResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__RemoveEventFilter +#define SOAP_TYPE_PointerTo_emi__RemoveEventFilter (1022) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__RemoveEventFilter(struct soap*, _emi__RemoveEventFilter *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__RemoveEventFilter(struct soap*, _emi__RemoveEventFilter *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__RemoveEventFilter(struct soap*, const char *, int, _emi__RemoveEventFilter *const*, const char *); +SOAP_FMAC3 _emi__RemoveEventFilter ** SOAP_FMAC4 soap_get_PointerTo_emi__RemoveEventFilter(struct soap*, _emi__RemoveEventFilter **, const char*, const char*); +SOAP_FMAC3 _emi__RemoveEventFilter ** SOAP_FMAC4 soap_in_PointerTo_emi__RemoveEventFilter(struct soap*, const char*, _emi__RemoveEventFilter **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__UpdateEventFilterResponse +#define SOAP_TYPE_PointerTo_emi__UpdateEventFilterResponse (1019) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__UpdateEventFilterResponse(struct soap*, _emi__UpdateEventFilterResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__UpdateEventFilterResponse(struct soap*, _emi__UpdateEventFilterResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__UpdateEventFilterResponse(struct soap*, const char *, int, _emi__UpdateEventFilterResponse *const*, const char *); +SOAP_FMAC3 _emi__UpdateEventFilterResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__UpdateEventFilterResponse(struct soap*, _emi__UpdateEventFilterResponse **, const char*, const char*); +SOAP_FMAC3 _emi__UpdateEventFilterResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__UpdateEventFilterResponse(struct soap*, const char*, _emi__UpdateEventFilterResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__UpdateEventFilter +#define SOAP_TYPE_PointerTo_emi__UpdateEventFilter (1018) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__UpdateEventFilter(struct soap*, _emi__UpdateEventFilter *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__UpdateEventFilter(struct soap*, _emi__UpdateEventFilter *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__UpdateEventFilter(struct soap*, const char *, int, _emi__UpdateEventFilter *const*, const char *); +SOAP_FMAC3 _emi__UpdateEventFilter ** SOAP_FMAC4 soap_get_PointerTo_emi__UpdateEventFilter(struct soap*, _emi__UpdateEventFilter **, const char*, const char*); +SOAP_FMAC3 _emi__UpdateEventFilter ** SOAP_FMAC4 soap_in_PointerTo_emi__UpdateEventFilter(struct soap*, const char*, _emi__UpdateEventFilter **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetEventFilterResponse +#define SOAP_TYPE_PointerTo_emi__GetEventFilterResponse (1015) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventFilterResponse(struct soap*, _emi__GetEventFilterResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventFilterResponse(struct soap*, _emi__GetEventFilterResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventFilterResponse(struct soap*, const char *, int, _emi__GetEventFilterResponse *const*, const char *); +SOAP_FMAC3 _emi__GetEventFilterResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventFilterResponse(struct soap*, _emi__GetEventFilterResponse **, const char*, const char*); +SOAP_FMAC3 _emi__GetEventFilterResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventFilterResponse(struct soap*, const char*, _emi__GetEventFilterResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetEventFilter +#define SOAP_TYPE_PointerTo_emi__GetEventFilter (1014) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventFilter(struct soap*, _emi__GetEventFilter *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventFilter(struct soap*, _emi__GetEventFilter *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventFilter(struct soap*, const char *, int, _emi__GetEventFilter *const*, const char *); +SOAP_FMAC3 _emi__GetEventFilter ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventFilter(struct soap*, _emi__GetEventFilter **, const char*, const char*); +SOAP_FMAC3 _emi__GetEventFilter ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventFilter(struct soap*, const char*, _emi__GetEventFilter **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__CancelAlertSubscriptionResponse +#define SOAP_TYPE_PointerTo_emi__CancelAlertSubscriptionResponse (1011) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap*, _emi__CancelAlertSubscriptionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap*, _emi__CancelAlertSubscriptionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap*, const char *, int, _emi__CancelAlertSubscriptionResponse *const*, const char *); +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap*, _emi__CancelAlertSubscriptionResponse **, const char*, const char*); +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap*, const char*, _emi__CancelAlertSubscriptionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__CancelAlertSubscription +#define SOAP_TYPE_PointerTo_emi__CancelAlertSubscription (1010) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__CancelAlertSubscription(struct soap*, _emi__CancelAlertSubscription *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__CancelAlertSubscription(struct soap*, _emi__CancelAlertSubscription *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__CancelAlertSubscription(struct soap*, const char *, int, _emi__CancelAlertSubscription *const*, const char *); +SOAP_FMAC3 _emi__CancelAlertSubscription ** SOAP_FMAC4 soap_get_PointerTo_emi__CancelAlertSubscription(struct soap*, _emi__CancelAlertSubscription **, const char*, const char*); +SOAP_FMAC3 _emi__CancelAlertSubscription ** SOAP_FMAC4 soap_in_PointerTo_emi__CancelAlertSubscription(struct soap*, const char*, _emi__CancelAlertSubscription **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateAlertPoliciesResponse +#define SOAP_TYPE_PointerTo_emi__EnumerateAlertPoliciesResponse (1007) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap*, _emi__EnumerateAlertPoliciesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap*, _emi__EnumerateAlertPoliciesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap*, const char *, int, _emi__EnumerateAlertPoliciesResponse *const*, const char *); +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap*, _emi__EnumerateAlertPoliciesResponse **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap*, const char*, _emi__EnumerateAlertPoliciesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateAlertPolicies +#define SOAP_TYPE_PointerTo_emi__EnumerateAlertPolicies (1006) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateAlertPolicies(struct soap*, _emi__EnumerateAlertPolicies *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateAlertPolicies(struct soap*, _emi__EnumerateAlertPolicies *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateAlertPolicies(struct soap*, const char *, int, _emi__EnumerateAlertPolicies *const*, const char *); +SOAP_FMAC3 _emi__EnumerateAlertPolicies ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateAlertPolicies(struct soap*, _emi__EnumerateAlertPolicies **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateAlertPolicies ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateAlertPolicies(struct soap*, const char*, _emi__EnumerateAlertPolicies **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptionsResponse +#define SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptionsResponse (1003) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap*, _emi__EnumerateAlertSubscriptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap*, _emi__EnumerateAlertSubscriptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap*, const char *, int, _emi__EnumerateAlertSubscriptionsResponse *const*, const char *); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap*, _emi__EnumerateAlertSubscriptionsResponse **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap*, const char*, _emi__EnumerateAlertSubscriptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptions +#define SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptions (1002) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateAlertSubscriptions(struct soap*, _emi__EnumerateAlertSubscriptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateAlertSubscriptions(struct soap*, _emi__EnumerateAlertSubscriptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateAlertSubscriptions(struct soap*, const char *, int, _emi__EnumerateAlertSubscriptions *const*, const char *); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateAlertSubscriptions(struct soap*, _emi__EnumerateAlertSubscriptions **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateAlertSubscriptions(struct soap*, const char*, _emi__EnumerateAlertSubscriptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__SubscribeForAlertResponse +#define SOAP_TYPE_PointerTo_emi__SubscribeForAlertResponse (999) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SubscribeForAlertResponse(struct soap*, _emi__SubscribeForAlertResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SubscribeForAlertResponse(struct soap*, _emi__SubscribeForAlertResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SubscribeForAlertResponse(struct soap*, const char *, int, _emi__SubscribeForAlertResponse *const*, const char *); +SOAP_FMAC3 _emi__SubscribeForAlertResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__SubscribeForAlertResponse(struct soap*, _emi__SubscribeForAlertResponse **, const char*, const char*); +SOAP_FMAC3 _emi__SubscribeForAlertResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__SubscribeForAlertResponse(struct soap*, const char*, _emi__SubscribeForAlertResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__SubscribeForAlert +#define SOAP_TYPE_PointerTo_emi__SubscribeForAlert (998) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SubscribeForAlert(struct soap*, _emi__SubscribeForAlert *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SubscribeForAlert(struct soap*, _emi__SubscribeForAlert *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SubscribeForAlert(struct soap*, const char *, int, _emi__SubscribeForAlert *const*, const char *); +SOAP_FMAC3 _emi__SubscribeForAlert ** SOAP_FMAC4 soap_get_PointerTo_emi__SubscribeForAlert(struct soap*, _emi__SubscribeForAlert **, const char*, const char*); +SOAP_FMAC3 _emi__SubscribeForAlert ** SOAP_FMAC4 soap_in_PointerTo_emi__SubscribeForAlert(struct soap*, const char*, _emi__SubscribeForAlert **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__AddEventFilterResponse +#define SOAP_TYPE_PointerTo_emi__AddEventFilterResponse (995) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__AddEventFilterResponse(struct soap*, _emi__AddEventFilterResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__AddEventFilterResponse(struct soap*, _emi__AddEventFilterResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__AddEventFilterResponse(struct soap*, const char *, int, _emi__AddEventFilterResponse *const*, const char *); +SOAP_FMAC3 _emi__AddEventFilterResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__AddEventFilterResponse(struct soap*, _emi__AddEventFilterResponse **, const char*, const char*); +SOAP_FMAC3 _emi__AddEventFilterResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__AddEventFilterResponse(struct soap*, const char*, _emi__AddEventFilterResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__AddEventFilter +#define SOAP_TYPE_PointerTo_emi__AddEventFilter (994) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__AddEventFilter(struct soap*, _emi__AddEventFilter *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__AddEventFilter(struct soap*, _emi__AddEventFilter *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__AddEventFilter(struct soap*, const char *, int, _emi__AddEventFilter *const*, const char *); +SOAP_FMAC3 _emi__AddEventFilter ** SOAP_FMAC4 soap_get_PointerTo_emi__AddEventFilter(struct soap*, _emi__AddEventFilter **, const char*, const char*); +SOAP_FMAC3 _emi__AddEventFilter ** SOAP_FMAC4 soap_in_PointerTo_emi__AddEventFilter(struct soap*, const char*, _emi__AddEventFilter **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetAlertCommunityStringResponse +#define SOAP_TYPE_PointerTo_emi__GetAlertCommunityStringResponse (991) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetAlertCommunityStringResponse(struct soap*, _emi__GetAlertCommunityStringResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetAlertCommunityStringResponse(struct soap*, _emi__GetAlertCommunityStringResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetAlertCommunityStringResponse(struct soap*, const char *, int, _emi__GetAlertCommunityStringResponse *const*, const char *); +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetAlertCommunityStringResponse(struct soap*, _emi__GetAlertCommunityStringResponse **, const char*, const char*); +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetAlertCommunityStringResponse(struct soap*, const char*, _emi__GetAlertCommunityStringResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetAlertCommunityString +#define SOAP_TYPE_PointerTo_emi__GetAlertCommunityString (990) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetAlertCommunityString(struct soap*, _emi__GetAlertCommunityString *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetAlertCommunityString(struct soap*, _emi__GetAlertCommunityString *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetAlertCommunityString(struct soap*, const char *, int, _emi__GetAlertCommunityString *const*, const char *); +SOAP_FMAC3 _emi__GetAlertCommunityString ** SOAP_FMAC4 soap_get_PointerTo_emi__GetAlertCommunityString(struct soap*, _emi__GetAlertCommunityString **, const char*, const char*); +SOAP_FMAC3 _emi__GetAlertCommunityString ** SOAP_FMAC4 soap_in_PointerTo_emi__GetAlertCommunityString(struct soap*, const char*, _emi__GetAlertCommunityString **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__SetAlertCommunityStringResponse +#define SOAP_TYPE_PointerTo_emi__SetAlertCommunityStringResponse (987) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SetAlertCommunityStringResponse(struct soap*, _emi__SetAlertCommunityStringResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SetAlertCommunityStringResponse(struct soap*, _emi__SetAlertCommunityStringResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SetAlertCommunityStringResponse(struct soap*, const char *, int, _emi__SetAlertCommunityStringResponse *const*, const char *); +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__SetAlertCommunityStringResponse(struct soap*, _emi__SetAlertCommunityStringResponse **, const char*, const char*); +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__SetAlertCommunityStringResponse(struct soap*, const char*, _emi__SetAlertCommunityStringResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__SetAlertCommunityString +#define SOAP_TYPE_PointerTo_emi__SetAlertCommunityString (986) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SetAlertCommunityString(struct soap*, _emi__SetAlertCommunityString *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SetAlertCommunityString(struct soap*, _emi__SetAlertCommunityString *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SetAlertCommunityString(struct soap*, const char *, int, _emi__SetAlertCommunityString *const*, const char *); +SOAP_FMAC3 _emi__SetAlertCommunityString ** SOAP_FMAC4 soap_get_PointerTo_emi__SetAlertCommunityString(struct soap*, _emi__SetAlertCommunityString **, const char*, const char*); +SOAP_FMAC3 _emi__SetAlertCommunityString ** SOAP_FMAC4 soap_in_PointerTo_emi__SetAlertCommunityString(struct soap*, const char*, _emi__SetAlertCommunityString **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetAlertSubscriptionResponse +#define SOAP_TYPE_PointerTo_emi__GetAlertSubscriptionResponse (983) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetAlertSubscriptionResponse(struct soap*, _emi__GetAlertSubscriptionResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetAlertSubscriptionResponse(struct soap*, _emi__GetAlertSubscriptionResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetAlertSubscriptionResponse(struct soap*, const char *, int, _emi__GetAlertSubscriptionResponse *const*, const char *); +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetAlertSubscriptionResponse(struct soap*, _emi__GetAlertSubscriptionResponse **, const char*, const char*); +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetAlertSubscriptionResponse(struct soap*, const char*, _emi__GetAlertSubscriptionResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__GetAlertSubscription +#define SOAP_TYPE_PointerTo_emi__GetAlertSubscription (982) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetAlertSubscription(struct soap*, _emi__GetAlertSubscription *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetAlertSubscription(struct soap*, _emi__GetAlertSubscription *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetAlertSubscription(struct soap*, const char *, int, _emi__GetAlertSubscription *const*, const char *); +SOAP_FMAC3 _emi__GetAlertSubscription ** SOAP_FMAC4 soap_get_PointerTo_emi__GetAlertSubscription(struct soap*, _emi__GetAlertSubscription **, const char*, const char*); +SOAP_FMAC3 _emi__GetAlertSubscription ** SOAP_FMAC4 soap_in_PointerTo_emi__GetAlertSubscription(struct soap*, const char*, _emi__GetAlertSubscription **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateEventFiltersResponse +#define SOAP_TYPE_PointerTo_emi__EnumerateEventFiltersResponse (979) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateEventFiltersResponse(struct soap*, _emi__EnumerateEventFiltersResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateEventFiltersResponse(struct soap*, _emi__EnumerateEventFiltersResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateEventFiltersResponse(struct soap*, const char *, int, _emi__EnumerateEventFiltersResponse *const*, const char *); +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateEventFiltersResponse(struct soap*, _emi__EnumerateEventFiltersResponse **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateEventFiltersResponse(struct soap*, const char*, _emi__EnumerateEventFiltersResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_emi__EnumerateEventFilters +#define SOAP_TYPE_PointerTo_emi__EnumerateEventFilters (978) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateEventFilters(struct soap*, _emi__EnumerateEventFilters *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateEventFilters(struct soap*, _emi__EnumerateEventFilters *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateEventFilters(struct soap*, const char *, int, _emi__EnumerateEventFilters *const*, const char *); +SOAP_FMAC3 _emi__EnumerateEventFilters ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateEventFilters(struct soap*, _emi__EnumerateEventFilters **, const char*, const char*); +SOAP_FMAC3 _emi__EnumerateEventFilters ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateEventFilters(struct soap*, const char*, _emi__EnumerateEventFilters **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__GetHcbStateResponse +#define SOAP_TYPE_PointerTo_cb__GetHcbStateResponse (975) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__GetHcbStateResponse(struct soap*, _cb__GetHcbStateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__GetHcbStateResponse(struct soap*, _cb__GetHcbStateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__GetHcbStateResponse(struct soap*, const char *, int, _cb__GetHcbStateResponse *const*, const char *); +SOAP_FMAC3 _cb__GetHcbStateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__GetHcbStateResponse(struct soap*, _cb__GetHcbStateResponse **, const char*, const char*); +SOAP_FMAC3 _cb__GetHcbStateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__GetHcbStateResponse(struct soap*, const char*, _cb__GetHcbStateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__GetHcbState +#define SOAP_TYPE_PointerTo_cb__GetHcbState (974) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__GetHcbState(struct soap*, _cb__GetHcbState *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__GetHcbState(struct soap*, _cb__GetHcbState *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__GetHcbState(struct soap*, const char *, int, _cb__GetHcbState *const*, const char *); +SOAP_FMAC3 _cb__GetHcbState ** SOAP_FMAC4 soap_get_PointerTo_cb__GetHcbState(struct soap*, _cb__GetHcbState **, const char*, const char*); +SOAP_FMAC3 _cb__GetHcbState ** SOAP_FMAC4 soap_in_PointerTo_cb__GetHcbState(struct soap*, const char*, _cb__GetHcbState **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__ClearHcbStateResponse +#define SOAP_TYPE_PointerTo_cb__ClearHcbStateResponse (971) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__ClearHcbStateResponse(struct soap*, _cb__ClearHcbStateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__ClearHcbStateResponse(struct soap*, _cb__ClearHcbStateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__ClearHcbStateResponse(struct soap*, const char *, int, _cb__ClearHcbStateResponse *const*, const char *); +SOAP_FMAC3 _cb__ClearHcbStateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__ClearHcbStateResponse(struct soap*, _cb__ClearHcbStateResponse **, const char*, const char*); +SOAP_FMAC3 _cb__ClearHcbStateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__ClearHcbStateResponse(struct soap*, const char*, _cb__ClearHcbStateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__ClearHcbState +#define SOAP_TYPE_PointerTo_cb__ClearHcbState (970) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__ClearHcbState(struct soap*, _cb__ClearHcbState *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__ClearHcbState(struct soap*, _cb__ClearHcbState *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__ClearHcbState(struct soap*, const char *, int, _cb__ClearHcbState *const*, const char *); +SOAP_FMAC3 _cb__ClearHcbState ** SOAP_FMAC4 soap_get_PointerTo_cb__ClearHcbState(struct soap*, _cb__ClearHcbState **, const char*, const char*); +SOAP_FMAC3 _cb__ClearHcbState ** SOAP_FMAC4 soap_in_PointerTo_cb__ClearHcbState(struct soap*, const char*, _cb__ClearHcbState **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__GetHcbOptionsResponse +#define SOAP_TYPE_PointerTo_cb__GetHcbOptionsResponse (967) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__GetHcbOptionsResponse(struct soap*, _cb__GetHcbOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__GetHcbOptionsResponse(struct soap*, _cb__GetHcbOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__GetHcbOptionsResponse(struct soap*, const char *, int, _cb__GetHcbOptionsResponse *const*, const char *); +SOAP_FMAC3 _cb__GetHcbOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__GetHcbOptionsResponse(struct soap*, _cb__GetHcbOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _cb__GetHcbOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__GetHcbOptionsResponse(struct soap*, const char*, _cb__GetHcbOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__GetHcbOptions +#define SOAP_TYPE_PointerTo_cb__GetHcbOptions (966) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__GetHcbOptions(struct soap*, _cb__GetHcbOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__GetHcbOptions(struct soap*, _cb__GetHcbOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__GetHcbOptions(struct soap*, const char *, int, _cb__GetHcbOptions *const*, const char *); +SOAP_FMAC3 _cb__GetHcbOptions ** SOAP_FMAC4 soap_get_PointerTo_cb__GetHcbOptions(struct soap*, _cb__GetHcbOptions **, const char*, const char*); +SOAP_FMAC3 _cb__GetHcbOptions ** SOAP_FMAC4 soap_in_PointerTo_cb__GetHcbOptions(struct soap*, const char*, _cb__GetHcbOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__SetHcbOptionsResponse +#define SOAP_TYPE_PointerTo_cb__SetHcbOptionsResponse (963) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__SetHcbOptionsResponse(struct soap*, _cb__SetHcbOptionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__SetHcbOptionsResponse(struct soap*, _cb__SetHcbOptionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__SetHcbOptionsResponse(struct soap*, const char *, int, _cb__SetHcbOptionsResponse *const*, const char *); +SOAP_FMAC3 _cb__SetHcbOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__SetHcbOptionsResponse(struct soap*, _cb__SetHcbOptionsResponse **, const char*, const char*); +SOAP_FMAC3 _cb__SetHcbOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__SetHcbOptionsResponse(struct soap*, const char*, _cb__SetHcbOptionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__SetHcbOptions +#define SOAP_TYPE_PointerTo_cb__SetHcbOptions (962) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__SetHcbOptions(struct soap*, _cb__SetHcbOptions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__SetHcbOptions(struct soap*, _cb__SetHcbOptions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__SetHcbOptions(struct soap*, const char *, int, _cb__SetHcbOptions *const*, const char *); +SOAP_FMAC3 _cb__SetHcbOptions ** SOAP_FMAC4 soap_get_PointerTo_cb__SetHcbOptions(struct soap*, _cb__SetHcbOptions **, const char*, const char*); +SOAP_FMAC3 _cb__SetHcbOptions ** SOAP_FMAC4 soap_in_PointerTo_cb__SetHcbOptions(struct soap*, const char*, _cb__SetHcbOptions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbQueryCapabilitiesResponse +#define SOAP_TYPE_PointerTo_cb__CbQueryCapabilitiesResponse (959) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap*, _cb__CbQueryCapabilitiesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap*, _cb__CbQueryCapabilitiesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap*, const char *, int, _cb__CbQueryCapabilitiesResponse *const*, const char *); +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap*, _cb__CbQueryCapabilitiesResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap*, const char*, _cb__CbQueryCapabilitiesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbQueryCapabilities +#define SOAP_TYPE_PointerTo_cb__CbQueryCapabilities (958) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbQueryCapabilities(struct soap*, _cb__CbQueryCapabilities *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbQueryCapabilities(struct soap*, _cb__CbQueryCapabilities *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbQueryCapabilities(struct soap*, const char *, int, _cb__CbQueryCapabilities *const*, const char *); +SOAP_FMAC3 _cb__CbQueryCapabilities ** SOAP_FMAC4 soap_get_PointerTo_cb__CbQueryCapabilities(struct soap*, _cb__CbQueryCapabilities **, const char*, const char*); +SOAP_FMAC3 _cb__CbQueryCapabilities ** SOAP_FMAC4 soap_in_PointerTo_cb__CbQueryCapabilities(struct soap*, const char*, _cb__CbQueryCapabilities **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbFilterEnumerateResponse +#define SOAP_TYPE_PointerTo_cb__CbFilterEnumerateResponse (955) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterEnumerateResponse(struct soap*, _cb__CbFilterEnumerateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterEnumerateResponse(struct soap*, _cb__CbFilterEnumerateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterEnumerateResponse(struct soap*, const char *, int, _cb__CbFilterEnumerateResponse *const*, const char *); +SOAP_FMAC3 _cb__CbFilterEnumerateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterEnumerateResponse(struct soap*, _cb__CbFilterEnumerateResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterEnumerateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterEnumerateResponse(struct soap*, const char*, _cb__CbFilterEnumerateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbFilterEnumerate +#define SOAP_TYPE_PointerTo_cb__CbFilterEnumerate (954) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterEnumerate(struct soap*, _cb__CbFilterEnumerate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterEnumerate(struct soap*, _cb__CbFilterEnumerate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterEnumerate(struct soap*, const char *, int, _cb__CbFilterEnumerate *const*, const char *); +SOAP_FMAC3 _cb__CbFilterEnumerate ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterEnumerate(struct soap*, _cb__CbFilterEnumerate **, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterEnumerate ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterEnumerate(struct soap*, const char*, _cb__CbFilterEnumerate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbFilterDeleteResponse +#define SOAP_TYPE_PointerTo_cb__CbFilterDeleteResponse (951) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterDeleteResponse(struct soap*, _cb__CbFilterDeleteResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterDeleteResponse(struct soap*, _cb__CbFilterDeleteResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterDeleteResponse(struct soap*, const char *, int, _cb__CbFilterDeleteResponse *const*, const char *); +SOAP_FMAC3 _cb__CbFilterDeleteResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterDeleteResponse(struct soap*, _cb__CbFilterDeleteResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterDeleteResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterDeleteResponse(struct soap*, const char*, _cb__CbFilterDeleteResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbFilterDelete +#define SOAP_TYPE_PointerTo_cb__CbFilterDelete (950) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterDelete(struct soap*, _cb__CbFilterDelete *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterDelete(struct soap*, _cb__CbFilterDelete *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterDelete(struct soap*, const char *, int, _cb__CbFilterDelete *const*, const char *); +SOAP_FMAC3 _cb__CbFilterDelete ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterDelete(struct soap*, _cb__CbFilterDelete **, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterDelete ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterDelete(struct soap*, const char*, _cb__CbFilterDelete **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbFilterGetResponse +#define SOAP_TYPE_PointerTo_cb__CbFilterGetResponse (947) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterGetResponse(struct soap*, _cb__CbFilterGetResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterGetResponse(struct soap*, _cb__CbFilterGetResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterGetResponse(struct soap*, const char *, int, _cb__CbFilterGetResponse *const*, const char *); +SOAP_FMAC3 _cb__CbFilterGetResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterGetResponse(struct soap*, _cb__CbFilterGetResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterGetResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterGetResponse(struct soap*, const char*, _cb__CbFilterGetResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbFilterGet +#define SOAP_TYPE_PointerTo_cb__CbFilterGet (946) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterGet(struct soap*, _cb__CbFilterGet *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterGet(struct soap*, _cb__CbFilterGet *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterGet(struct soap*, const char *, int, _cb__CbFilterGet *const*, const char *); +SOAP_FMAC3 _cb__CbFilterGet ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterGet(struct soap*, _cb__CbFilterGet **, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterGet ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterGet(struct soap*, const char*, _cb__CbFilterGet **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbFilterCreateResponse +#define SOAP_TYPE_PointerTo_cb__CbFilterCreateResponse (943) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterCreateResponse(struct soap*, _cb__CbFilterCreateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterCreateResponse(struct soap*, _cb__CbFilterCreateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterCreateResponse(struct soap*, const char *, int, _cb__CbFilterCreateResponse *const*, const char *); +SOAP_FMAC3 _cb__CbFilterCreateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterCreateResponse(struct soap*, _cb__CbFilterCreateResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterCreateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterCreateResponse(struct soap*, const char*, _cb__CbFilterCreateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbFilterCreate +#define SOAP_TYPE_PointerTo_cb__CbFilterCreate (942) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterCreate(struct soap*, _cb__CbFilterCreate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterCreate(struct soap*, _cb__CbFilterCreate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterCreate(struct soap*, const char *, int, _cb__CbFilterCreate *const*, const char *); +SOAP_FMAC3 _cb__CbFilterCreate ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterCreate(struct soap*, _cb__CbFilterCreate **, const char*, const char*); +SOAP_FMAC3 _cb__CbFilterCreate ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterCreate(struct soap*, const char*, _cb__CbFilterCreate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatisticsResponse +#define SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatisticsResponse (939) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap*, _cb__CbPolicyGetActiveStatisticsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap*, _cb__CbPolicyGetActiveStatisticsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap*, const char *, int, _cb__CbPolicyGetActiveStatisticsResponse *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap*, _cb__CbPolicyGetActiveStatisticsResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap*, const char*, _cb__CbPolicyGetActiveStatisticsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatistics +#define SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatistics (938) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap*, _cb__CbPolicyGetActiveStatistics *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap*, _cb__CbPolicyGetActiveStatistics *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap*, const char *, int, _cb__CbPolicyGetActiveStatistics *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap*, _cb__CbPolicyGetActiveStatistics **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap*, const char*, _cb__CbPolicyGetActiveStatistics **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabledResponse +#define SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabledResponse (935) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap*, _cb__CbPolicyGetEnabledResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap*, _cb__CbPolicyGetEnabledResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap*, const char *, int, _cb__CbPolicyGetEnabledResponse *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap*, _cb__CbPolicyGetEnabledResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap*, const char*, _cb__CbPolicyGetEnabledResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabled +#define SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabled (934) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetEnabled(struct soap*, _cb__CbPolicyGetEnabled *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetEnabled(struct soap*, _cb__CbPolicyGetEnabled *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetEnabled(struct soap*, const char *, int, _cb__CbPolicyGetEnabled *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyGetEnabled ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetEnabled(struct soap*, _cb__CbPolicyGetEnabled **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetEnabled ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetEnabled(struct soap*, const char*, _cb__CbPolicyGetEnabled **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyDisableResponse +#define SOAP_TYPE_PointerTo_cb__CbPolicyDisableResponse (931) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyDisableResponse(struct soap*, _cb__CbPolicyDisableResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyDisableResponse(struct soap*, _cb__CbPolicyDisableResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyDisableResponse(struct soap*, const char *, int, _cb__CbPolicyDisableResponse *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyDisableResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyDisableResponse(struct soap*, _cb__CbPolicyDisableResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyDisableResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyDisableResponse(struct soap*, const char*, _cb__CbPolicyDisableResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyDisable +#define SOAP_TYPE_PointerTo_cb__CbPolicyDisable (930) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyDisable(struct soap*, _cb__CbPolicyDisable *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyDisable(struct soap*, _cb__CbPolicyDisable *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyDisable(struct soap*, const char *, int, _cb__CbPolicyDisable *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyDisable ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyDisable(struct soap*, _cb__CbPolicyDisable **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyDisable ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyDisable(struct soap*, const char*, _cb__CbPolicyDisable **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyEnableResponse +#define SOAP_TYPE_PointerTo_cb__CbPolicyEnableResponse (927) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyEnableResponse(struct soap*, _cb__CbPolicyEnableResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyEnableResponse(struct soap*, _cb__CbPolicyEnableResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyEnableResponse(struct soap*, const char *, int, _cb__CbPolicyEnableResponse *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyEnableResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyEnableResponse(struct soap*, _cb__CbPolicyEnableResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyEnableResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyEnableResponse(struct soap*, const char*, _cb__CbPolicyEnableResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyEnable +#define SOAP_TYPE_PointerTo_cb__CbPolicyEnable (926) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyEnable(struct soap*, _cb__CbPolicyEnable *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyEnable(struct soap*, _cb__CbPolicyEnable *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyEnable(struct soap*, const char *, int, _cb__CbPolicyEnable *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyEnable ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyEnable(struct soap*, _cb__CbPolicyEnable **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyEnable ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyEnable(struct soap*, const char*, _cb__CbPolicyEnable **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyEnumerateResponse +#define SOAP_TYPE_PointerTo_cb__CbPolicyEnumerateResponse (923) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyEnumerateResponse(struct soap*, _cb__CbPolicyEnumerateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyEnumerateResponse(struct soap*, _cb__CbPolicyEnumerateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyEnumerateResponse(struct soap*, const char *, int, _cb__CbPolicyEnumerateResponse *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyEnumerateResponse(struct soap*, _cb__CbPolicyEnumerateResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyEnumerateResponse(struct soap*, const char*, _cb__CbPolicyEnumerateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyEnumerate +#define SOAP_TYPE_PointerTo_cb__CbPolicyEnumerate (922) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyEnumerate(struct soap*, _cb__CbPolicyEnumerate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyEnumerate(struct soap*, _cb__CbPolicyEnumerate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyEnumerate(struct soap*, const char *, int, _cb__CbPolicyEnumerate *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyEnumerate ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyEnumerate(struct soap*, _cb__CbPolicyEnumerate **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyEnumerate ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyEnumerate(struct soap*, const char*, _cb__CbPolicyEnumerate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyDeleteResponse +#define SOAP_TYPE_PointerTo_cb__CbPolicyDeleteResponse (919) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyDeleteResponse(struct soap*, _cb__CbPolicyDeleteResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyDeleteResponse(struct soap*, _cb__CbPolicyDeleteResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyDeleteResponse(struct soap*, const char *, int, _cb__CbPolicyDeleteResponse *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyDeleteResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyDeleteResponse(struct soap*, _cb__CbPolicyDeleteResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyDeleteResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyDeleteResponse(struct soap*, const char*, _cb__CbPolicyDeleteResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyDelete +#define SOAP_TYPE_PointerTo_cb__CbPolicyDelete (918) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyDelete(struct soap*, _cb__CbPolicyDelete *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyDelete(struct soap*, _cb__CbPolicyDelete *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyDelete(struct soap*, const char *, int, _cb__CbPolicyDelete *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyDelete ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyDelete(struct soap*, _cb__CbPolicyDelete **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyDelete ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyDelete(struct soap*, const char*, _cb__CbPolicyDelete **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyGetResponse +#define SOAP_TYPE_PointerTo_cb__CbPolicyGetResponse (915) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetResponse(struct soap*, _cb__CbPolicyGetResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetResponse(struct soap*, _cb__CbPolicyGetResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetResponse(struct soap*, const char *, int, _cb__CbPolicyGetResponse *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyGetResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetResponse(struct soap*, _cb__CbPolicyGetResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGetResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetResponse(struct soap*, const char*, _cb__CbPolicyGetResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyGet +#define SOAP_TYPE_PointerTo_cb__CbPolicyGet (914) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGet(struct soap*, _cb__CbPolicyGet *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGet(struct soap*, _cb__CbPolicyGet *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGet(struct soap*, const char *, int, _cb__CbPolicyGet *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyGet ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGet(struct soap*, _cb__CbPolicyGet **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyGet ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGet(struct soap*, const char*, _cb__CbPolicyGet **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyCreateResponse +#define SOAP_TYPE_PointerTo_cb__CbPolicyCreateResponse (911) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyCreateResponse(struct soap*, _cb__CbPolicyCreateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyCreateResponse(struct soap*, _cb__CbPolicyCreateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyCreateResponse(struct soap*, const char *, int, _cb__CbPolicyCreateResponse *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyCreateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyCreateResponse(struct soap*, _cb__CbPolicyCreateResponse **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyCreateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyCreateResponse(struct soap*, const char*, _cb__CbPolicyCreateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_cb__CbPolicyCreate +#define SOAP_TYPE_PointerTo_cb__CbPolicyCreate (910) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyCreate(struct soap*, _cb__CbPolicyCreate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyCreate(struct soap*, _cb__CbPolicyCreate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyCreate(struct soap*, const char *, int, _cb__CbPolicyCreate *const*, const char *); +SOAP_FMAC3 _cb__CbPolicyCreate ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyCreate(struct soap*, _cb__CbPolicyCreate **, const char*, const char*); +SOAP_FMAC3 _cb__CbPolicyCreate ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyCreate(struct soap*, const char*, _cb__CbPolicyCreate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse (907) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, _apr__ConsoleWatchdogQueryCapabilitiesResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, _apr__ConsoleWatchdogQueryCapabilitiesResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, const char *, int, _apr__ConsoleWatchdogQueryCapabilitiesResponse *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, _apr__ConsoleWatchdogQueryCapabilitiesResponse **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap*, const char*, _apr__ConsoleWatchdogQueryCapabilitiesResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilities +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilities (906) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap*, _apr__ConsoleWatchdogQueryCapabilities *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap*, _apr__ConsoleWatchdogQueryCapabilities *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap*, const char *, int, _apr__ConsoleWatchdogQueryCapabilities *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap*, _apr__ConsoleWatchdogQueryCapabilities **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap*, const char*, _apr__ConsoleWatchdogQueryCapabilities **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse (903) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogGetCbPolicyResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogGetCbPolicyResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, const char *, int, _apr__ConsoleWatchdogGetCbPolicyResponse *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogGetCbPolicyResponse **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap*, const char*, _apr__ConsoleWatchdogGetCbPolicyResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicy +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicy (902) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap*, _apr__ConsoleWatchdogGetCbPolicy *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap*, _apr__ConsoleWatchdogGetCbPolicy *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap*, const char *, int, _apr__ConsoleWatchdogGetCbPolicy *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap*, _apr__ConsoleWatchdogGetCbPolicy **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap*, const char*, _apr__ConsoleWatchdogGetCbPolicy **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse (899) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogSetCbPolicyResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogSetCbPolicyResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, const char *, int, _apr__ConsoleWatchdogSetCbPolicyResponse *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, _apr__ConsoleWatchdogSetCbPolicyResponse **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap*, const char*, _apr__ConsoleWatchdogSetCbPolicyResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicy +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicy (898) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap*, _apr__ConsoleWatchdogSetCbPolicy *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap*, _apr__ConsoleWatchdogSetCbPolicy *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap*, const char *, int, _apr__ConsoleWatchdogSetCbPolicy *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap*, _apr__ConsoleWatchdogSetCbPolicy **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap*, const char*, _apr__ConsoleWatchdogSetCbPolicy **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActionsResponse +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActionsResponse (895) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap*, _apr__ConsoleWatchdogGetActionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap*, _apr__ConsoleWatchdogGetActionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap*, const char *, int, _apr__ConsoleWatchdogGetActionsResponse *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap*, _apr__ConsoleWatchdogGetActionsResponse **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap*, const char*, _apr__ConsoleWatchdogGetActionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActions +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActions (894) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogGetActions(struct soap*, _apr__ConsoleWatchdogGetActions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogGetActions(struct soap*, _apr__ConsoleWatchdogGetActions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogGetActions(struct soap*, const char *, int, _apr__ConsoleWatchdogGetActions *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogGetActions(struct soap*, _apr__ConsoleWatchdogGetActions **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogGetActions(struct soap*, const char*, _apr__ConsoleWatchdogGetActions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActionsResponse +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActionsResponse (891) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap*, _apr__ConsoleWatchdogSetActionsResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap*, _apr__ConsoleWatchdogSetActionsResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap*, const char *, int, _apr__ConsoleWatchdogSetActionsResponse *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap*, _apr__ConsoleWatchdogSetActionsResponse **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap*, const char*, _apr__ConsoleWatchdogSetActionsResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActions +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActions (890) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogSetActions(struct soap*, _apr__ConsoleWatchdogSetActions *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogSetActions(struct soap*, _apr__ConsoleWatchdogSetActions *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogSetActions(struct soap*, const char *, int, _apr__ConsoleWatchdogSetActions *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogSetActions(struct soap*, _apr__ConsoleWatchdogSetActions **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogSetActions(struct soap*, const char*, _apr__ConsoleWatchdogSetActions **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerateResponse +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerateResponse (887) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap*, _apr__ConsoleWatchdogEnumerateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap*, _apr__ConsoleWatchdogEnumerateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap*, const char *, int, _apr__ConsoleWatchdogEnumerateResponse *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap*, _apr__ConsoleWatchdogEnumerateResponse **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap*, const char*, _apr__ConsoleWatchdogEnumerateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerate +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerate (886) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap*, _apr__ConsoleWatchdogEnumerate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap*, _apr__ConsoleWatchdogEnumerate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap*, const char *, int, _apr__ConsoleWatchdogEnumerate *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap*, _apr__ConsoleWatchdogEnumerate **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap*, const char*, _apr__ConsoleWatchdogEnumerate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDeleteResponse +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDeleteResponse (883) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap*, _apr__ConsoleWatchdogDeleteResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap*, _apr__ConsoleWatchdogDeleteResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap*, const char *, int, _apr__ConsoleWatchdogDeleteResponse *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap*, _apr__ConsoleWatchdogDeleteResponse **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap*, const char*, _apr__ConsoleWatchdogDeleteResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDelete +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDelete (882) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogDelete(struct soap*, _apr__ConsoleWatchdogDelete *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogDelete(struct soap*, _apr__ConsoleWatchdogDelete *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogDelete(struct soap*, const char *, int, _apr__ConsoleWatchdogDelete *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogDelete ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogDelete(struct soap*, _apr__ConsoleWatchdogDelete **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogDelete ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogDelete(struct soap*, const char*, _apr__ConsoleWatchdogDelete **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreateResponse +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreateResponse (879) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap*, _apr__ConsoleWatchdogCreateResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap*, _apr__ConsoleWatchdogCreateResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap*, const char *, int, _apr__ConsoleWatchdogCreateResponse *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap*, _apr__ConsoleWatchdogCreateResponse **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap*, const char*, _apr__ConsoleWatchdogCreateResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreate +#define SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreate (878) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogCreate(struct soap*, _apr__ConsoleWatchdogCreate *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogCreate(struct soap*, _apr__ConsoleWatchdogCreate *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogCreate(struct soap*, const char *, int, _apr__ConsoleWatchdogCreate *const*, const char *); +SOAP_FMAC3 _apr__ConsoleWatchdogCreate ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogCreate(struct soap*, _apr__ConsoleWatchdogCreate **, const char*, const char*); +SOAP_FMAC3 _apr__ConsoleWatchdogCreate ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogCreate(struct soap*, const char*, _apr__ConsoleWatchdogCreate **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apl__AgentWatchdogRegisterResponse +#define SOAP_TYPE_PointerTo_apl__AgentWatchdogRegisterResponse (875) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap*, _apl__AgentWatchdogRegisterResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap*, _apl__AgentWatchdogRegisterResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap*, const char *, int, _apl__AgentWatchdogRegisterResponse *const*, const char *); +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap*, _apl__AgentWatchdogRegisterResponse **, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap*, const char*, _apl__AgentWatchdogRegisterResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apl__AgentWatchdogRegister +#define SOAP_TYPE_PointerTo_apl__AgentWatchdogRegister (874) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogRegister(struct soap*, _apl__AgentWatchdogRegister *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogRegister(struct soap*, _apl__AgentWatchdogRegister *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogRegister(struct soap*, const char *, int, _apl__AgentWatchdogRegister *const*, const char *); +SOAP_FMAC3 _apl__AgentWatchdogRegister ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogRegister(struct soap*, _apl__AgentWatchdogRegister **, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogRegister ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogRegister(struct soap*, const char*, _apl__AgentWatchdogRegister **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeatResponse +#define SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeatResponse (871) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap*, _apl__AgentWatchdogHeartbeatResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap*, _apl__AgentWatchdogHeartbeatResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap*, const char *, int, _apl__AgentWatchdogHeartbeatResponse *const*, const char *); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap*, _apl__AgentWatchdogHeartbeatResponse **, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap*, const char*, _apl__AgentWatchdogHeartbeatResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeat +#define SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeat (870) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogHeartbeat(struct soap*, _apl__AgentWatchdogHeartbeat *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogHeartbeat(struct soap*, _apl__AgentWatchdogHeartbeat *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogHeartbeat(struct soap*, const char *, int, _apl__AgentWatchdogHeartbeat *const*, const char *); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogHeartbeat(struct soap*, _apl__AgentWatchdogHeartbeat **, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogHeartbeat(struct soap*, const char*, _apl__AgentWatchdogHeartbeat **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdownResponse +#define SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdownResponse (867) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap*, _apl__AgentWatchdogShutdownResponse *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap*, _apl__AgentWatchdogShutdownResponse *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap*, const char *, int, _apl__AgentWatchdogShutdownResponse *const*, const char *); +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap*, _apl__AgentWatchdogShutdownResponse **, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap*, const char*, _apl__AgentWatchdogShutdownResponse **, const char*); + +#ifndef SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdown +#define SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdown (866) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogShutdown(struct soap*, _apl__AgentWatchdogShutdown *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogShutdown(struct soap*, _apl__AgentWatchdogShutdown *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogShutdown(struct soap*, const char *, int, _apl__AgentWatchdogShutdown *const*, const char *); +SOAP_FMAC3 _apl__AgentWatchdogShutdown ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogShutdown(struct soap*, _apl__AgentWatchdogShutdown **, const char*, const char*); +SOAP_FMAC3 _apl__AgentWatchdogShutdown ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogShutdown(struct soap*, const char*, _apl__AgentWatchdogShutdown **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType +#define SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType (865) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, cb__CircuitBreakerIPLayeredTCPFlagsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, cb__CircuitBreakerIPLayeredTCPFlagsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, const char *, int, cb__CircuitBreakerIPLayeredTCPFlagsType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, cb__CircuitBreakerIPLayeredTCPFlagsType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap*, const char*, cb__CircuitBreakerIPLayeredTCPFlagsType **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__WirelessSettingsType +#define SOAP_TYPE_PointerTowcxs__WirelessSettingsType (864) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__WirelessSettingsType(struct soap*, wcxs__WirelessSettingsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__WirelessSettingsType(struct soap*, wcxs__WirelessSettingsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__WirelessSettingsType(struct soap*, const char *, int, wcxs__WirelessSettingsType *const*, const char *); +SOAP_FMAC3 wcxs__WirelessSettingsType ** SOAP_FMAC4 soap_get_PointerTowcxs__WirelessSettingsType(struct soap*, wcxs__WirelessSettingsType **, const char*, const char*); +SOAP_FMAC3 wcxs__WirelessSettingsType ** SOAP_FMAC4 soap_in_PointerTowcxs__WirelessSettingsType(struct soap*, const char*, wcxs__WirelessSettingsType **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__WirelessCapabilitiesType +#define SOAP_TYPE_PointerTowcxs__WirelessCapabilitiesType (863) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__WirelessCapabilitiesType(struct soap*, wcxs__WirelessCapabilitiesType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__WirelessCapabilitiesType(struct soap*, wcxs__WirelessCapabilitiesType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__WirelessCapabilitiesType(struct soap*, const char *, int, wcxs__WirelessCapabilitiesType *const*, const char *); +SOAP_FMAC3 wcxs__WirelessCapabilitiesType ** SOAP_FMAC4 soap_get_PointerTowcxs__WirelessCapabilitiesType(struct soap*, wcxs__WirelessCapabilitiesType **, const char*, const char*); +SOAP_FMAC3 wcxs__WirelessCapabilitiesType ** SOAP_FMAC4 soap_in_PointerTowcxs__WirelessCapabilitiesType(struct soap*, const char*, wcxs__WirelessCapabilitiesType **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__ProfileType +#define SOAP_TYPE_PointerTowcxs__ProfileType (861) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__ProfileType(struct soap*, wcxs__ProfileType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__ProfileType(struct soap*, wcxs__ProfileType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__ProfileType(struct soap*, const char *, int, wcxs__ProfileType *const*, const char *); +SOAP_FMAC3 wcxs__ProfileType ** SOAP_FMAC4 soap_get_PointerTowcxs__ProfileType(struct soap*, wcxs__ProfileType **, const char*, const char*); +SOAP_FMAC3 wcxs__ProfileType ** SOAP_FMAC4 soap_in_PointerTowcxs__ProfileType(struct soap*, const char*, wcxs__ProfileType **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingsType +#define SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingsType (859) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__ProfileSecuritySettingsType(struct soap*, wcxs__ProfileSecuritySettingsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__ProfileSecuritySettingsType(struct soap*, wcxs__ProfileSecuritySettingsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__ProfileSecuritySettingsType(struct soap*, const char *, int, wcxs__ProfileSecuritySettingsType *const*, const char *); +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType ** SOAP_FMAC4 soap_get_PointerTowcxs__ProfileSecuritySettingsType(struct soap*, wcxs__ProfileSecuritySettingsType **, const char*, const char*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType ** SOAP_FMAC4 soap_in_PointerTowcxs__ProfileSecuritySettingsType(struct soap*, const char*, wcxs__ProfileSecuritySettingsType **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingRSNType +#define SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingRSNType (857) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap*, wcxs__ProfileSecuritySettingRSNType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap*, wcxs__ProfileSecuritySettingRSNType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap*, const char *, int, wcxs__ProfileSecuritySettingRSNType *const*, const char *); +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType ** SOAP_FMAC4 soap_get_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap*, wcxs__ProfileSecuritySettingRSNType **, const char*, const char*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType ** SOAP_FMAC4 soap_in_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap*, const char*, wcxs__ProfileSecuritySettingRSNType **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingWPAType +#define SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingWPAType (856) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap*, wcxs__ProfileSecuritySettingWPAType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap*, wcxs__ProfileSecuritySettingWPAType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap*, const char *, int, wcxs__ProfileSecuritySettingWPAType *const*, const char *); +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType ** SOAP_FMAC4 soap_get_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap*, wcxs__ProfileSecuritySettingWPAType **, const char*, const char*); +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType ** SOAP_FMAC4 soap_in_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap*, const char*, wcxs__ProfileSecuritySettingWPAType **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__DataEncryptionCCMPType +#define SOAP_TYPE_PointerTowcxs__DataEncryptionCCMPType (853) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__DataEncryptionCCMPType(struct soap*, wcxs__DataEncryptionCCMPType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__DataEncryptionCCMPType(struct soap*, wcxs__DataEncryptionCCMPType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__DataEncryptionCCMPType(struct soap*, const char *, int, wcxs__DataEncryptionCCMPType *const*, const char *); +SOAP_FMAC3 wcxs__DataEncryptionCCMPType ** SOAP_FMAC4 soap_get_PointerTowcxs__DataEncryptionCCMPType(struct soap*, wcxs__DataEncryptionCCMPType **, const char*, const char*); +SOAP_FMAC3 wcxs__DataEncryptionCCMPType ** SOAP_FMAC4 soap_in_PointerTowcxs__DataEncryptionCCMPType(struct soap*, const char*, wcxs__DataEncryptionCCMPType **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__DataEncryptionTKIPType +#define SOAP_TYPE_PointerTowcxs__DataEncryptionTKIPType (852) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__DataEncryptionTKIPType(struct soap*, wcxs__DataEncryptionTKIPType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__DataEncryptionTKIPType(struct soap*, wcxs__DataEncryptionTKIPType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__DataEncryptionTKIPType(struct soap*, const char *, int, wcxs__DataEncryptionTKIPType *const*, const char *); +SOAP_FMAC3 wcxs__DataEncryptionTKIPType ** SOAP_FMAC4 soap_get_PointerTowcxs__DataEncryptionTKIPType(struct soap*, wcxs__DataEncryptionTKIPType **, const char*, const char*); +SOAP_FMAC3 wcxs__DataEncryptionTKIPType ** SOAP_FMAC4 soap_in_PointerTowcxs__DataEncryptionTKIPType(struct soap*, const char*, wcxs__DataEncryptionTKIPType **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__RawKey256Type +#define SOAP_TYPE_PointerTowcxs__RawKey256Type (849) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__RawKey256Type(struct soap*, xsd__base64Binary *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__RawKey256Type(struct soap*, xsd__base64Binary *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__RawKey256Type(struct soap*, const char *, int, xsd__base64Binary *const*, const char *); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerTowcxs__RawKey256Type(struct soap*, xsd__base64Binary **, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerTowcxs__RawKey256Type(struct soap*, const char*, xsd__base64Binary **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__PassPhrase63Type +#define SOAP_TYPE_PointerTowcxs__PassPhrase63Type (847) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__PassPhrase63Type(struct soap*, std::string *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__PassPhrase63Type(struct soap*, std::string *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__PassPhrase63Type(struct soap*, const char *, int, std::string *const*, const char *); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTowcxs__PassPhrase63Type(struct soap*, std::string **, const char*, const char*); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTowcxs__PassPhrase63Type(struct soap*, const char*, std::string **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__WEP128Type +#define SOAP_TYPE_PointerTowcxs__WEP128Type (845) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__WEP128Type(struct soap*, wcxs__WEP128Type *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__WEP128Type(struct soap*, wcxs__WEP128Type *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__WEP128Type(struct soap*, const char *, int, wcxs__WEP128Type *const*, const char *); +SOAP_FMAC3 wcxs__WEP128Type ** SOAP_FMAC4 soap_get_PointerTowcxs__WEP128Type(struct soap*, wcxs__WEP128Type **, const char*, const char*); +SOAP_FMAC3 wcxs__WEP128Type ** SOAP_FMAC4 soap_in_PointerTowcxs__WEP128Type(struct soap*, const char*, wcxs__WEP128Type **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__WEP64Type +#define SOAP_TYPE_PointerTowcxs__WEP64Type (844) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__WEP64Type(struct soap*, wcxs__WEP64Type *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__WEP64Type(struct soap*, wcxs__WEP64Type *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__WEP64Type(struct soap*, const char *, int, wcxs__WEP64Type *const*, const char *); +SOAP_FMAC3 wcxs__WEP64Type ** SOAP_FMAC4 soap_get_PointerTowcxs__WEP64Type(struct soap*, wcxs__WEP64Type **, const char*, const char*); +SOAP_FMAC3 wcxs__WEP64Type ** SOAP_FMAC4 soap_in_PointerTowcxs__WEP64Type(struct soap*, const char*, wcxs__WEP64Type **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__RawKey128Type +#define SOAP_TYPE_PointerTowcxs__RawKey128Type (842) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__RawKey128Type(struct soap*, xsd__base64Binary *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__RawKey128Type(struct soap*, xsd__base64Binary *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__RawKey128Type(struct soap*, const char *, int, xsd__base64Binary *const*, const char *); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerTowcxs__RawKey128Type(struct soap*, xsd__base64Binary **, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerTowcxs__RawKey128Type(struct soap*, const char*, xsd__base64Binary **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__PassPhraseWEP128Type +#define SOAP_TYPE_PointerTowcxs__PassPhraseWEP128Type (841) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__PassPhraseWEP128Type(struct soap*, std::string *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__PassPhraseWEP128Type(struct soap*, std::string *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__PassPhraseWEP128Type(struct soap*, const char *, int, std::string *const*, const char *); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTowcxs__PassPhraseWEP128Type(struct soap*, std::string **, const char*, const char*); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTowcxs__PassPhraseWEP128Type(struct soap*, const char*, std::string **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__RawKey64Type +#define SOAP_TYPE_PointerTowcxs__RawKey64Type (839) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__RawKey64Type(struct soap*, xsd__base64Binary *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__RawKey64Type(struct soap*, xsd__base64Binary *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__RawKey64Type(struct soap*, const char *, int, xsd__base64Binary *const*, const char *); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerTowcxs__RawKey64Type(struct soap*, xsd__base64Binary **, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerTowcxs__RawKey64Type(struct soap*, const char*, xsd__base64Binary **, const char*); + +#ifndef SOAP_TYPE_PointerTowcxs__PassPhrase5Type +#define SOAP_TYPE_PointerTowcxs__PassPhrase5Type (838) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__PassPhrase5Type(struct soap*, std::string *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__PassPhrase5Type(struct soap*, std::string *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__PassPhrase5Type(struct soap*, const char *, int, std::string *const*, const char *); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTowcxs__PassPhrase5Type(struct soap*, std::string **, const char*, const char*); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTowcxs__PassPhrase5Type(struct soap*, const char*, std::string **, const char*); + +#ifndef SOAP_TYPE_PointerTorci__OemParametersType +#define SOAP_TYPE_PointerTorci__OemParametersType (837) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTorci__OemParametersType(struct soap*, unsigned short *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTorci__OemParametersType(struct soap*, unsigned short *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTorci__OemParametersType(struct soap*, const char *, int, unsigned short *const*, const char *); +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_get_PointerTorci__OemParametersType(struct soap*, unsigned short **, const char*, const char*); +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_in_PointerTorci__OemParametersType(struct soap*, const char*, unsigned short **, const char*); + +#ifndef SOAP_TYPE_PointerTorci__BootOptionsType +#define SOAP_TYPE_PointerTorci__BootOptionsType (836) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTorci__BootOptionsType(struct soap*, unsigned short *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTorci__BootOptionsType(struct soap*, unsigned short *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTorci__BootOptionsType(struct soap*, const char *, int, unsigned short *const*, const char *); +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_get_PointerTorci__BootOptionsType(struct soap*, unsigned short **, const char*, const char*); +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_in_PointerTorci__BootOptionsType(struct soap*, const char*, unsigned short **, const char*); + +#ifndef SOAP_TYPE_PointerTorci__SpecialCommandParameterType +#define SOAP_TYPE_PointerTorci__SpecialCommandParameterType (835) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTorci__SpecialCommandParameterType(struct soap*, unsigned short *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTorci__SpecialCommandParameterType(struct soap*, unsigned short *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTorci__SpecialCommandParameterType(struct soap*, const char *, int, unsigned short *const*, const char *); +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_get_PointerTorci__SpecialCommandParameterType(struct soap*, unsigned short **, const char*, const char*); +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_in_PointerTorci__SpecialCommandParameterType(struct soap*, const char*, unsigned short **, const char*); + +#ifndef SOAP_TYPE_PointerTorci__SpecialCommandType +#define SOAP_TYPE_PointerTorci__SpecialCommandType (834) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTorci__SpecialCommandType(struct soap*, enum rci__SpecialCommandType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTorci__SpecialCommandType(struct soap*, enum rci__SpecialCommandType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTorci__SpecialCommandType(struct soap*, const char *, int, enum rci__SpecialCommandType *const*, const char *); +SOAP_FMAC3 enum rci__SpecialCommandType ** SOAP_FMAC4 soap_get_PointerTorci__SpecialCommandType(struct soap*, enum rci__SpecialCommandType **, const char*, const char*); +SOAP_FMAC3 enum rci__SpecialCommandType ** SOAP_FMAC4 soap_in_PointerTorci__SpecialCommandType(struct soap*, const char*, enum rci__SpecialCommandType **, const char*); + +#ifndef SOAP_TYPE_PointerToinf__IderSessionLogEntryType +#define SOAP_TYPE_PointerToinf__IderSessionLogEntryType (832) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToinf__IderSessionLogEntryType(struct soap*, inf__IderSessionLogEntryType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToinf__IderSessionLogEntryType(struct soap*, inf__IderSessionLogEntryType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToinf__IderSessionLogEntryType(struct soap*, const char *, int, inf__IderSessionLogEntryType *const*, const char *); +SOAP_FMAC3 inf__IderSessionLogEntryType ** SOAP_FMAC4 soap_get_PointerToinf__IderSessionLogEntryType(struct soap*, inf__IderSessionLogEntryType **, const char*, const char*); +SOAP_FMAC3 inf__IderSessionLogEntryType ** SOAP_FMAC4 soap_in_PointerToinf__IderSessionLogEntryType(struct soap*, const char*, inf__IderSessionLogEntryType **, const char*); + +#ifndef SOAP_TYPE_PointerToinf__FirmwareVersionType +#define SOAP_TYPE_PointerToinf__FirmwareVersionType (829) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToinf__FirmwareVersionType(struct soap*, inf__FirmwareVersionType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToinf__FirmwareVersionType(struct soap*, inf__FirmwareVersionType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToinf__FirmwareVersionType(struct soap*, const char *, int, inf__FirmwareVersionType *const*, const char *); +SOAP_FMAC3 inf__FirmwareVersionType ** SOAP_FMAC4 soap_get_PointerToinf__FirmwareVersionType(struct soap*, inf__FirmwareVersionType **, const char*, const char*); +SOAP_FMAC3 inf__FirmwareVersionType ** SOAP_FMAC4 soap_in_PointerToinf__FirmwareVersionType(struct soap*, const char*, inf__FirmwareVersionType **, const char*); + +#ifndef SOAP_TYPE_PointerToidr__IderSessionLogEntryType +#define SOAP_TYPE_PointerToidr__IderSessionLogEntryType (827) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToidr__IderSessionLogEntryType(struct soap*, idr__IderSessionLogEntryType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToidr__IderSessionLogEntryType(struct soap*, idr__IderSessionLogEntryType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToidr__IderSessionLogEntryType(struct soap*, const char *, int, idr__IderSessionLogEntryType *const*, const char *); +SOAP_FMAC3 idr__IderSessionLogEntryType ** SOAP_FMAC4 soap_get_PointerToidr__IderSessionLogEntryType(struct soap*, idr__IderSessionLogEntryType **, const char*, const char*); +SOAP_FMAC3 idr__IderSessionLogEntryType ** SOAP_FMAC4 soap_in_PointerToidr__IderSessionLogEntryType(struct soap*, const char*, idr__IderSessionLogEntryType **, const char*); + +#ifndef SOAP_TYPE_PointerToapl__GUID +#define SOAP_TYPE_PointerToapl__GUID (826) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapl__GUID(struct soap*, apl__GUID *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapl__GUID(struct soap*, apl__GUID *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapl__GUID(struct soap*, const char *, int, apl__GUID *const*, const char *); +SOAP_FMAC3 apl__GUID ** SOAP_FMAC4 soap_get_PointerToapl__GUID(struct soap*, apl__GUID **, const char*, const char*); +SOAP_FMAC3 apl__GUID ** SOAP_FMAC4 soap_in_PointerToapl__GUID(struct soap*, const char*, apl__GUID **, const char*); + +#ifndef SOAP_TYPE_PointerToapr__AgentPresenceCapabilitiesType +#define SOAP_TYPE_PointerToapr__AgentPresenceCapabilitiesType (825) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__AgentPresenceCapabilitiesType(struct soap*, apr__AgentPresenceCapabilitiesType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__AgentPresenceCapabilitiesType(struct soap*, apr__AgentPresenceCapabilitiesType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__AgentPresenceCapabilitiesType(struct soap*, const char *, int, apr__AgentPresenceCapabilitiesType *const*, const char *); +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType ** SOAP_FMAC4 soap_get_PointerToapr__AgentPresenceCapabilitiesType(struct soap*, apr__AgentPresenceCapabilitiesType **, const char*, const char*); +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType ** SOAP_FMAC4 soap_in_PointerToapr__AgentPresenceCapabilitiesType(struct soap*, const char*, apr__AgentPresenceCapabilitiesType **, const char*); + +#ifndef SOAP_TYPE_PointerToapr__CircuitBreakerHardwarePolicyType +#define SOAP_TYPE_PointerToapr__CircuitBreakerHardwarePolicyType (823) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, apr__CircuitBreakerHardwarePolicyType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, apr__CircuitBreakerHardwarePolicyType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, const char *, int, apr__CircuitBreakerHardwarePolicyType *const*, const char *); +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType ** SOAP_FMAC4 soap_get_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, apr__CircuitBreakerHardwarePolicyType **, const char*, const char*); +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType ** SOAP_FMAC4 soap_in_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, const char*, apr__CircuitBreakerHardwarePolicyType **, const char*); + +#ifndef SOAP_TYPE_PointerToapr__ConsoleWatchdogActionType +#define SOAP_TYPE_PointerToapr__ConsoleWatchdogActionType (821) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__ConsoleWatchdogActionType(struct soap*, apr__ConsoleWatchdogActionType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__ConsoleWatchdogActionType(struct soap*, apr__ConsoleWatchdogActionType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__ConsoleWatchdogActionType(struct soap*, const char *, int, apr__ConsoleWatchdogActionType *const*, const char *); +SOAP_FMAC3 apr__ConsoleWatchdogActionType ** SOAP_FMAC4 soap_get_PointerToapr__ConsoleWatchdogActionType(struct soap*, apr__ConsoleWatchdogActionType **, const char*, const char*); +SOAP_FMAC3 apr__ConsoleWatchdogActionType ** SOAP_FMAC4 soap_in_PointerToapr__ConsoleWatchdogActionType(struct soap*, const char*, apr__ConsoleWatchdogActionType **, const char*); + +#ifndef SOAP_TYPE_PointerToapr__ConsoleWatchdogEntryType +#define SOAP_TYPE_PointerToapr__ConsoleWatchdogEntryType (819) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__ConsoleWatchdogEntryType(struct soap*, apr__ConsoleWatchdogEntryType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__ConsoleWatchdogEntryType(struct soap*, apr__ConsoleWatchdogEntryType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__ConsoleWatchdogEntryType(struct soap*, const char *, int, apr__ConsoleWatchdogEntryType *const*, const char *); +SOAP_FMAC3 apr__ConsoleWatchdogEntryType ** SOAP_FMAC4 soap_get_PointerToapr__ConsoleWatchdogEntryType(struct soap*, apr__ConsoleWatchdogEntryType **, const char*, const char*); +SOAP_FMAC3 apr__ConsoleWatchdogEntryType ** SOAP_FMAC4 soap_in_PointerToapr__ConsoleWatchdogEntryType(struct soap*, const char*, apr__ConsoleWatchdogEntryType **, const char*); + +#ifndef SOAP_TYPE_PointerToapr__CbActionType +#define SOAP_TYPE_PointerToapr__CbActionType (818) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__CbActionType(struct soap*, enum apr__CbActionType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__CbActionType(struct soap*, enum apr__CbActionType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__CbActionType(struct soap*, const char *, int, enum apr__CbActionType *const*, const char *); +SOAP_FMAC3 enum apr__CbActionType ** SOAP_FMAC4 soap_get_PointerToapr__CbActionType(struct soap*, enum apr__CbActionType **, const char*, const char*); +SOAP_FMAC3 enum apr__CbActionType ** SOAP_FMAC4 soap_in_PointerToapr__CbActionType(struct soap*, const char*, enum apr__CbActionType **, const char*); + +#ifndef SOAP_TYPE_PointerToapr__GUID +#define SOAP_TYPE_PointerToapr__GUID (817) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__GUID(struct soap*, apr__GUID *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__GUID(struct soap*, apr__GUID *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__GUID(struct soap*, const char *, int, apr__GUID *const*, const char *); +SOAP_FMAC3 apr__GUID ** SOAP_FMAC4 soap_get_PointerToapr__GUID(struct soap*, apr__GUID **, const char*, const char*); +SOAP_FMAC3 apr__GUID ** SOAP_FMAC4 soap_in_PointerToapr__GUID(struct soap*, const char*, apr__GUID **, const char*); + +#ifndef SOAP_TYPE_PointerTohwa__AssetDataArrayType +#define SOAP_TYPE_PointerTohwa__AssetDataArrayType (816) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTohwa__AssetDataArrayType(struct soap*, hwa__AssetDataArrayType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTohwa__AssetDataArrayType(struct soap*, hwa__AssetDataArrayType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTohwa__AssetDataArrayType(struct soap*, const char *, int, hwa__AssetDataArrayType *const*, const char *); +SOAP_FMAC3 hwa__AssetDataArrayType ** SOAP_FMAC4 soap_get_PointerTohwa__AssetDataArrayType(struct soap*, hwa__AssetDataArrayType **, const char*, const char*); +SOAP_FMAC3 hwa__AssetDataArrayType ** SOAP_FMAC4 soap_in_PointerTohwa__AssetDataArrayType(struct soap*, const char*, hwa__AssetDataArrayType **, const char*); + +#ifndef SOAP_TYPE_PointerTohwa__AssetTypeArrayType +#define SOAP_TYPE_PointerTohwa__AssetTypeArrayType (815) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTohwa__AssetTypeArrayType(struct soap*, hwa__AssetTypeArrayType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTohwa__AssetTypeArrayType(struct soap*, hwa__AssetTypeArrayType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTohwa__AssetTypeArrayType(struct soap*, const char *, int, hwa__AssetTypeArrayType *const*, const char *); +SOAP_FMAC3 hwa__AssetTypeArrayType ** SOAP_FMAC4 soap_get_PointerTohwa__AssetTypeArrayType(struct soap*, hwa__AssetTypeArrayType **, const char*, const char*); +SOAP_FMAC3 hwa__AssetTypeArrayType ** SOAP_FMAC4 soap_in_PointerTohwa__AssetTypeArrayType(struct soap*, const char*, hwa__AssetTypeArrayType **, const char*); + +#ifndef SOAP_TYPE_PointerTohwa__GUID +#define SOAP_TYPE_PointerTohwa__GUID (813) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTohwa__GUID(struct soap*, hwa__GUID *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTohwa__GUID(struct soap*, hwa__GUID *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTohwa__GUID(struct soap*, const char *, int, hwa__GUID *const*, const char *); +SOAP_FMAC3 hwa__GUID ** SOAP_FMAC4 soap_get_PointerTohwa__GUID(struct soap*, hwa__GUID **, const char*, const char*); +SOAP_FMAC3 hwa__GUID ** SOAP_FMAC4 soap_in_PointerTohwa__GUID(struct soap*, const char*, hwa__GUID **, const char*); + +#ifndef SOAP_TYPE_PointerToxsd__base64Binary +#define SOAP_TYPE_PointerToxsd__base64Binary (812) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxsd__base64Binary(struct soap*, xsd__base64Binary *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxsd__base64Binary(struct soap*, xsd__base64Binary *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxsd__base64Binary(struct soap*, const char *, int, xsd__base64Binary *const*, const char *); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerToxsd__base64Binary(struct soap*, xsd__base64Binary **, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerToxsd__base64Binary(struct soap*, const char*, xsd__base64Binary **, const char*); + +#ifndef SOAP_TYPE_PointerTohwa__AssetDataType +#define SOAP_TYPE_PointerTohwa__AssetDataType (810) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTohwa__AssetDataType(struct soap*, hwa__AssetDataType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTohwa__AssetDataType(struct soap*, hwa__AssetDataType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTohwa__AssetDataType(struct soap*, const char *, int, hwa__AssetDataType *const*, const char *); +SOAP_FMAC3 hwa__AssetDataType ** SOAP_FMAC4 soap_get_PointerTohwa__AssetDataType(struct soap*, hwa__AssetDataType **, const char*, const char*); +SOAP_FMAC3 hwa__AssetDataType ** SOAP_FMAC4 soap_in_PointerTohwa__AssetDataType(struct soap*, const char*, hwa__AssetDataType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__BlockedPortInfoType +#define SOAP_TYPE_PointerTocb__BlockedPortInfoType (808) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__BlockedPortInfoType(struct soap*, cb__BlockedPortInfoType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__BlockedPortInfoType(struct soap*, cb__BlockedPortInfoType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__BlockedPortInfoType(struct soap*, const char *, int, cb__BlockedPortInfoType *const*, const char *); +SOAP_FMAC3 cb__BlockedPortInfoType ** SOAP_FMAC4 soap_get_PointerTocb__BlockedPortInfoType(struct soap*, cb__BlockedPortInfoType **, const char*, const char*); +SOAP_FMAC3 cb__BlockedPortInfoType ** SOAP_FMAC4 soap_in_PointerTocb__BlockedPortInfoType(struct soap*, const char*, cb__BlockedPortInfoType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__HcbTriggerReasonType +#define SOAP_TYPE_PointerTocb__HcbTriggerReasonType (807) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__HcbTriggerReasonType(struct soap*, enum cb__HcbTriggerReasonType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__HcbTriggerReasonType(struct soap*, enum cb__HcbTriggerReasonType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__HcbTriggerReasonType(struct soap*, const char *, int, enum cb__HcbTriggerReasonType *const*, const char *); +SOAP_FMAC3 enum cb__HcbTriggerReasonType ** SOAP_FMAC4 soap_get_PointerTocb__HcbTriggerReasonType(struct soap*, enum cb__HcbTriggerReasonType **, const char*, const char*); +SOAP_FMAC3 enum cb__HcbTriggerReasonType ** SOAP_FMAC4 soap_in_PointerTocb__HcbTriggerReasonType(struct soap*, const char*, enum cb__HcbTriggerReasonType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__TimeType +#define SOAP_TYPE_PointerTocb__TimeType (806) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__TimeType(struct soap*, unsigned int *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__TimeType(struct soap*, unsigned int *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__TimeType(struct soap*, const char *, int, unsigned int *const*, const char *); +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_get_PointerTocb__TimeType(struct soap*, unsigned int **, const char*, const char*); +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTocb__TimeType(struct soap*, const char*, unsigned int **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__HcbOptionsType +#define SOAP_TYPE_PointerTocb__HcbOptionsType (805) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__HcbOptionsType(struct soap*, cb__HcbOptionsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__HcbOptionsType(struct soap*, cb__HcbOptionsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__HcbOptionsType(struct soap*, const char *, int, cb__HcbOptionsType *const*, const char *); +SOAP_FMAC3 cb__HcbOptionsType ** SOAP_FMAC4 soap_get_PointerTocb__HcbOptionsType(struct soap*, cb__HcbOptionsType **, const char*, const char*); +SOAP_FMAC3 cb__HcbOptionsType ** SOAP_FMAC4 soap_in_PointerTocb__HcbOptionsType(struct soap*, const char*, cb__HcbOptionsType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerCapabilitiesType +#define SOAP_TYPE_PointerTocb__CircuitBreakerCapabilitiesType (803) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerCapabilitiesType(struct soap*, cb__CircuitBreakerCapabilitiesType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerCapabilitiesType(struct soap*, cb__CircuitBreakerCapabilitiesType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerCapabilitiesType(struct soap*, const char *, int, cb__CircuitBreakerCapabilitiesType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerCapabilitiesType(struct soap*, cb__CircuitBreakerCapabilitiesType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerCapabilitiesType(struct soap*, const char*, cb__CircuitBreakerCapabilitiesType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerFilterInfoType +#define SOAP_TYPE_PointerTocb__CircuitBreakerFilterInfoType (801) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerFilterInfoType(struct soap*, cb__CircuitBreakerFilterInfoType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerFilterInfoType(struct soap*, cb__CircuitBreakerFilterInfoType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerFilterInfoType(struct soap*, const char *, int, cb__CircuitBreakerFilterInfoType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerFilterInfoType(struct soap*, cb__CircuitBreakerFilterInfoType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerFilterInfoType(struct soap*, const char*, cb__CircuitBreakerFilterInfoType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerFilterStatisticsType +#define SOAP_TYPE_PointerTocb__CircuitBreakerFilterStatisticsType (799) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, cb__CircuitBreakerFilterStatisticsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, cb__CircuitBreakerFilterStatisticsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, const char *, int, cb__CircuitBreakerFilterStatisticsType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, cb__CircuitBreakerFilterStatisticsType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, const char*, cb__CircuitBreakerFilterStatisticsType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerApplicationType +#define SOAP_TYPE_PointerTocb__CircuitBreakerApplicationType (798) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerApplicationType(struct soap*, enum cb__CircuitBreakerApplicationType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerApplicationType(struct soap*, enum cb__CircuitBreakerApplicationType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerApplicationType(struct soap*, const char *, int, enum cb__CircuitBreakerApplicationType *const*, const char *); +SOAP_FMAC3 enum cb__CircuitBreakerApplicationType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerApplicationType(struct soap*, enum cb__CircuitBreakerApplicationType **, const char*, const char*); +SOAP_FMAC3 enum cb__CircuitBreakerApplicationType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerApplicationType(struct soap*, const char*, enum cb__CircuitBreakerApplicationType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerHardwarePolicyType +#define SOAP_TYPE_PointerTocb__CircuitBreakerHardwarePolicyType (796) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, cb__CircuitBreakerHardwarePolicyType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, cb__CircuitBreakerHardwarePolicyType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, const char *, int, cb__CircuitBreakerHardwarePolicyType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, cb__CircuitBreakerHardwarePolicyType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, const char*, cb__CircuitBreakerHardwarePolicyType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerPolicyInfoType +#define SOAP_TYPE_PointerTocb__CircuitBreakerPolicyInfoType (794) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPolicyInfoType(struct soap*, cb__CircuitBreakerPolicyInfoType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPolicyInfoType(struct soap*, cb__CircuitBreakerPolicyInfoType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPolicyInfoType(struct soap*, const char *, int, cb__CircuitBreakerPolicyInfoType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPolicyInfoType(struct soap*, cb__CircuitBreakerPolicyInfoType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPolicyInfoType(struct soap*, const char*, cb__CircuitBreakerPolicyInfoType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__TimedCounterType +#define SOAP_TYPE_PointerTocb__TimedCounterType (793) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__TimedCounterType(struct soap*, cb__TimedCounterType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__TimedCounterType(struct soap*, cb__TimedCounterType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__TimedCounterType(struct soap*, const char *, int, cb__TimedCounterType *const*, const char *); +SOAP_FMAC3 cb__TimedCounterType ** SOAP_FMAC4 soap_get_PointerTocb__TimedCounterType(struct soap*, cb__TimedCounterType **, const char*, const char*); +SOAP_FMAC3 cb__TimedCounterType ** SOAP_FMAC4 soap_in_PointerTocb__TimedCounterType(struct soap*, const char*, cb__TimedCounterType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerFilterType +#define SOAP_TYPE_PointerTocb__CircuitBreakerFilterType (792) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerFilterType(struct soap*, cb__CircuitBreakerFilterType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerFilterType(struct soap*, cb__CircuitBreakerFilterType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerFilterType(struct soap*, const char *, int, cb__CircuitBreakerFilterType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerFilterType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerFilterType(struct soap*, cb__CircuitBreakerFilterType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerFilterType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerFilterType(struct soap*, const char*, cb__CircuitBreakerFilterType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerPacketType +#define SOAP_TYPE_PointerTocb__CircuitBreakerPacketType (791) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketType(struct soap*, cb__CircuitBreakerPacketType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketType(struct soap*, cb__CircuitBreakerPacketType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketType(struct soap*, const char *, int, cb__CircuitBreakerPacketType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerPacketType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketType(struct soap*, cb__CircuitBreakerPacketType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketType(struct soap*, const char*, cb__CircuitBreakerPacketType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerPacketETHType +#define SOAP_TYPE_PointerTocb__CircuitBreakerPacketETHType (789) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketETHType(struct soap*, cb__CircuitBreakerPacketETHType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketETHType(struct soap*, cb__CircuitBreakerPacketETHType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketETHType(struct soap*, const char *, int, cb__CircuitBreakerPacketETHType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerPacketETHType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketETHType(struct soap*, cb__CircuitBreakerPacketETHType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketETHType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketETHType(struct soap*, const char*, cb__CircuitBreakerPacketETHType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerPacketIPType +#define SOAP_TYPE_PointerTocb__CircuitBreakerPacketIPType (788) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketIPType(struct soap*, cb__CircuitBreakerPacketIPType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketIPType(struct soap*, cb__CircuitBreakerPacketIPType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketIPType(struct soap*, const char *, int, cb__CircuitBreakerPacketIPType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerPacketIPType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketIPType(struct soap*, cb__CircuitBreakerPacketIPType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketIPType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketIPType(struct soap*, const char*, cb__CircuitBreakerPacketIPType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerPacketUDPType +#define SOAP_TYPE_PointerTocb__CircuitBreakerPacketUDPType (787) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketUDPType(struct soap*, cb__CircuitBreakerPacketUDPType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketUDPType(struct soap*, cb__CircuitBreakerPacketUDPType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketUDPType(struct soap*, const char *, int, cb__CircuitBreakerPacketUDPType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketUDPType(struct soap*, cb__CircuitBreakerPacketUDPType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketUDPType(struct soap*, const char*, cb__CircuitBreakerPacketUDPType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerPacketTCPType +#define SOAP_TYPE_PointerTocb__CircuitBreakerPacketTCPType (786) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketTCPType(struct soap*, cb__CircuitBreakerPacketTCPType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketTCPType(struct soap*, cb__CircuitBreakerPacketTCPType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketTCPType(struct soap*, const char *, int, cb__CircuitBreakerPacketTCPType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketTCPType(struct soap*, cb__CircuitBreakerPacketTCPType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketTCPType(struct soap*, const char*, cb__CircuitBreakerPacketTCPType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortType +#define SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortType (785) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap*, cb__CircuitBreakerIPLayeredPortType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap*, cb__CircuitBreakerIPLayeredPortType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap*, const char *, int, cb__CircuitBreakerIPLayeredPortType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap*, cb__CircuitBreakerIPLayeredPortType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap*, const char*, cb__CircuitBreakerIPLayeredPortType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerIPPacketType +#define SOAP_TYPE_PointerTocb__CircuitBreakerIPPacketType (784) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPPacketType(struct soap*, cb__CircuitBreakerIPPacketType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPPacketType(struct soap*, cb__CircuitBreakerIPPacketType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPPacketType(struct soap*, const char *, int, cb__CircuitBreakerIPPacketType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerIPPacketType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPPacketType(struct soap*, cb__CircuitBreakerIPPacketType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPPacketType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPPacketType(struct soap*, const char*, cb__CircuitBreakerIPPacketType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerIPv6Type +#define SOAP_TYPE_PointerTocb__CircuitBreakerIPv6Type (782) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPv6Type(struct soap*, cb__CircuitBreakerIPv6Type *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPv6Type(struct soap*, cb__CircuitBreakerIPv6Type *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPv6Type(struct soap*, const char *, int, cb__CircuitBreakerIPv6Type *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerIPv6Type ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPv6Type(struct soap*, cb__CircuitBreakerIPv6Type **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv6Type ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPv6Type(struct soap*, const char*, cb__CircuitBreakerIPv6Type **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerIPv4Type +#define SOAP_TYPE_PointerTocb__CircuitBreakerIPv4Type (781) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPv4Type(struct soap*, cb__CircuitBreakerIPv4Type *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPv4Type(struct soap*, cb__CircuitBreakerIPv4Type *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPv4Type(struct soap*, const char *, int, cb__CircuitBreakerIPv4Type *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerIPv4Type ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPv4Type(struct soap*, cb__CircuitBreakerIPv4Type **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv4Type ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPv4Type(struct soap*, const char*, cb__CircuitBreakerIPv4Type **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerIPv6AddressAndMaskType +#define SOAP_TYPE_PointerTocb__CircuitBreakerIPv6AddressAndMaskType (780) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv6AddressAndMaskType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv6AddressAndMaskType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, const char *, int, cb__CircuitBreakerIPv6AddressAndMaskType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv6AddressAndMaskType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap*, const char*, cb__CircuitBreakerIPv6AddressAndMaskType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerIPv4AddressAndMaskType +#define SOAP_TYPE_PointerTocb__CircuitBreakerIPv4AddressAndMaskType (779) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv4AddressAndMaskType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv4AddressAndMaskType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, const char *, int, cb__CircuitBreakerIPv4AddressAndMaskType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, cb__CircuitBreakerIPv4AddressAndMaskType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap*, const char*, cb__CircuitBreakerIPv4AddressAndMaskType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortRangeType +#define SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortRangeType (777) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap*, cb__CircuitBreakerIPLayeredPortRangeType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap*, cb__CircuitBreakerIPLayeredPortRangeType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap*, const char *, int, cb__CircuitBreakerIPLayeredPortRangeType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap*, cb__CircuitBreakerIPLayeredPortRangeType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap*, const char*, cb__CircuitBreakerIPLayeredPortRangeType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortSimpleType +#define SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortSimpleType (776) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, cb__CircuitBreakerIPLayeredPortSimpleType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, cb__CircuitBreakerIPLayeredPortSimpleType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, const char *, int, cb__CircuitBreakerIPLayeredPortSimpleType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, cb__CircuitBreakerIPLayeredPortSimpleType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap*, const char*, cb__CircuitBreakerIPLayeredPortSimpleType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerPolicyType +#define SOAP_TYPE_PointerTocb__CircuitBreakerPolicyType (775) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPolicyType(struct soap*, cb__CircuitBreakerPolicyType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPolicyType(struct soap*, cb__CircuitBreakerPolicyType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPolicyType(struct soap*, const char *, int, cb__CircuitBreakerPolicyType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerPolicyType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPolicyType(struct soap*, cb__CircuitBreakerPolicyType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerPolicyType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPolicyType(struct soap*, const char*, cb__CircuitBreakerPolicyType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerDefaultFilterType +#define SOAP_TYPE_PointerTocb__CircuitBreakerDefaultFilterType (774) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerDefaultFilterType(struct soap*, cb__CircuitBreakerDefaultFilterType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerDefaultFilterType(struct soap*, cb__CircuitBreakerDefaultFilterType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerDefaultFilterType(struct soap*, const char *, int, cb__CircuitBreakerDefaultFilterType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerDefaultFilterType(struct soap*, cb__CircuitBreakerDefaultFilterType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerDefaultFilterType(struct soap*, const char*, cb__CircuitBreakerDefaultFilterType **, const char*); + +#ifndef SOAP_TYPE_PointerTocb__CircuitBreakerAntiSpoofingFilterType +#define SOAP_TYPE_PointerTocb__CircuitBreakerAntiSpoofingFilterType (773) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap*, cb__CircuitBreakerAntiSpoofingFilterType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap*, cb__CircuitBreakerAntiSpoofingFilterType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap*, const char *, int, cb__CircuitBreakerAntiSpoofingFilterType *const*, const char *); +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap*, cb__CircuitBreakerAntiSpoofingFilterType **, const char*, const char*); +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap*, const char*, cb__CircuitBreakerAntiSpoofingFilterType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__AlertSubscriptionGeneralType +#define SOAP_TYPE_PointerToemi__AlertSubscriptionGeneralType (772) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionGeneralType(struct soap*, emi__AlertSubscriptionGeneralType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionGeneralType(struct soap*, emi__AlertSubscriptionGeneralType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionGeneralType(struct soap*, const char *, int, emi__AlertSubscriptionGeneralType *const*, const char *); +SOAP_FMAC3 emi__AlertSubscriptionGeneralType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionGeneralType(struct soap*, emi__AlertSubscriptionGeneralType **, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionGeneralType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionGeneralType(struct soap*, const char*, emi__AlertSubscriptionGeneralType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__SensorAttributesType +#define SOAP_TYPE_PointerToemi__SensorAttributesType (771) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__SensorAttributesType(struct soap*, emi__SensorAttributesType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__SensorAttributesType(struct soap*, emi__SensorAttributesType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__SensorAttributesType(struct soap*, const char *, int, emi__SensorAttributesType *const*, const char *); +SOAP_FMAC3 emi__SensorAttributesType ** SOAP_FMAC4 soap_get_PointerToemi__SensorAttributesType(struct soap*, emi__SensorAttributesType **, const char*, const char*); +SOAP_FMAC3 emi__SensorAttributesType ** SOAP_FMAC4 soap_in_PointerToemi__SensorAttributesType(struct soap*, const char*, emi__SensorAttributesType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__SensorHandleArrayType +#define SOAP_TYPE_PointerToemi__SensorHandleArrayType (770) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__SensorHandleArrayType(struct soap*, emi__SensorHandleArrayType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__SensorHandleArrayType(struct soap*, emi__SensorHandleArrayType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__SensorHandleArrayType(struct soap*, const char *, int, emi__SensorHandleArrayType *const*, const char *); +SOAP_FMAC3 emi__SensorHandleArrayType ** SOAP_FMAC4 soap_get_PointerToemi__SensorHandleArrayType(struct soap*, emi__SensorHandleArrayType **, const char*, const char*); +SOAP_FMAC3 emi__SensorHandleArrayType ** SOAP_FMAC4 soap_in_PointerToemi__SensorHandleArrayType(struct soap*, const char*, emi__SensorHandleArrayType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__EventLogRecordArrayType +#define SOAP_TYPE_PointerToemi__EventLogRecordArrayType (769) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__EventLogRecordArrayType(struct soap*, emi__EventLogRecordArrayType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__EventLogRecordArrayType(struct soap*, emi__EventLogRecordArrayType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__EventLogRecordArrayType(struct soap*, const char *, int, emi__EventLogRecordArrayType *const*, const char *); +SOAP_FMAC3 emi__EventLogRecordArrayType ** SOAP_FMAC4 soap_get_PointerToemi__EventLogRecordArrayType(struct soap*, emi__EventLogRecordArrayType **, const char*, const char*); +SOAP_FMAC3 emi__EventLogRecordArrayType ** SOAP_FMAC4 soap_in_PointerToemi__EventLogRecordArrayType(struct soap*, const char*, emi__EventLogRecordArrayType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__EventFilterHandleArrayType +#define SOAP_TYPE_PointerToemi__EventFilterHandleArrayType (768) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__EventFilterHandleArrayType(struct soap*, emi__EventFilterHandleArrayType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__EventFilterHandleArrayType(struct soap*, emi__EventFilterHandleArrayType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__EventFilterHandleArrayType(struct soap*, const char *, int, emi__EventFilterHandleArrayType *const*, const char *); +SOAP_FMAC3 emi__EventFilterHandleArrayType ** SOAP_FMAC4 soap_get_PointerToemi__EventFilterHandleArrayType(struct soap*, emi__EventFilterHandleArrayType **, const char*, const char*); +SOAP_FMAC3 emi__EventFilterHandleArrayType ** SOAP_FMAC4 soap_in_PointerToemi__EventFilterHandleArrayType(struct soap*, const char*, emi__EventFilterHandleArrayType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__EventFilterType +#define SOAP_TYPE_PointerToemi__EventFilterType (767) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__EventFilterType(struct soap*, emi__EventFilterType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__EventFilterType(struct soap*, emi__EventFilterType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__EventFilterType(struct soap*, const char *, int, emi__EventFilterType *const*, const char *); +SOAP_FMAC3 emi__EventFilterType ** SOAP_FMAC4 soap_get_PointerToemi__EventFilterType(struct soap*, emi__EventFilterType **, const char*, const char*); +SOAP_FMAC3 emi__EventFilterType ** SOAP_FMAC4 soap_in_PointerToemi__EventFilterType(struct soap*, const char*, emi__EventFilterType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__ByteStr +#define SOAP_TYPE_PointerToemi__ByteStr (766) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__ByteStr(struct soap*, emi__ByteStr *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__ByteStr(struct soap*, emi__ByteStr *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__ByteStr(struct soap*, const char *, int, emi__ByteStr *const*, const char *); +SOAP_FMAC3 emi__ByteStr ** SOAP_FMAC4 soap_get_PointerToemi__ByteStr(struct soap*, emi__ByteStr **, const char*, const char*); +SOAP_FMAC3 emi__ByteStr ** SOAP_FMAC4 soap_in_PointerToemi__ByteStr(struct soap*, const char*, emi__ByteStr **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDArrayType +#define SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDArrayType (765) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap*, emi__AlertSubscriptionPolicyIDArrayType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap*, emi__AlertSubscriptionPolicyIDArrayType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap*, const char *, int, emi__AlertSubscriptionPolicyIDArrayType *const*, const char *); +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap*, emi__AlertSubscriptionPolicyIDArrayType **, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap*, const char*, emi__AlertSubscriptionPolicyIDArrayType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__AlertSubscriptionHandleArrayType +#define SOAP_TYPE_PointerToemi__AlertSubscriptionHandleArrayType (764) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionHandleArrayType(struct soap*, emi__AlertSubscriptionHandleArrayType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionHandleArrayType(struct soap*, emi__AlertSubscriptionHandleArrayType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionHandleArrayType(struct soap*, const char *, int, emi__AlertSubscriptionHandleArrayType *const*, const char *); +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionHandleArrayType(struct soap*, emi__AlertSubscriptionHandleArrayType **, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionHandleArrayType(struct soap*, const char*, emi__AlertSubscriptionHandleArrayType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDType +#define SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDType (763) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionPolicyIDType(struct soap*, unsigned char *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionPolicyIDType(struct soap*, unsigned char *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionPolicyIDType(struct soap*, const char *, int, unsigned char *const*, const char *); +SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionPolicyIDType(struct soap*, unsigned char **, const char*, const char*); +SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionPolicyIDType(struct soap*, const char*, unsigned char **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__AlertSubscriptionType +#define SOAP_TYPE_PointerToemi__AlertSubscriptionType (762) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionType(struct soap*, emi__AlertSubscriptionType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionType(struct soap*, emi__AlertSubscriptionType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionType(struct soap*, const char *, int, emi__AlertSubscriptionType *const*, const char *); +SOAP_FMAC3 emi__AlertSubscriptionType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionType(struct soap*, emi__AlertSubscriptionType **, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionType(struct soap*, const char*, emi__AlertSubscriptionType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__AlertSubscriptionSoapType +#define SOAP_TYPE_PointerToemi__AlertSubscriptionSoapType (760) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionSoapType(struct soap*, emi__AlertSubscriptionSoapType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionSoapType(struct soap*, emi__AlertSubscriptionSoapType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionSoapType(struct soap*, const char *, int, emi__AlertSubscriptionSoapType *const*, const char *); +SOAP_FMAC3 emi__AlertSubscriptionSoapType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionSoapType(struct soap*, emi__AlertSubscriptionSoapType **, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionSoapType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionSoapType(struct soap*, const char*, emi__AlertSubscriptionSoapType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__AlertSubscriptionSNMPType +#define SOAP_TYPE_PointerToemi__AlertSubscriptionSNMPType (759) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionSNMPType(struct soap*, emi__AlertSubscriptionSNMPType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionSNMPType(struct soap*, emi__AlertSubscriptionSNMPType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionSNMPType(struct soap*, const char *, int, emi__AlertSubscriptionSNMPType *const*, const char *); +SOAP_FMAC3 emi__AlertSubscriptionSNMPType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionSNMPType(struct soap*, emi__AlertSubscriptionSNMPType **, const char*, const char*); +SOAP_FMAC3 emi__AlertSubscriptionSNMPType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionSNMPType(struct soap*, const char*, emi__AlertSubscriptionSNMPType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__AlertCredentialsType +#define SOAP_TYPE_PointerToemi__AlertCredentialsType (757) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertCredentialsType(struct soap*, emi__AlertCredentialsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertCredentialsType(struct soap*, emi__AlertCredentialsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertCredentialsType(struct soap*, const char *, int, emi__AlertCredentialsType *const*, const char *); +SOAP_FMAC3 emi__AlertCredentialsType ** SOAP_FMAC4 soap_get_PointerToemi__AlertCredentialsType(struct soap*, emi__AlertCredentialsType **, const char*, const char*); +SOAP_FMAC3 emi__AlertCredentialsType ** SOAP_FMAC4 soap_in_PointerToemi__AlertCredentialsType(struct soap*, const char*, emi__AlertCredentialsType **, const char*); + +#ifndef SOAP_TYPE_PointerTocmn__URLType +#define SOAP_TYPE_PointerTocmn__URLType (756) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__URLType(struct soap*, cmn__URLType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__URLType(struct soap*, cmn__URLType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__URLType(struct soap*, const char *, int, cmn__URLType *const*, const char *); +SOAP_FMAC3 cmn__URLType ** SOAP_FMAC4 soap_get_PointerTocmn__URLType(struct soap*, cmn__URLType **, const char*, const char*); +SOAP_FMAC3 cmn__URLType ** SOAP_FMAC4 soap_in_PointerTocmn__URLType(struct soap*, const char*, cmn__URLType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__CommunityStringType +#define SOAP_TYPE_PointerToemi__CommunityStringType (755) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__CommunityStringType(struct soap*, std::string *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__CommunityStringType(struct soap*, std::string *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__CommunityStringType(struct soap*, const char *, int, std::string *const*, const char *); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerToemi__CommunityStringType(struct soap*, std::string **, const char*, const char*); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerToemi__CommunityStringType(struct soap*, const char*, std::string **, const char*); + +#ifndef SOAP_TYPE_PointerTocmn__NodeAddressType +#define SOAP_TYPE_PointerTocmn__NodeAddressType (754) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__NodeAddressType(struct soap*, cmn__NodeAddressType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__NodeAddressType(struct soap*, cmn__NodeAddressType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__NodeAddressType(struct soap*, const char *, int, cmn__NodeAddressType *const*, const char *); +SOAP_FMAC3 cmn__NodeAddressType ** SOAP_FMAC4 soap_get_PointerTocmn__NodeAddressType(struct soap*, cmn__NodeAddressType **, const char*, const char*); +SOAP_FMAC3 cmn__NodeAddressType ** SOAP_FMAC4 soap_in_PointerTocmn__NodeAddressType(struct soap*, const char*, cmn__NodeAddressType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__EventLogRecordType +#define SOAP_TYPE_PointerToemi__EventLogRecordType (751) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__EventLogRecordType(struct soap*, emi__EventLogRecordType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__EventLogRecordType(struct soap*, emi__EventLogRecordType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__EventLogRecordType(struct soap*, const char *, int, emi__EventLogRecordType *const*, const char *); +SOAP_FMAC3 emi__EventLogRecordType ** SOAP_FMAC4 soap_get_PointerToemi__EventLogRecordType(struct soap*, emi__EventLogRecordType **, const char*, const char*); +SOAP_FMAC3 emi__EventLogRecordType ** SOAP_FMAC4 soap_in_PointerToemi__EventLogRecordType(struct soap*, const char*, emi__EventLogRecordType **, const char*); + +#ifndef SOAP_TYPE_PointerToemi__ByteData +#define SOAP_TYPE_PointerToemi__ByteData (748) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__ByteData(struct soap*, emi__ByteData *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__ByteData(struct soap*, emi__ByteData *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__ByteData(struct soap*, const char *, int, emi__ByteData *const*, const char *); +SOAP_FMAC3 emi__ByteData ** SOAP_FMAC4 soap_get_PointerToemi__ByteData(struct soap*, emi__ByteData **, const char*, const char*); +SOAP_FMAC3 emi__ByteData ** SOAP_FMAC4 soap_in_PointerToemi__ByteData(struct soap*, const char*, emi__ByteData **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__StorageAllocEntryHandleListType +#define SOAP_TYPE_PointerTostra__StorageAllocEntryHandleListType (746) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageAllocEntryHandleListType(struct soap*, stra__StorageAllocEntryHandleListType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageAllocEntryHandleListType(struct soap*, stra__StorageAllocEntryHandleListType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageAllocEntryHandleListType(struct soap*, const char *, int, stra__StorageAllocEntryHandleListType *const*, const char *); +SOAP_FMAC3 stra__StorageAllocEntryHandleListType ** SOAP_FMAC4 soap_get_PointerTostra__StorageAllocEntryHandleListType(struct soap*, stra__StorageAllocEntryHandleListType **, const char*, const char*); +SOAP_FMAC3 stra__StorageAllocEntryHandleListType ** SOAP_FMAC4 soap_in_PointerTostra__StorageAllocEntryHandleListType(struct soap*, const char*, stra__StorageAllocEntryHandleListType **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__StorageAllocEntryType +#define SOAP_TYPE_PointerTostra__StorageAllocEntryType (745) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageAllocEntryType(struct soap*, stra__StorageAllocEntryType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageAllocEntryType(struct soap*, stra__StorageAllocEntryType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageAllocEntryType(struct soap*, const char *, int, stra__StorageAllocEntryType *const*, const char *); +SOAP_FMAC3 stra__StorageAllocEntryType ** SOAP_FMAC4 soap_get_PointerTostra__StorageAllocEntryType(struct soap*, stra__StorageAllocEntryType **, const char*, const char*); +SOAP_FMAC3 stra__StorageAllocEntryType ** SOAP_FMAC4 soap_in_PointerTostra__StorageAllocEntryType(struct soap*, const char*, stra__StorageAllocEntryType **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__StorageEaclEntryHandleListType +#define SOAP_TYPE_PointerTostra__StorageEaclEntryHandleListType (744) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageEaclEntryHandleListType(struct soap*, stra__StorageEaclEntryHandleListType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageEaclEntryHandleListType(struct soap*, stra__StorageEaclEntryHandleListType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageEaclEntryHandleListType(struct soap*, const char *, int, stra__StorageEaclEntryHandleListType *const*, const char *); +SOAP_FMAC3 stra__StorageEaclEntryHandleListType ** SOAP_FMAC4 soap_get_PointerTostra__StorageEaclEntryHandleListType(struct soap*, stra__StorageEaclEntryHandleListType **, const char*, const char*); +SOAP_FMAC3 stra__StorageEaclEntryHandleListType ** SOAP_FMAC4 soap_in_PointerTostra__StorageEaclEntryHandleListType(struct soap*, const char*, stra__StorageEaclEntryHandleListType **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__StorageEaclEntryType +#define SOAP_TYPE_PointerTostra__StorageEaclEntryType (743) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageEaclEntryType(struct soap*, stra__StorageEaclEntryType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageEaclEntryType(struct soap*, stra__StorageEaclEntryType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageEaclEntryType(struct soap*, const char *, int, stra__StorageEaclEntryType *const*, const char *); +SOAP_FMAC3 stra__StorageEaclEntryType ** SOAP_FMAC4 soap_get_PointerTostra__StorageEaclEntryType(struct soap*, stra__StorageEaclEntryType **, const char*, const char*); +SOAP_FMAC3 stra__StorageEaclEntryType ** SOAP_FMAC4 soap_in_PointerTostra__StorageEaclEntryType(struct soap*, const char*, stra__StorageEaclEntryType **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__StorageApplicationAttributesType +#define SOAP_TYPE_PointerTostra__StorageApplicationAttributesType (742) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageApplicationAttributesType(struct soap*, stra__StorageApplicationAttributesType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageApplicationAttributesType(struct soap*, stra__StorageApplicationAttributesType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageApplicationAttributesType(struct soap*, const char *, int, stra__StorageApplicationAttributesType *const*, const char *); +SOAP_FMAC3 stra__StorageApplicationAttributesType ** SOAP_FMAC4 soap_get_PointerTostra__StorageApplicationAttributesType(struct soap*, stra__StorageApplicationAttributesType **, const char*, const char*); +SOAP_FMAC3 stra__StorageApplicationAttributesType ** SOAP_FMAC4 soap_in_PointerTostra__StorageApplicationAttributesType(struct soap*, const char*, stra__StorageApplicationAttributesType **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__StorageApplicationHandleListType +#define SOAP_TYPE_PointerTostra__StorageApplicationHandleListType (741) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageApplicationHandleListType(struct soap*, stra__StorageApplicationHandleListType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageApplicationHandleListType(struct soap*, stra__StorageApplicationHandleListType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageApplicationHandleListType(struct soap*, const char *, int, stra__StorageApplicationHandleListType *const*, const char *); +SOAP_FMAC3 stra__StorageApplicationHandleListType ** SOAP_FMAC4 soap_get_PointerTostra__StorageApplicationHandleListType(struct soap*, stra__StorageApplicationHandleListType **, const char*, const char*); +SOAP_FMAC3 stra__StorageApplicationHandleListType ** SOAP_FMAC4 soap_in_PointerTostra__StorageApplicationHandleListType(struct soap*, const char*, stra__StorageApplicationHandleListType **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__GlobalStorageAttributesType +#define SOAP_TYPE_PointerTostra__GlobalStorageAttributesType (740) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__GlobalStorageAttributesType(struct soap*, stra__GlobalStorageAttributesType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__GlobalStorageAttributesType(struct soap*, stra__GlobalStorageAttributesType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__GlobalStorageAttributesType(struct soap*, const char *, int, stra__GlobalStorageAttributesType *const*, const char *); +SOAP_FMAC3 stra__GlobalStorageAttributesType ** SOAP_FMAC4 soap_get_PointerTostra__GlobalStorageAttributesType(struct soap*, stra__GlobalStorageAttributesType **, const char*, const char*); +SOAP_FMAC3 stra__GlobalStorageAttributesType ** SOAP_FMAC4 soap_in_PointerTostra__GlobalStorageAttributesType(struct soap*, const char*, stra__GlobalStorageAttributesType **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__StorageSnrpApplicationAttributeType +#define SOAP_TYPE_PointerTostra__StorageSnrpApplicationAttributeType (739) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageSnrpApplicationAttributeType(struct soap*, stra__StorageSnrpApplicationAttributeType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageSnrpApplicationAttributeType(struct soap*, stra__StorageSnrpApplicationAttributeType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageSnrpApplicationAttributeType(struct soap*, const char *, int, stra__StorageSnrpApplicationAttributeType *const*, const char *); +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType ** SOAP_FMAC4 soap_get_PointerTostra__StorageSnrpApplicationAttributeType(struct soap*, stra__StorageSnrpApplicationAttributeType **, const char*, const char*); +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType ** SOAP_FMAC4 soap_in_PointerTostra__StorageSnrpApplicationAttributeType(struct soap*, const char*, stra__StorageSnrpApplicationAttributeType **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__GUID +#define SOAP_TYPE_PointerTostra__GUID (738) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__GUID(struct soap*, stra__GUID *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__GUID(struct soap*, stra__GUID *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__GUID(struct soap*, const char *, int, stra__GUID *const*, const char *); +SOAP_FMAC3 stra__GUID ** SOAP_FMAC4 soap_get_PointerTostra__GUID(struct soap*, stra__GUID **, const char*, const char*); +SOAP_FMAC3 stra__GUID ** SOAP_FMAC4 soap_in_PointerTostra__GUID(struct soap*, const char*, stra__GUID **, const char*); + +#ifndef SOAP_TYPE_PointerTostra__StorageAllocSnrpEntryType +#define SOAP_TYPE_PointerTostra__StorageAllocSnrpEntryType (734) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageAllocSnrpEntryType(struct soap*, stra__StorageAllocSnrpEntryType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageAllocSnrpEntryType(struct soap*, stra__StorageAllocSnrpEntryType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageAllocSnrpEntryType(struct soap*, const char *, int, stra__StorageAllocSnrpEntryType *const*, const char *); +SOAP_FMAC3 stra__StorageAllocSnrpEntryType ** SOAP_FMAC4 soap_get_PointerTostra__StorageAllocSnrpEntryType(struct soap*, stra__StorageAllocSnrpEntryType **, const char*, const char*); +SOAP_FMAC3 stra__StorageAllocSnrpEntryType ** SOAP_FMAC4 soap_in_PointerTostra__StorageAllocSnrpEntryType(struct soap*, const char*, stra__StorageAllocSnrpEntryType **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__XProfileType +#define SOAP_TYPE_PointerToxcfg__XProfileType (732) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileType(struct soap*, xcfg__XProfileType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileType(struct soap*, xcfg__XProfileType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileType(struct soap*, const char *, int, xcfg__XProfileType *const*, const char *); +SOAP_FMAC3 xcfg__XProfileType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileType(struct soap*, xcfg__XProfileType **, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileType(struct soap*, const char*, xcfg__XProfileType **, const char*); + +#ifndef SOAP_TYPE_PointerTonet__InterfaceDescriptorSetType +#define SOAP_TYPE_PointerTonet__InterfaceDescriptorSetType (731) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTonet__InterfaceDescriptorSetType(struct soap*, net__InterfaceDescriptorSetType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTonet__InterfaceDescriptorSetType(struct soap*, net__InterfaceDescriptorSetType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTonet__InterfaceDescriptorSetType(struct soap*, const char *, int, net__InterfaceDescriptorSetType *const*, const char *); +SOAP_FMAC3 net__InterfaceDescriptorSetType ** SOAP_FMAC4 soap_get_PointerTonet__InterfaceDescriptorSetType(struct soap*, net__InterfaceDescriptorSetType **, const char*, const char*); +SOAP_FMAC3 net__InterfaceDescriptorSetType ** SOAP_FMAC4 soap_in_PointerTonet__InterfaceDescriptorSetType(struct soap*, const char*, net__InterfaceDescriptorSetType **, const char*); + +#ifndef SOAP_TYPE_PointerTonet__InterfaceDescriptorGetType +#define SOAP_TYPE_PointerTonet__InterfaceDescriptorGetType (730) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTonet__InterfaceDescriptorGetType(struct soap*, net__InterfaceDescriptorGetType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTonet__InterfaceDescriptorGetType(struct soap*, net__InterfaceDescriptorGetType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTonet__InterfaceDescriptorGetType(struct soap*, const char *, int, net__InterfaceDescriptorGetType *const*, const char *); +SOAP_FMAC3 net__InterfaceDescriptorGetType ** SOAP_FMAC4 soap_get_PointerTonet__InterfaceDescriptorGetType(struct soap*, net__InterfaceDescriptorGetType **, const char*, const char*); +SOAP_FMAC3 net__InterfaceDescriptorGetType ** SOAP_FMAC4 soap_in_PointerTonet__InterfaceDescriptorGetType(struct soap*, const char*, net__InterfaceDescriptorGetType **, const char*); + +#ifndef SOAP_TYPE_PointerTocmn__InterfaceHandleType +#define SOAP_TYPE_PointerTocmn__InterfaceHandleType (728) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__InterfaceHandleType(struct soap*, unsigned int *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__InterfaceHandleType(struct soap*, unsigned int *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__InterfaceHandleType(struct soap*, const char *, int, unsigned int *const*, const char *); +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_get_PointerTocmn__InterfaceHandleType(struct soap*, unsigned int **, const char*, const char*); +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTocmn__InterfaceHandleType(struct soap*, const char*, unsigned int **, const char*); + +#ifndef SOAP_TYPE_PointerTonet__StaticIPv4ParametersType +#define SOAP_TYPE_PointerTonet__StaticIPv4ParametersType (727) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTonet__StaticIPv4ParametersType(struct soap*, net__StaticIPv4ParametersType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTonet__StaticIPv4ParametersType(struct soap*, net__StaticIPv4ParametersType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTonet__StaticIPv4ParametersType(struct soap*, const char *, int, net__StaticIPv4ParametersType *const*, const char *); +SOAP_FMAC3 net__StaticIPv4ParametersType ** SOAP_FMAC4 soap_get_PointerTonet__StaticIPv4ParametersType(struct soap*, net__StaticIPv4ParametersType **, const char*, const char*); +SOAP_FMAC3 net__StaticIPv4ParametersType ** SOAP_FMAC4 soap_in_PointerTonet__StaticIPv4ParametersType(struct soap*, const char*, net__StaticIPv4ParametersType **, const char*); + +#ifndef SOAP_TYPE_PointerTonet__IPv4ParametersType +#define SOAP_TYPE_PointerTonet__IPv4ParametersType (726) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTonet__IPv4ParametersType(struct soap*, net__IPv4ParametersType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTonet__IPv4ParametersType(struct soap*, net__IPv4ParametersType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTonet__IPv4ParametersType(struct soap*, const char *, int, net__IPv4ParametersType *const*, const char *); +SOAP_FMAC3 net__IPv4ParametersType ** SOAP_FMAC4 soap_get_PointerTonet__IPv4ParametersType(struct soap*, net__IPv4ParametersType **, const char*, const char*); +SOAP_FMAC3 net__IPv4ParametersType ** SOAP_FMAC4 soap_in_PointerTonet__IPv4ParametersType(struct soap*, const char*, net__IPv4ParametersType **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCORETLSType +#define SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCORETLSType (724) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap*, xcfg__XProfileEAPFAST_USCORETLSType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap*, xcfg__XProfileEAPFAST_USCORETLSType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap*, const char *, int, xcfg__XProfileEAPFAST_USCORETLSType *const*, const char *); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap*, xcfg__XProfileEAPFAST_USCORETLSType **, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap*, const char*, xcfg__XProfileEAPFAST_USCORETLSType **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREGTCType +#define SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREGTCType (723) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, xcfg__XProfileEAPFAST_USCOREGTCType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, xcfg__XProfileEAPFAST_USCOREGTCType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, const char *, int, xcfg__XProfileEAPFAST_USCOREGTCType *const*, const char *); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, xcfg__XProfileEAPFAST_USCOREGTCType **, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap*, const char*, xcfg__XProfileEAPFAST_USCOREGTCType **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type +#define SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type (722) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, const char *, int, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *const*, const char *); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type **, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap*, const char*, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__XProfileEAP_USCOREGTCType +#define SOAP_TYPE_PointerToxcfg__XProfileEAP_USCOREGTCType (721) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap*, xcfg__XProfileEAP_USCOREGTCType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap*, xcfg__XProfileEAP_USCOREGTCType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap*, const char *, int, xcfg__XProfileEAP_USCOREGTCType *const*, const char *); +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap*, xcfg__XProfileEAP_USCOREGTCType **, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap*, const char*, xcfg__XProfileEAP_USCOREGTCType **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type +#define SOAP_TYPE_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type (720) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, const char *, int, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *const*, const char *); +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfilePEAP_USCOREMSCHAPv2Type **, const char*, const char*); +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap*, const char*, xcfg__XProfilePEAP_USCOREMSCHAPv2Type **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type +#define SOAP_TYPE_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type (719) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, const char *, int, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *const*, const char *); +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, xcfg__XProfileTTLS_USCOREMSCHAPv2Type **, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap*, const char*, xcfg__XProfileTTLS_USCOREMSCHAPv2Type **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__XProfileTLSType +#define SOAP_TYPE_PointerToxcfg__XProfileTLSType (718) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileTLSType(struct soap*, xcfg__XProfileTLSType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileTLSType(struct soap*, xcfg__XProfileTLSType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileTLSType(struct soap*, const char *, int, xcfg__XProfileTLSType *const*, const char *); +SOAP_FMAC3 xcfg__XProfileTLSType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileTLSType(struct soap*, xcfg__XProfileTLSType **, const char*, const char*); +SOAP_FMAC3 xcfg__XProfileTLSType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileTLSType(struct soap*, const char*, xcfg__XProfileTLSType **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__ManualPACType +#define SOAP_TYPE_PointerToxcfg__ManualPACType (717) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__ManualPACType(struct soap*, xcfg__ManualPACType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__ManualPACType(struct soap*, xcfg__ManualPACType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__ManualPACType(struct soap*, const char *, int, xcfg__ManualPACType *const*, const char *); +SOAP_FMAC3 xcfg__ManualPACType ** SOAP_FMAC4 soap_get_PointerToxcfg__ManualPACType(struct soap*, xcfg__ManualPACType **, const char*, const char*); +SOAP_FMAC3 xcfg__ManualPACType ** SOAP_FMAC4 soap_in_PointerToxcfg__ManualPACType(struct soap*, const char*, xcfg__ManualPACType **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__UserCredentialsType +#define SOAP_TYPE_PointerToxcfg__UserCredentialsType (716) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__UserCredentialsType(struct soap*, xcfg__UserCredentialsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__UserCredentialsType(struct soap*, xcfg__UserCredentialsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__UserCredentialsType(struct soap*, const char *, int, xcfg__UserCredentialsType *const*, const char *); +SOAP_FMAC3 xcfg__UserCredentialsType ** SOAP_FMAC4 soap_get_PointerToxcfg__UserCredentialsType(struct soap*, xcfg__UserCredentialsType **, const char*, const char*); +SOAP_FMAC3 xcfg__UserCredentialsType ** SOAP_FMAC4 soap_in_PointerToxcfg__UserCredentialsType(struct soap*, const char*, xcfg__UserCredentialsType **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__ServerIdentityType +#define SOAP_TYPE_PointerToxcfg__ServerIdentityType (715) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__ServerIdentityType(struct soap*, xcfg__ServerIdentityType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__ServerIdentityType(struct soap*, xcfg__ServerIdentityType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__ServerIdentityType(struct soap*, const char *, int, xcfg__ServerIdentityType *const*, const char *); +SOAP_FMAC3 xcfg__ServerIdentityType ** SOAP_FMAC4 soap_get_PointerToxcfg__ServerIdentityType(struct soap*, xcfg__ServerIdentityType **, const char*, const char*); +SOAP_FMAC3 xcfg__ServerIdentityType ** SOAP_FMAC4 soap_in_PointerToxcfg__ServerIdentityType(struct soap*, const char*, xcfg__ServerIdentityType **, const char*); + +#ifndef SOAP_TYPE_PointerToxcfg__CertificateNameType +#define SOAP_TYPE_PointerToxcfg__CertificateNameType (714) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__CertificateNameType(struct soap*, xcfg__CertificateNameType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__CertificateNameType(struct soap*, xcfg__CertificateNameType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__CertificateNameType(struct soap*, const char *, int, xcfg__CertificateNameType *const*, const char *); +SOAP_FMAC3 xcfg__CertificateNameType ** SOAP_FMAC4 soap_get_PointerToxcfg__CertificateNameType(struct soap*, xcfg__CertificateNameType **, const char*, const char*); +SOAP_FMAC3 xcfg__CertificateNameType ** SOAP_FMAC4 soap_in_PointerToxcfg__CertificateNameType(struct soap*, const char*, xcfg__CertificateNameType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__CertificateHandleType +#define SOAP_TYPE_PointerTosai__CertificateHandleType (713) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CertificateHandleType(struct soap*, unsigned int *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CertificateHandleType(struct soap*, unsigned int *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CertificateHandleType(struct soap*, const char *, int, unsigned int *const*, const char *); +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_get_PointerTosai__CertificateHandleType(struct soap*, unsigned int **, const char*, const char*); +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTosai__CertificateHandleType(struct soap*, const char*, unsigned int **, const char*); + +#ifndef SOAP_TYPE_PointerTocstr__KeyPairType +#define SOAP_TYPE_PointerTocstr__KeyPairType (712) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocstr__KeyPairType(struct soap*, cstr__KeyPairType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocstr__KeyPairType(struct soap*, cstr__KeyPairType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocstr__KeyPairType(struct soap*, const char *, int, cstr__KeyPairType *const*, const char *); +SOAP_FMAC3 cstr__KeyPairType ** SOAP_FMAC4 soap_get_PointerTocstr__KeyPairType(struct soap*, cstr__KeyPairType **, const char*, const char*); +SOAP_FMAC3 cstr__KeyPairType ** SOAP_FMAC4 soap_in_PointerTocstr__KeyPairType(struct soap*, const char*, cstr__KeyPairType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__GlobalPowerPolicyType +#define SOAP_TYPE_PointerTosai__GlobalPowerPolicyType (711) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__GlobalPowerPolicyType(struct soap*, sai__GlobalPowerPolicyType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__GlobalPowerPolicyType(struct soap*, sai__GlobalPowerPolicyType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__GlobalPowerPolicyType(struct soap*, const char *, int, sai__GlobalPowerPolicyType *const*, const char *); +SOAP_FMAC3 sai__GlobalPowerPolicyType ** SOAP_FMAC4 soap_get_PointerTosai__GlobalPowerPolicyType(struct soap*, sai__GlobalPowerPolicyType **, const char*, const char*); +SOAP_FMAC3 sai__GlobalPowerPolicyType ** SOAP_FMAC4 soap_in_PointerTosai__GlobalPowerPolicyType(struct soap*, const char*, sai__GlobalPowerPolicyType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__EnvironmentDetectionType +#define SOAP_TYPE_PointerTosai__EnvironmentDetectionType (709) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__EnvironmentDetectionType(struct soap*, sai__EnvironmentDetectionType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__EnvironmentDetectionType(struct soap*, sai__EnvironmentDetectionType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__EnvironmentDetectionType(struct soap*, const char *, int, sai__EnvironmentDetectionType *const*, const char *); +SOAP_FMAC3 sai__EnvironmentDetectionType ** SOAP_FMAC4 soap_get_PointerTosai__EnvironmentDetectionType(struct soap*, sai__EnvironmentDetectionType **, const char*, const char*); +SOAP_FMAC3 sai__EnvironmentDetectionType ** SOAP_FMAC4 soap_in_PointerTosai__EnvironmentDetectionType(struct soap*, const char*, sai__EnvironmentDetectionType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__ProvisioningAuditRecordType +#define SOAP_TYPE_PointerTosai__ProvisioningAuditRecordType (708) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__ProvisioningAuditRecordType(struct soap*, sai__ProvisioningAuditRecordType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__ProvisioningAuditRecordType(struct soap*, sai__ProvisioningAuditRecordType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__ProvisioningAuditRecordType(struct soap*, const char *, int, sai__ProvisioningAuditRecordType *const*, const char *); +SOAP_FMAC3 sai__ProvisioningAuditRecordType ** SOAP_FMAC4 soap_get_PointerTosai__ProvisioningAuditRecordType(struct soap*, sai__ProvisioningAuditRecordType **, const char*, const char*); +SOAP_FMAC3 sai__ProvisioningAuditRecordType ** SOAP_FMAC4 soap_in_PointerTosai__ProvisioningAuditRecordType(struct soap*, const char*, sai__ProvisioningAuditRecordType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__CertHashEntryType +#define SOAP_TYPE_PointerTosai__CertHashEntryType (707) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CertHashEntryType(struct soap*, sai__CertHashEntryType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CertHashEntryType(struct soap*, sai__CertHashEntryType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CertHashEntryType(struct soap*, const char *, int, sai__CertHashEntryType *const*, const char *); +SOAP_FMAC3 sai__CertHashEntryType ** SOAP_FMAC4 soap_get_PointerTosai__CertHashEntryType(struct soap*, sai__CertHashEntryType **, const char*, const char*); +SOAP_FMAC3 sai__CertHashEntryType ** SOAP_FMAC4 soap_in_PointerTosai__CertHashEntryType(struct soap*, const char*, sai__CertHashEntryType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__ProvisioningOTPType +#define SOAP_TYPE_PointerTosai__ProvisioningOTPType (706) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__ProvisioningOTPType(struct soap*, xsd__base64Binary *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__ProvisioningOTPType(struct soap*, xsd__base64Binary *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__ProvisioningOTPType(struct soap*, const char *, int, xsd__base64Binary *const*, const char *); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerTosai__ProvisioningOTPType(struct soap*, xsd__base64Binary **, const char*, const char*); +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerTosai__ProvisioningOTPType(struct soap*, const char*, xsd__base64Binary **, const char*); + +#ifndef SOAP_TYPE_PointerTounsignedShort +#define SOAP_TYPE_PointerTounsignedShort (705) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTounsignedShort(struct soap*, unsigned short *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTounsignedShort(struct soap*, unsigned short *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTounsignedShort(struct soap*, const char *, int, unsigned short *const*, const char *); +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_get_PointerTounsignedShort(struct soap*, unsigned short **, const char*, const char*); +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_in_PointerTounsignedShort(struct soap*, const char*, unsigned short **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__PowerStateType +#define SOAP_TYPE_PointerTosai__PowerStateType (704) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__PowerStateType(struct soap*, enum sai__PowerStateType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__PowerStateType(struct soap*, enum sai__PowerStateType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__PowerStateType(struct soap*, const char *, int, enum sai__PowerStateType *const*, const char *); +SOAP_FMAC3 enum sai__PowerStateType ** SOAP_FMAC4 soap_get_PointerTosai__PowerStateType(struct soap*, enum sai__PowerStateType **, const char*, const char*); +SOAP_FMAC3 enum sai__PowerStateType ** SOAP_FMAC4 soap_in_PointerTosai__PowerStateType(struct soap*, const char*, enum sai__PowerStateType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__PkiCapsType +#define SOAP_TYPE_PointerTosai__PkiCapsType (703) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__PkiCapsType(struct soap*, sai__PkiCapsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__PkiCapsType(struct soap*, sai__PkiCapsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__PkiCapsType(struct soap*, const char *, int, sai__PkiCapsType *const*, const char *); +SOAP_FMAC3 sai__PkiCapsType ** SOAP_FMAC4 soap_get_PointerTosai__PkiCapsType(struct soap*, sai__PkiCapsType **, const char*, const char*); +SOAP_FMAC3 sai__PkiCapsType ** SOAP_FMAC4 soap_in_PointerTosai__PkiCapsType(struct soap*, const char*, sai__PkiCapsType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__CrlType +#define SOAP_TYPE_PointerTosai__CrlType (701) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CrlType(struct soap*, sai__CrlType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CrlType(struct soap*, sai__CrlType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CrlType(struct soap*, const char *, int, sai__CrlType *const*, const char *); +SOAP_FMAC3 sai__CrlType ** SOAP_FMAC4 soap_get_PointerTosai__CrlType(struct soap*, sai__CrlType **, const char*, const char*); +SOAP_FMAC3 sai__CrlType ** SOAP_FMAC4 soap_in_PointerTosai__CrlType(struct soap*, const char*, sai__CrlType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__CertificateType +#define SOAP_TYPE_PointerTosai__CertificateType (699) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CertificateType(struct soap*, sai__CertificateType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CertificateType(struct soap*, sai__CertificateType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CertificateType(struct soap*, const char *, int, sai__CertificateType *const*, const char *); +SOAP_FMAC3 sai__CertificateType ** SOAP_FMAC4 soap_get_PointerTosai__CertificateType(struct soap*, sai__CertificateType **, const char*, const char*); +SOAP_FMAC3 sai__CertificateType ** SOAP_FMAC4 soap_in_PointerTosai__CertificateType(struct soap*, const char*, sai__CertificateType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__TlsOptionsType +#define SOAP_TYPE_PointerTosai__TlsOptionsType (697) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__TlsOptionsType(struct soap*, sai__TlsOptionsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__TlsOptionsType(struct soap*, sai__TlsOptionsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__TlsOptionsType(struct soap*, const char *, int, sai__TlsOptionsType *const*, const char *); +SOAP_FMAC3 sai__TlsOptionsType ** SOAP_FMAC4 soap_get_PointerTosai__TlsOptionsType(struct soap*, sai__TlsOptionsType **, const char*, const char*); +SOAP_FMAC3 sai__TlsOptionsType ** SOAP_FMAC4 soap_in_PointerTosai__TlsOptionsType(struct soap*, const char*, sai__TlsOptionsType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__KerberosOptionsType +#define SOAP_TYPE_PointerTosai__KerberosOptionsType (695) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__KerberosOptionsType(struct soap*, sai__KerberosOptionsType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__KerberosOptionsType(struct soap*, sai__KerberosOptionsType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__KerberosOptionsType(struct soap*, const char *, int, sai__KerberosOptionsType *const*, const char *); +SOAP_FMAC3 sai__KerberosOptionsType ** SOAP_FMAC4 soap_get_PointerTosai__KerberosOptionsType(struct soap*, sai__KerberosOptionsType **, const char*, const char*); +SOAP_FMAC3 sai__KerberosOptionsType ** SOAP_FMAC4 soap_in_PointerTosai__KerberosOptionsType(struct soap*, const char*, sai__KerberosOptionsType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__AdminAclEntryExType +#define SOAP_TYPE_PointerTosai__AdminAclEntryExType (694) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__AdminAclEntryExType(struct soap*, sai__AdminAclEntryExType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__AdminAclEntryExType(struct soap*, sai__AdminAclEntryExType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__AdminAclEntryExType(struct soap*, const char *, int, sai__AdminAclEntryExType *const*, const char *); +SOAP_FMAC3 sai__AdminAclEntryExType ** SOAP_FMAC4 soap_get_PointerTosai__AdminAclEntryExType(struct soap*, sai__AdminAclEntryExType **, const char*, const char*); +SOAP_FMAC3 sai__AdminAclEntryExType ** SOAP_FMAC4 soap_in_PointerTosai__AdminAclEntryExType(struct soap*, const char*, sai__AdminAclEntryExType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__UserAclEntryExType +#define SOAP_TYPE_PointerTosai__UserAclEntryExType (693) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserAclEntryExType(struct soap*, sai__UserAclEntryExType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserAclEntryExType(struct soap*, sai__UserAclEntryExType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserAclEntryExType(struct soap*, const char *, int, sai__UserAclEntryExType *const*, const char *); +SOAP_FMAC3 sai__UserAclEntryExType ** SOAP_FMAC4 soap_get_PointerTosai__UserAclEntryExType(struct soap*, sai__UserAclEntryExType **, const char*, const char*); +SOAP_FMAC3 sai__UserAclEntryExType ** SOAP_FMAC4 soap_in_PointerTosai__UserAclEntryExType(struct soap*, const char*, sai__UserAclEntryExType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__UpdateCoreUrlKeyType +#define SOAP_TYPE_PointerTosai__UpdateCoreUrlKeyType (692) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UpdateCoreUrlKeyType(struct soap*, sai__UpdateCoreUrlKeyType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UpdateCoreUrlKeyType(struct soap*, sai__UpdateCoreUrlKeyType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UpdateCoreUrlKeyType(struct soap*, const char *, int, sai__UpdateCoreUrlKeyType *const*, const char *); +SOAP_FMAC3 sai__UpdateCoreUrlKeyType ** SOAP_FMAC4 soap_get_PointerTosai__UpdateCoreUrlKeyType(struct soap*, sai__UpdateCoreUrlKeyType **, const char*, const char*); +SOAP_FMAC3 sai__UpdateCoreUrlKeyType ** SOAP_FMAC4 soap_in_PointerTosai__UpdateCoreUrlKeyType(struct soap*, const char*, sai__UpdateCoreUrlKeyType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__AmtVersion +#define SOAP_TYPE_PointerTosai__AmtVersion (691) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__AmtVersion(struct soap*, sai__AmtVersion *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__AmtVersion(struct soap*, sai__AmtVersion *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__AmtVersion(struct soap*, const char *, int, sai__AmtVersion *const*, const char *); +SOAP_FMAC3 sai__AmtVersion ** SOAP_FMAC4 soap_get_PointerTosai__AmtVersion(struct soap*, sai__AmtVersion **, const char*, const char*); +SOAP_FMAC3 sai__AmtVersion ** SOAP_FMAC4 soap_in_PointerTosai__AmtVersion(struct soap*, const char*, sai__AmtVersion **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__RngKeyType +#define SOAP_TYPE_PointerTosai__RngKeyType (690) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__RngKeyType(struct soap*, sai__RngKeyType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__RngKeyType(struct soap*, sai__RngKeyType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__RngKeyType(struct soap*, const char *, int, sai__RngKeyType *const*, const char *); +SOAP_FMAC3 sai__RngKeyType ** SOAP_FMAC4 soap_get_PointerTosai__RngKeyType(struct soap*, sai__RngKeyType **, const char*, const char*); +SOAP_FMAC3 sai__RngKeyType ** SOAP_FMAC4 soap_in_PointerTosai__RngKeyType(struct soap*, const char*, sai__RngKeyType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__CertificateChainType +#define SOAP_TYPE_PointerTosai__CertificateChainType (689) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CertificateChainType(struct soap*, sai__CertificateChainType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CertificateChainType(struct soap*, sai__CertificateChainType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CertificateChainType(struct soap*, const char *, int, sai__CertificateChainType *const*, const char *); +SOAP_FMAC3 sai__CertificateChainType ** SOAP_FMAC4 soap_get_PointerTosai__CertificateChainType(struct soap*, sai__CertificateChainType **, const char*, const char*); +SOAP_FMAC3 sai__CertificateChainType ** SOAP_FMAC4 soap_in_PointerTosai__CertificateChainType(struct soap*, const char*, sai__CertificateChainType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__RsaKeyType +#define SOAP_TYPE_PointerTosai__RsaKeyType (688) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__RsaKeyType(struct soap*, sai__RsaKeyType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__RsaKeyType(struct soap*, sai__RsaKeyType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__RsaKeyType(struct soap*, const char *, int, sai__RsaKeyType *const*, const char *); +SOAP_FMAC3 sai__RsaKeyType ** SOAP_FMAC4 soap_get_PointerTosai__RsaKeyType(struct soap*, sai__RsaKeyType **, const char*, const char*); +SOAP_FMAC3 sai__RsaKeyType ** SOAP_FMAC4 soap_in_PointerTosai__RsaKeyType(struct soap*, const char*, sai__RsaKeyType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__UserAclEntryHandleListType +#define SOAP_TYPE_PointerTosai__UserAclEntryHandleListType (687) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserAclEntryHandleListType(struct soap*, sai__UserAclEntryHandleListType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserAclEntryHandleListType(struct soap*, sai__UserAclEntryHandleListType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserAclEntryHandleListType(struct soap*, const char *, int, sai__UserAclEntryHandleListType *const*, const char *); +SOAP_FMAC3 sai__UserAclEntryHandleListType ** SOAP_FMAC4 soap_get_PointerTosai__UserAclEntryHandleListType(struct soap*, sai__UserAclEntryHandleListType **, const char*, const char*); +SOAP_FMAC3 sai__UserAclEntryHandleListType ** SOAP_FMAC4 soap_in_PointerTosai__UserAclEntryHandleListType(struct soap*, const char*, sai__UserAclEntryHandleListType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__AdminAclEntryType +#define SOAP_TYPE_PointerTosai__AdminAclEntryType (686) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__AdminAclEntryType(struct soap*, sai__AdminAclEntryType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__AdminAclEntryType(struct soap*, sai__AdminAclEntryType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__AdminAclEntryType(struct soap*, const char *, int, sai__AdminAclEntryType *const*, const char *); +SOAP_FMAC3 sai__AdminAclEntryType ** SOAP_FMAC4 soap_get_PointerTosai__AdminAclEntryType(struct soap*, sai__AdminAclEntryType **, const char*, const char*); +SOAP_FMAC3 sai__AdminAclEntryType ** SOAP_FMAC4 soap_in_PointerTosai__AdminAclEntryType(struct soap*, const char*, sai__AdminAclEntryType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__UserAclEntryType +#define SOAP_TYPE_PointerTosai__UserAclEntryType (685) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserAclEntryType(struct soap*, sai__UserAclEntryType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserAclEntryType(struct soap*, sai__UserAclEntryType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserAclEntryType(struct soap*, const char *, int, sai__UserAclEntryType *const*, const char *); +SOAP_FMAC3 sai__UserAclEntryType ** SOAP_FMAC4 soap_get_PointerTosai__UserAclEntryType(struct soap*, sai__UserAclEntryType **, const char*, const char*); +SOAP_FMAC3 sai__UserAclEntryType ** SOAP_FMAC4 soap_in_PointerTosai__UserAclEntryType(struct soap*, const char*, sai__UserAclEntryType **, const char*); + +#ifndef SOAP_TYPE_PointerTounsignedInt +#define SOAP_TYPE_PointerTounsignedInt (684) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTounsignedInt(struct soap*, unsigned int *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTounsignedInt(struct soap*, unsigned int *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTounsignedInt(struct soap*, const char *, int, unsigned int *const*, const char *); +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_get_PointerTounsignedInt(struct soap*, unsigned int **, const char*, const char*); +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTounsignedInt(struct soap*, const char*, unsigned int **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__EnvironmentDetectionDomainType +#define SOAP_TYPE_PointerTosai__EnvironmentDetectionDomainType (683) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__EnvironmentDetectionDomainType(struct soap*, sai__EnvironmentDetectionDomainType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__EnvironmentDetectionDomainType(struct soap*, sai__EnvironmentDetectionDomainType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__EnvironmentDetectionDomainType(struct soap*, const char *, int, sai__EnvironmentDetectionDomainType *const*, const char *); +SOAP_FMAC3 sai__EnvironmentDetectionDomainType ** SOAP_FMAC4 soap_get_PointerTosai__EnvironmentDetectionDomainType(struct soap*, sai__EnvironmentDetectionDomainType **, const char*, const char*); +SOAP_FMAC3 sai__EnvironmentDetectionDomainType ** SOAP_FMAC4 soap_in_PointerTosai__EnvironmentDetectionDomainType(struct soap*, const char*, sai__EnvironmentDetectionDomainType **, const char*); + +#ifndef SOAP_TYPE_PointerTobool +#define SOAP_TYPE_PointerTobool (681) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTobool(struct soap*, bool *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTobool(struct soap*, bool *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTobool(struct soap*, const char *, int, bool *const*, const char *); +SOAP_FMAC3 bool ** SOAP_FMAC4 soap_get_PointerTobool(struct soap*, bool **, const char*, const char*); +SOAP_FMAC3 bool ** SOAP_FMAC4 soap_in_PointerTobool(struct soap*, const char*, bool **, const char*); + +#ifndef SOAP_TYPE_PointerTostd__string +#define SOAP_TYPE_PointerTostd__string (680) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostd__string(struct soap*, std::string *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostd__string(struct soap*, std::string *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostd__string(struct soap*, const char *, int, std::string *const*, const char *); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTostd__string(struct soap*, std::string **, const char*, const char*); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTostd__string(struct soap*, const char*, std::string **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__KerberosSpnType +#define SOAP_TYPE_PointerTosai__KerberosSpnType (675) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__KerberosSpnType(struct soap*, sai__KerberosSpnType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__KerberosSpnType(struct soap*, sai__KerberosSpnType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__KerberosSpnType(struct soap*, const char *, int, sai__KerberosSpnType *const*, const char *); +SOAP_FMAC3 sai__KerberosSpnType ** SOAP_FMAC4 soap_get_PointerTosai__KerberosSpnType(struct soap*, sai__KerberosSpnType **, const char*, const char*); +SOAP_FMAC3 sai__KerberosSpnType ** SOAP_FMAC4 soap_in_PointerTosai__KerberosSpnType(struct soap*, const char*, sai__KerberosSpnType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__UserEntryKerberosType +#define SOAP_TYPE_PointerTosai__UserEntryKerberosType (673) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserEntryKerberosType(struct soap*, sai__UserEntryKerberosType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserEntryKerberosType(struct soap*, sai__UserEntryKerberosType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserEntryKerberosType(struct soap*, const char *, int, sai__UserEntryKerberosType *const*, const char *); +SOAP_FMAC3 sai__UserEntryKerberosType ** SOAP_FMAC4 soap_get_PointerTosai__UserEntryKerberosType(struct soap*, sai__UserEntryKerberosType **, const char*, const char*); +SOAP_FMAC3 sai__UserEntryKerberosType ** SOAP_FMAC4 soap_in_PointerTosai__UserEntryKerberosType(struct soap*, const char*, sai__UserEntryKerberosType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__UserEntryDigestType +#define SOAP_TYPE_PointerTosai__UserEntryDigestType (672) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserEntryDigestType(struct soap*, sai__UserEntryDigestType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserEntryDigestType(struct soap*, sai__UserEntryDigestType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserEntryDigestType(struct soap*, const char *, int, sai__UserEntryDigestType *const*, const char *); +SOAP_FMAC3 sai__UserEntryDigestType ** SOAP_FMAC4 soap_get_PointerTosai__UserEntryDigestType(struct soap*, sai__UserEntryDigestType **, const char*, const char*); +SOAP_FMAC3 sai__UserEntryDigestType ** SOAP_FMAC4 soap_in_PointerTosai__UserEntryDigestType(struct soap*, const char*, sai__UserEntryDigestType **, const char*); + +#ifndef SOAP_TYPE_PointerTosai__UserAclRealmListType +#define SOAP_TYPE_PointerTosai__UserAclRealmListType (669) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserAclRealmListType(struct soap*, sai__UserAclRealmListType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserAclRealmListType(struct soap*, sai__UserAclRealmListType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserAclRealmListType(struct soap*, const char *, int, sai__UserAclRealmListType *const*, const char *); +SOAP_FMAC3 sai__UserAclRealmListType ** SOAP_FMAC4 soap_get_PointerTosai__UserAclRealmListType(struct soap*, sai__UserAclRealmListType **, const char*, const char*); +SOAP_FMAC3 sai__UserAclRealmListType ** SOAP_FMAC4 soap_in_PointerTosai__UserAclRealmListType(struct soap*, const char*, sai__UserAclRealmListType **, const char*); + +#ifndef SOAP_TYPE_PointerTocstr__RSAKeyPairType +#define SOAP_TYPE_PointerTocstr__RSAKeyPairType (667) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocstr__RSAKeyPairType(struct soap*, cstr__RSAKeyPairType *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocstr__RSAKeyPairType(struct soap*, cstr__RSAKeyPairType *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocstr__RSAKeyPairType(struct soap*, const char *, int, cstr__RSAKeyPairType *const*, const char *); +SOAP_FMAC3 cstr__RSAKeyPairType ** SOAP_FMAC4 soap_get_PointerTocstr__RSAKeyPairType(struct soap*, cstr__RSAKeyPairType **, const char*, const char*); +SOAP_FMAC3 cstr__RSAKeyPairType ** SOAP_FMAC4 soap_in_PointerTocstr__RSAKeyPairType(struct soap*, const char*, cstr__RSAKeyPairType **, const char*); + +#ifndef SOAP_TYPE_PointerTocmn__IPv6AddressStringType +#define SOAP_TYPE_PointerTocmn__IPv6AddressStringType (665) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__IPv6AddressStringType(struct soap*, std::string *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__IPv6AddressStringType(struct soap*, std::string *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__IPv6AddressStringType(struct soap*, const char *, int, std::string *const*, const char *); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTocmn__IPv6AddressStringType(struct soap*, std::string **, const char*, const char*); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTocmn__IPv6AddressStringType(struct soap*, const char*, std::string **, const char*); + +#ifndef SOAP_TYPE_PointerTocmn__IPv4AddressStringType +#define SOAP_TYPE_PointerTocmn__IPv4AddressStringType (664) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__IPv4AddressStringType(struct soap*, std::string *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__IPv4AddressStringType(struct soap*, std::string *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__IPv4AddressStringType(struct soap*, const char *, int, std::string *const*, const char *); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTocmn__IPv4AddressStringType(struct soap*, std::string **, const char*, const char*); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTocmn__IPv4AddressStringType(struct soap*, const char*, std::string **, const char*); + +#ifndef SOAP_TYPE_PointerTocmn__HostNameType +#define SOAP_TYPE_PointerTocmn__HostNameType (663) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__HostNameType(struct soap*, std::string *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__HostNameType(struct soap*, std::string *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__HostNameType(struct soap*, const char *, int, std::string *const*, const char *); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTocmn__HostNameType(struct soap*, std::string **, const char*, const char*); +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTocmn__HostNameType(struct soap*, const char*, std::string **, const char*); + +#ifndef SOAP_TYPE_PointerTounsignedByte +#define SOAP_TYPE_PointerTounsignedByte (12) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTounsignedByte(struct soap*, unsigned char *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTounsignedByte(struct soap*, unsigned char *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTounsignedByte(struct soap*, const char *, int, unsigned char *const*, const char *); +SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_get_PointerTounsignedByte(struct soap*, unsigned char **, const char*, const char*); +SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_in_PointerTounsignedByte(struct soap*, const char*, unsigned char **, const char*); + +#ifndef SOAP_TYPE__QName +#define SOAP_TYPE__QName (5) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default__QName(struct soap*, char **); +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap*, char *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap*, char *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap*, const char*, int, char*const*, const char*); +SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap*, char **, const char*, const char*); +SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap*, const char*, char **, const char*); + +#ifndef SOAP_TYPE_string +#define SOAP_TYPE_string (3) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap*, char **); +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap*, char *const*); +SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap*, char *const*, const char*, const char*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap*, const char*, int, char*const*, const char*); +SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap*, char **, const char*, const char*); +SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap*, const char*, char **, const char*); + +#ifndef SOAP_TYPE_std__vectorTemplateOfwcxs__ProfileNameType +#define SOAP_TYPE_std__vectorTemplateOfwcxs__ProfileNameType (862) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfwcxs__ProfileNameType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfwcxs__ProfileNameType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfwcxs__ProfileNameType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfwcxs__ProfileNameType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfwcxs__ProfileNameType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfwcxs__ProfileNameType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfwcxs__ProfileNameType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfwcxs__ProfileNameType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfwcxs__FeatureType +#define SOAP_TYPE_std__vectorTemplateOfwcxs__FeatureType (860) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfwcxs__FeatureType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfwcxs__FeatureType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfwcxs__FeatureType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfwcxs__FeatureType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfwcxs__FeatureType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfwcxs__FeatureType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfwcxs__FeatureType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfwcxs__FeatureType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType +#define SOAP_TYPE_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType (833) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfinf__EnabledInterfacesType +#define SOAP_TYPE_std__vectorTemplateOfinf__EnabledInterfacesType (831) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerToinf__FirmwareVersionType +#define SOAP_TYPE_std__vectorTemplateOfPointerToinf__FirmwareVersionType (830) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType +#define SOAP_TYPE_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType (828) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType +#define SOAP_TYPE_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType (824) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType +#define SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType (822) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType +#define SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType (820) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfunsignedShort +#define SOAP_TYPE_std__vectorTemplateOfunsignedShort (814) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfunsignedShort(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfunsignedShort(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfunsignedShort(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfunsignedShort(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfunsignedShort(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfunsignedShort(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfunsignedShort(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfunsignedShort(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerTohwa__AssetDataType +#define SOAP_TYPE_std__vectorTemplateOfPointerTohwa__AssetDataType (811) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfhwa__AssetTypeType +#define SOAP_TYPE_std__vectorTemplateOfhwa__AssetTypeType (809) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfhwa__AssetTypeType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfhwa__AssetTypeType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfhwa__AssetTypeType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfhwa__AssetTypeType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfhwa__AssetTypeType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfhwa__AssetTypeType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfhwa__AssetTypeType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfhwa__AssetTypeType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType +#define SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType (804) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType +#define SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType (802) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType +#define SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType (800) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType +#define SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType (797) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType +#define SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType (795) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfemi__AlertAuthOptionsType +#define SOAP_TYPE_std__vectorTemplateOfemi__AlertAuthOptionsType (758) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfemi__SensorHandleType +#define SOAP_TYPE_std__vectorTemplateOfemi__SensorHandleType (753) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__SensorHandleType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__SensorHandleType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__SensorHandleType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__SensorHandleType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__SensorHandleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__SensorHandleType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__SensorHandleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__SensorHandleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerToemi__EventLogRecordType +#define SOAP_TYPE_std__vectorTemplateOfPointerToemi__EventLogRecordType (752) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfemi__EventFilterHandleType +#define SOAP_TYPE_std__vectorTemplateOfemi__EventFilterHandleType (750) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__EventFilterHandleType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__EventFilterHandleType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__EventFilterHandleType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__EventFilterHandleType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__EventFilterHandleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__EventFilterHandleType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__EventFilterHandleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__EventFilterHandleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionHandleType +#define SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionHandleType (749) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType +#define SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType (747) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfstra__StorageApplicationHandleType +#define SOAP_TYPE_std__vectorTemplateOfstra__StorageApplicationHandleType (737) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfunsignedByte +#define SOAP_TYPE_std__vectorTemplateOfunsignedByte (736) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfunsignedByte(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfunsignedByte(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfunsignedByte(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfunsignedByte(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfunsignedByte(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfunsignedByte(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfunsignedByte(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfunsignedByte(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfstra__StorageAllocEntryHandleType +#define SOAP_TYPE_std__vectorTemplateOfstra__StorageAllocEntryHandleType (735) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfstra__StorageEaclEntryHandleType +#define SOAP_TYPE_std__vectorTemplateOfstra__StorageEaclEntryHandleType (733) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfnet__InterfaceHandleType +#define SOAP_TYPE_std__vectorTemplateOfnet__InterfaceHandleType (729) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfnet__InterfaceHandleType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfnet__InterfaceHandleType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfnet__InterfaceHandleType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfnet__InterfaceHandleType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfnet__InterfaceHandleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfnet__InterfaceHandleType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfnet__InterfaceHandleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfnet__InterfaceHandleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfcmn__GuidBuf +#define SOAP_TYPE_std__vectorTemplateOfcmn__GuidBuf (710) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfcmn__GuidBuf(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfcmn__GuidBuf(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfcmn__GuidBuf(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfcmn__GuidBuf(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfcmn__GuidBuf(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfcmn__GuidBuf(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfcmn__GuidBuf(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfcmn__GuidBuf(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerTosai__CrlType +#define SOAP_TYPE_std__vectorTemplateOfPointerTosai__CrlType (702) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTosai__CrlType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTosai__CrlType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTosai__CrlType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTosai__CrlType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTosai__CrlType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTosai__CrlType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTosai__CrlType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTosai__CrlType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfsai__CertificateHandleType +#define SOAP_TYPE_std__vectorTemplateOfsai__CertificateHandleType (700) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfsai__CertificateHandleType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfsai__CertificateHandleType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfsai__CertificateHandleType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfsai__CertificateHandleType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfsai__CertificateHandleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfsai__CertificateHandleType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfsai__CertificateHandleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfsai__CertificateHandleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerTosai__TlsOptionsType +#define SOAP_TYPE_std__vectorTemplateOfPointerTosai__TlsOptionsType (698) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfsai__EnabledInterfacesType +#define SOAP_TYPE_std__vectorTemplateOfsai__EnabledInterfacesType (696) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfstd__string +#define SOAP_TYPE_std__vectorTemplateOfstd__string (682) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfstd__string(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfstd__string(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfstd__string(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfstd__string(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfstd__string(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfstd__string(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfstd__string(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfstd__string(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfunsignedInt +#define SOAP_TYPE_std__vectorTemplateOfunsignedInt (678) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfunsignedInt(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfunsignedInt(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfunsignedInt(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfunsignedInt(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfunsignedInt(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfunsignedInt(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfunsignedInt(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfunsignedInt(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfxsd__base64Binary +#define SOAP_TYPE_std__vectorTemplateOfxsd__base64Binary (677) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfxsd__base64Binary(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfxsd__base64Binary(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfxsd__base64Binary(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfxsd__base64Binary(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfxsd__base64Binary(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfxsd__base64Binary(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfxsd__base64Binary(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfxsd__base64Binary(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfPointerTosai__KerberosSpnType +#define SOAP_TYPE_std__vectorTemplateOfPointerTosai__KerberosSpnType (676) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfsai__UserAclRealmType +#define SOAP_TYPE_std__vectorTemplateOfsai__UserAclRealmType (671) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfsai__UserAclRealmType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfsai__UserAclRealmType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfsai__UserAclRealmType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfsai__UserAclRealmType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfsai__UserAclRealmType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfsai__UserAclRealmType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfsai__UserAclRealmType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfsai__UserAclRealmType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#ifndef SOAP_TYPE_std__vectorTemplateOfsai__UserAclEntryHandleType +#define SOAP_TYPE_std__vectorTemplateOfsai__UserAclEntryHandleType (670) +#endif +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap*, const std::vector*); +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap*, std::vector*); +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap*, const char*, int, const std::vector*, const char*); +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap*, const char*, std::vector*, const char*); +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap*, int); +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap*, std::vector*); +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap*, int, const char*, const char*, size_t*); +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap*, int, int, void*, size_t, const void*, size_t); + +#endif + +/* End of soapH.h */ diff --git a/pcucontrol/models/intelamt/Include/soapStub.h b/pcucontrol/models/intelamt/Include/soapStub.h new file mode 100644 index 0000000..d6566e5 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/soapStub.h @@ -0,0 +1,15001 @@ +/* soapStub.h + Generated by gSOAP 2.7.8c from ../../Samples/gSoapGeneratedCode/AmtWsdlInterface.h + Copyright (C) 2000-2006, Robert van Engelen, Genivia Inc. All Rights Reserved. + This part of the software is released under one of the following licenses: + GPL, the gSOAP public license, or Genivia's license for commercial use. +*/ + +#ifndef soapStub_H +#define soapStub_H +#include +#include "stdsoap2.h" + +/******************************************************************************\ + * * + * Enumerations * + * * +\******************************************************************************/ + + +#ifndef SOAP_TYPE_sai__UserAclRealmType +#define SOAP_TYPE_sai__UserAclRealmType (552) +/* sai:UserAclRealmType */ +enum sai__UserAclRealmType {sai__UserAclRealmType__0 = 0, sai__UserAclRealmType__1 = 1, sai__UserAclRealmType__2 = 2, sai__UserAclRealmType__3 = 3, sai__UserAclRealmType__4 = 4, sai__UserAclRealmType__5 = 5, sai__UserAclRealmType__6 = 6, sai__UserAclRealmType__7 = 7, sai__UserAclRealmType__8 = 8, sai__UserAclRealmType__9 = 9, sai__UserAclRealmType__10 = 10, sai__UserAclRealmType__11 = 11, sai__UserAclRealmType__12 = 12, sai__UserAclRealmType__13 = 13, sai__UserAclRealmType__14 = 14, sai__UserAclRealmType__15 = 15, sai__UserAclRealmType__16 = 16, sai__UserAclRealmType__17 = 17, sai__UserAclRealmType__18 = 18, sai__UserAclRealmType__19 = 19}; +#endif + +#ifndef SOAP_TYPE_sai__RsaKeyEncodingType +#define SOAP_TYPE_sai__RsaKeyEncodingType (557) +/* sai:RsaKeyEncodingType */ +enum sai__RsaKeyEncodingType {sai__RsaKeyEncodingType__30 = 30, sai__RsaKeyEncodingType__31 = 31}; +#endif + +#ifndef SOAP_TYPE_sai__RsaCertificateEncodingType +#define SOAP_TYPE_sai__RsaCertificateEncodingType (558) +/* sai:RsaCertificateEncodingType */ +enum sai__RsaCertificateEncodingType {sai__RsaCertificateEncodingType__10 = 10, sai__RsaCertificateEncodingType__11 = 11}; +#endif + +#ifndef SOAP_TYPE_sai__RngKeyEncodingType +#define SOAP_TYPE_sai__RngKeyEncodingType (559) +/* sai:RngKeyEncodingType */ +enum sai__RngKeyEncodingType {sai__RngKeyEncodingType__20 = 20, sai__RngKeyEncodingType__21 = 21}; +#endif + +#ifndef SOAP_TYPE_sai__ProvisioningModeType +#define SOAP_TYPE_sai__ProvisioningModeType (560) +/* sai:ProvisioningModeType */ +enum sai__ProvisioningModeType {sai__ProvisioningModeType__0 = 0, sai__ProvisioningModeType__1 = 1, sai__ProvisioningModeType__2 = 2}; +#endif + +#ifndef SOAP_TYPE_sai__AccessPermissionType +#define SOAP_TYPE_sai__AccessPermissionType (561) +/* sai:AccessPermissionType */ +enum sai__AccessPermissionType {sai__AccessPermissionType__LocalAccessPermission = 0, sai__AccessPermissionType__NetworkAccessPermission = 1, sai__AccessPermissionType__AnyAccessPermission = 2}; +#endif + +#ifndef SOAP_TYPE_sai__KerberosSpnProtocolType +#define SOAP_TYPE_sai__KerberosSpnProtocolType (562) +/* sai:KerberosSpnProtocolType */ +enum sai__KerberosSpnProtocolType {sai__KerberosSpnProtocolType__HTTP = 0, sai__KerberosSpnProtocolType__HTTPS = 1, sai__KerberosSpnProtocolType__SOL_USCOREIDER = 2, sai__KerberosSpnProtocolType__SOL_USCOREIDER_USCORESSL = 3}; +#endif + +#ifndef SOAP_TYPE_sai__KerberosEncryptionType +#define SOAP_TYPE_sai__KerberosEncryptionType (563) +/* sai:KerberosEncryptionType */ +enum sai__KerberosEncryptionType {sai__KerberosEncryptionType__HMAC_USCORERC4 = 0}; +#endif + +#ifndef SOAP_TYPE_sai__PowerStateType +#define SOAP_TYPE_sai__PowerStateType (564) +/* sai:PowerStateType */ +enum sai__PowerStateType {sai__PowerStateType__PowerStateS0 = 0, sai__PowerStateType__PowerStateS1 = 1, sai__PowerStateType__PowerStateS2 = 2, sai__PowerStateType__PowerStateS3 = 3, sai__PowerStateType__PowerStateS4 = 4, sai__PowerStateType__PowerStateS5 = 5}; +#endif + +#ifndef SOAP_TYPE_sai__EnabledInterfacesType +#define SOAP_TYPE_sai__EnabledInterfacesType (565) +/* sai:EnabledInterfacesType */ +enum sai__EnabledInterfacesType {sai__EnabledInterfacesType__WebUI = 0, sai__EnabledInterfacesType__SerialOverLAN = 1, sai__EnabledInterfacesType__IdeRedirection = 2}; +#endif + +#ifndef SOAP_TYPE_sai__InterfaceType +#define SOAP_TYPE_sai__InterfaceType (566) +/* sai:InterfaceType */ +enum sai__InterfaceType {sai__InterfaceType__NetworkInterface = 0, sai__InterfaceType__LocalHostInterface = 1}; +#endif + +#ifndef SOAP_TYPE_sai__TlsAthenticationType +#define SOAP_TYPE_sai__TlsAthenticationType (567) +/* sai:TlsAthenticationType */ +enum sai__TlsAthenticationType {sai__TlsAthenticationType__NoAuth = 0, sai__TlsAthenticationType__ServerAuth = 1, sai__TlsAthenticationType__MutualAuth = 2}; +#endif + +#ifndef SOAP_TYPE_sai__ProvisioningTLSModeType +#define SOAP_TYPE_sai__ProvisioningTLSModeType (569) +/* sai:ProvisioningTLSModeType */ +enum sai__ProvisioningTLSModeType {sai__ProvisioningTLSModeType__0 = 0, sai__ProvisioningTLSModeType__1 = 1, sai__ProvisioningTLSModeType__2 = 2}; +#endif + +#ifndef SOAP_TYPE_sai__HashTypeType +#define SOAP_TYPE_sai__HashTypeType (573) +/* sai:HashTypeType */ +enum sai__HashTypeType {sai__HashTypeType__1 = 1}; +#endif + +#ifndef SOAP_TYPE_sai__HTTPAuthOptionType +#define SOAP_TYPE_sai__HTTPAuthOptionType (574) +/* sai:HTTPAuthOptionType */ +enum sai__HTTPAuthOptionType {sai__HTTPAuthOptionType__NoAuth = 0, sai__HTTPAuthOptionType__Auth = 1, sai__HTTPAuthOptionType__Disable = 2}; +#endif + +#ifndef SOAP_TYPE_xcfg__CertNameOptionsType +#define SOAP_TYPE_xcfg__CertNameOptionsType (577) +/* xcfg:CertNameOptionsType */ +enum xcfg__CertNameOptionsType {xcfg__CertNameOptionsType__CertNameMatch = 0, xcfg__CertNameOptionsType__DomainSuffixMatch = 1}; +#endif + +#ifndef SOAP_TYPE_net__DhcpModeType +#define SOAP_TYPE_net__DhcpModeType (580) +/* net:DhcpModeType */ +enum net__DhcpModeType {net__DhcpModeType__0 = 0, net__DhcpModeType__1 = 1, net__DhcpModeType__2 = 2}; +#endif + +#ifndef SOAP_TYPE_net__InterfaceModeType +#define SOAP_TYPE_net__InterfaceModeType (582) +/* net:InterfaceModeType */ +enum net__InterfaceModeType {net__InterfaceModeType__SEPARATE_USCOREMAC_USCOREADDRESS = 0, net__InterfaceModeType__SHARED_USCOREMAC_USCOREADDRESS = 1}; +#endif + +#ifndef SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE +#define SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE (587) +/* stra:ISVS_APP_ATTR_TYPE */ +enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE {stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE__0 = 0, stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE__1 = 1}; +#endif + +#ifndef SOAP_TYPE_emi__EventSeverityType +#define SOAP_TYPE_emi__EventSeverityType (594) +/* emi:EventSeverityType */ +enum emi__EventSeverityType {emi__EventSeverityType__0 = 0, emi__EventSeverityType__1 = 1, emi__EventSeverityType__2 = 2, emi__EventSeverityType__4 = 4, emi__EventSeverityType__8 = 8, emi__EventSeverityType__16 = 16, emi__EventSeverityType__32 = 32}; +#endif + +#ifndef SOAP_TYPE_emi__AlertAuthOptionsType +#define SOAP_TYPE_emi__AlertAuthOptionsType (598) +/* emi:AlertAuthOptionsType */ +enum emi__AlertAuthOptionsType {emi__AlertAuthOptionsType__Kerberos = 0, emi__AlertAuthOptionsType__Digest = 1, emi__AlertAuthOptionsType__Basic = 2}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterDirectionType +#define SOAP_TYPE_cb__CircuitBreakerFilterDirectionType (604) +/* cb:CircuitBreakerFilterDirectionType */ +enum cb__CircuitBreakerFilterDirectionType {cb__CircuitBreakerFilterDirectionType__0 = 0, cb__CircuitBreakerFilterDirectionType__1 = 1}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType +#define SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType (605) +/* cb:CircuitBreakerFilterIPAddressDirectionType */ +enum cb__CircuitBreakerFilterIPAddressDirectionType {cb__CircuitBreakerFilterIPAddressDirectionType__0 = 0, cb__CircuitBreakerFilterIPAddressDirectionType__1 = 1}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerProfileType +#define SOAP_TYPE_cb__CircuitBreakerProfileType (606) +/* cb:CircuitBreakerProfileType */ +enum cb__CircuitBreakerProfileType {cb__CircuitBreakerProfileType__0 = 0, cb__CircuitBreakerProfileType__1 = 1, cb__CircuitBreakerProfileType__2 = 2, cb__CircuitBreakerProfileType__3 = 3, cb__CircuitBreakerProfileType__4 = 4}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerApplicationType +#define SOAP_TYPE_cb__CircuitBreakerApplicationType (607) +/* cb:CircuitBreakerApplicationType */ +enum cb__CircuitBreakerApplicationType {cb__CircuitBreakerApplicationType__0 = 0, cb__CircuitBreakerApplicationType__1 = 1, cb__CircuitBreakerApplicationType__3 = 3, cb__CircuitBreakerApplicationType__4 = 4}; +#endif + +#ifndef SOAP_TYPE_cb__HcbStateType +#define SOAP_TYPE_cb__HcbStateType (608) +/* cb:HcbStateType */ +enum cb__HcbStateType {cb__HcbStateType__0 = 0, cb__HcbStateType__1 = 1, cb__HcbStateType__2 = 2, cb__HcbStateType__3 = 3}; +#endif + +#ifndef SOAP_TYPE_cb__HcbTriggerReasonType +#define SOAP_TYPE_cb__HcbTriggerReasonType (609) +/* cb:HcbTriggerReasonType */ +enum cb__HcbTriggerReasonType {cb__HcbTriggerReasonType__0 = 0, cb__HcbTriggerReasonType__1 = 1, cb__HcbTriggerReasonType__2 = 2}; +#endif + +#ifndef SOAP_TYPE_hwa__AssetTypeType +#define SOAP_TYPE_hwa__AssetTypeType (613) +/* hwa:AssetTypeType */ +enum hwa__AssetTypeType {hwa__AssetTypeType__2 = 2, hwa__AssetTypeType__3 = 3, hwa__AssetTypeType__4 = 4, hwa__AssetTypeType__5 = 5, hwa__AssetTypeType__6 = 6, hwa__AssetTypeType__7 = 7, hwa__AssetTypeType__8 = 8, hwa__AssetTypeType__9 = 9}; +#endif + +#ifndef SOAP_TYPE_apr__CbActionType +#define SOAP_TYPE_apr__CbActionType (626) +/* apr:CbActionType */ +enum apr__CbActionType {apr__CbActionType__0 = 0, apr__CbActionType__1 = 1}; +#endif + +#ifndef SOAP_TYPE_inf__ProvisioningModeType +#define SOAP_TYPE_inf__ProvisioningModeType (638) +/* inf:ProvisioningModeType */ +enum inf__ProvisioningModeType {inf__ProvisioningModeType__0 = 0, inf__ProvisioningModeType__1 = 1, inf__ProvisioningModeType__2 = 2}; +#endif + +#ifndef SOAP_TYPE_inf__ProvisioningStateType +#define SOAP_TYPE_inf__ProvisioningStateType (639) +/* inf:ProvisioningStateType */ +enum inf__ProvisioningStateType {inf__ProvisioningStateType__ProvisioningStatePre = 0, inf__ProvisioningStateType__ProvisioningStateIn = 1, inf__ProvisioningStateType__ProvisioningStatePost = 2}; +#endif + +#ifndef SOAP_TYPE_inf__PasswordModelType +#define SOAP_TYPE_inf__PasswordModelType (640) +/* inf:PasswordModelType */ +enum inf__PasswordModelType {inf__PasswordModelType__PasswordModelCoupled = 0, inf__PasswordModelType__PasswordModelSeperate = 1, inf__PasswordModelType__PasswordModelSeperateHash = 2}; +#endif + +#ifndef SOAP_TYPE_inf__EnabledInterfacesType +#define SOAP_TYPE_inf__EnabledInterfacesType (641) +/* inf:EnabledInterfacesType */ +enum inf__EnabledInterfacesType {inf__EnabledInterfacesType__WebUI = 0, inf__EnabledInterfacesType__SerialOverLAN = 1, inf__EnabledInterfacesType__IdeRedirection = 2}; +#endif + +#ifndef SOAP_TYPE_rci__RemoteControlCommandType +#define SOAP_TYPE_rci__RemoteControlCommandType (648) +/* rci:RemoteControlCommandType */ +enum rci__RemoteControlCommandType {rci__RemoteControlCommandType__16 = 16, rci__RemoteControlCommandType__17 = 17, rci__RemoteControlCommandType__18 = 18, rci__RemoteControlCommandType__19 = 19, rci__RemoteControlCommandType__33 = 33}; +#endif + +#ifndef SOAP_TYPE_rci__SpecialCommandType +#define SOAP_TYPE_rci__SpecialCommandType (649) +/* rci:SpecialCommandType */ +enum rci__SpecialCommandType {rci__SpecialCommandType__0 = 0, rci__SpecialCommandType__1 = 1, rci__SpecialCommandType__2 = 2, rci__SpecialCommandType__3 = 3, rci__SpecialCommandType__4 = 4, rci__SpecialCommandType__5 = 5, rci__SpecialCommandType__193 = 193}; +#endif + +#ifndef SOAP_TYPE_wcxs__KeyIndexType +#define SOAP_TYPE_wcxs__KeyIndexType (655) +/* wcxs:KeyIndexType */ +enum wcxs__KeyIndexType {wcxs__KeyIndexType__1 = 1, wcxs__KeyIndexType__2 = 2, wcxs__KeyIndexType__3 = 3, wcxs__KeyIndexType__4 = 4}; +#endif + +#ifndef SOAP_TYPE_wcxs__FeatureType +#define SOAP_TYPE_wcxs__FeatureType (662) +/* wcxs:FeatureType */ +enum wcxs__FeatureType {wcxs__FeatureType__802_x002e11a = 0, wcxs__FeatureType__802_x002e11b = 1, wcxs__FeatureType__802_x002e11g = 2, wcxs__FeatureType__802_x002e11n = 3}; +#endif + +/******************************************************************************\ + * * + * Classes and Structs * + * * +\******************************************************************************/ + + +#if 0 /* volatile type: do no redeclare */ + +#endif + + + +#ifndef SOAP_TYPE_xsd__base64Binary +#define SOAP_TYPE_xsd__base64Binary (9) +/* Base64 schema type: */ +class SOAP_CMAC xsd__base64Binary +{ +public: + unsigned char *__ptr; + int __size; + char *id; /* optional element of type xsd:string */ + char *type; /* optional element of type xsd:string */ + char *options; /* optional element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 9; } /* = unique id SOAP_TYPE_xsd__base64Binary */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xsd__base64Binary() : __ptr(NULL), id(NULL), type(NULL), options(NULL), soap(NULL) { } + virtual ~xsd__base64Binary() { } +}; +#endif + +#ifndef SOAP_TYPE__cmn__union_NodeAddressType +#define SOAP_TYPE__cmn__union_NodeAddressType (666) +/* xsd:choice */ +union _cmn__union_NodeAddressType +{ +#define SOAP_UNION__cmn__union_NodeAddressType_HostName (1) + std::string *HostName; +#define SOAP_UNION__cmn__union_NodeAddressType_IPv4Address (2) + std::string *IPv4Address; +#define SOAP_UNION__cmn__union_NodeAddressType_IPv6Address (3) + std::string *IPv6Address; +}; +#endif + +#ifndef SOAP_TYPE_cmn__NodeAddressType +#define SOAP_TYPE_cmn__NodeAddressType (16) +/* cmn:NodeAddressType */ +class SOAP_CMAC cmn__NodeAddressType +{ +public: + int __union_NodeAddressType; /* union discriminant (of union defined below) */ + union _cmn__union_NodeAddressType union_NodeAddressType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 16; } /* = unique id SOAP_TYPE_cmn__NodeAddressType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cmn__NodeAddressType() : soap(NULL) { } + virtual ~cmn__NodeAddressType() { } +}; +#endif + +#ifndef SOAP_TYPE_cstr__RSAKeyPairType +#define SOAP_TYPE_cstr__RSAKeyPairType (17) +/* cstr:RSAKeyPairType */ +class SOAP_CMAC cstr__RSAKeyPairType +{ +public: + xsd__base64Binary DERKey; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 17; } /* = unique id SOAP_TYPE_cstr__RSAKeyPairType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cstr__RSAKeyPairType() : soap(NULL) { } + virtual ~cstr__RSAKeyPairType() { } +}; +#endif + +#ifndef SOAP_TYPE__cstr__union_KeyPairType +#define SOAP_TYPE__cstr__union_KeyPairType (668) +/* xsd:choice */ +union _cstr__union_KeyPairType +{ +#define SOAP_UNION__cstr__union_KeyPairType_RSAKeyPair (1) + cstr__RSAKeyPairType *RSAKeyPair; +}; +#endif + +#ifndef SOAP_TYPE_cstr__KeyPairType +#define SOAP_TYPE_cstr__KeyPairType (18) +/* cstr:KeyPairType */ +class SOAP_CMAC cstr__KeyPairType +{ +public: + int __union_KeyPairType; /* union discriminant (of union defined below) */ + union _cstr__union_KeyPairType union_KeyPairType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 18; } /* = unique id SOAP_TYPE_cstr__KeyPairType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cstr__KeyPairType() : soap(NULL) { } + virtual ~cstr__KeyPairType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__UserAclEntryType +#define SOAP_TYPE_sai__UserAclEntryType (19) +/* sai:UserAclEntryType */ +class SOAP_CMAC sai__UserAclEntryType +{ +public: + std::string Username; /* required element of type sai:AclStringType */ + std::string Password; /* required element of type sai:AclPasswordStringType */ + class sai__UserAclRealmListType *Realms; /* required element of type sai:UserAclRealmListType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 19; } /* = unique id SOAP_TYPE_sai__UserAclEntryType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__UserAclEntryType() : Realms(NULL), soap(NULL) { } + virtual ~sai__UserAclEntryType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__AdminAclEntryType +#define SOAP_TYPE_sai__AdminAclEntryType (20) +/* sai:AdminAclEntryType */ +class SOAP_CMAC sai__AdminAclEntryType +{ +public: + std::string Username; /* required element of type sai:AclStringType */ + std::string Password; /* required element of type sai:AclPasswordStringType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 20; } /* = unique id SOAP_TYPE_sai__AdminAclEntryType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__AdminAclEntryType() : soap(NULL) { } + virtual ~sai__AdminAclEntryType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__UserAclEntryHandleListType +#define SOAP_TYPE_sai__UserAclEntryHandleListType (21) +/* sai:UserAclEntryHandleListType */ +class SOAP_CMAC sai__UserAclEntryHandleListType +{ +public: + std::vectorHandle; /* sequence of 0 to 7 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 21; } /* = unique id SOAP_TYPE_sai__UserAclEntryHandleListType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__UserAclEntryHandleListType() : soap(NULL) { } + virtual ~sai__UserAclEntryHandleListType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__UserAclRealmListType +#define SOAP_TYPE_sai__UserAclRealmListType (22) +/* sai:UserAclRealmListType */ +class SOAP_CMAC sai__UserAclRealmListType +{ +public: + std::vectorRealm; /* sequence of 0 to 16 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 22; } /* = unique id SOAP_TYPE_sai__UserAclRealmListType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__UserAclRealmListType() : soap(NULL) { } + virtual ~sai__UserAclRealmListType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__RsaKeyType +#define SOAP_TYPE_sai__RsaKeyType (23) +/* sai:RsaKeyType */ +class SOAP_CMAC sai__RsaKeyType +{ +public: + enum sai__RsaKeyEncodingType Encoding; /* required element of type sai:RsaKeyEncodingType */ + unsigned int Length; /* required element of type xsd:unsignedInt */ + xsd__base64Binary Value; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 23; } /* = unique id SOAP_TYPE_sai__RsaKeyType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__RsaKeyType() : soap(NULL) { } + virtual ~sai__RsaKeyType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__RngKeyType +#define SOAP_TYPE_sai__RngKeyType (24) +/* sai:RngKeyType */ +class SOAP_CMAC sai__RngKeyType +{ +public: + enum sai__RngKeyEncodingType Type; /* required element of type sai:RngKeyEncodingType */ + unsigned int Length; /* required element of type xsd:unsignedInt */ + xsd__base64Binary Data; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 24; } /* = unique id SOAP_TYPE_sai__RngKeyType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__RngKeyType() : soap(NULL) { } + virtual ~sai__RngKeyType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__CertificateChainType +#define SOAP_TYPE_sai__CertificateChainType (25) +/* sai:CertificateChainType */ +class SOAP_CMAC sai__CertificateChainType +{ +public: + enum sai__RsaCertificateEncodingType Encoding; /* required element of type sai:RsaCertificateEncodingType */ + unsigned int Length; /* required element of type xsd:unsignedInt */ + xsd__base64Binary Value; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 25; } /* = unique id SOAP_TYPE_sai__CertificateChainType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__CertificateChainType() : soap(NULL) { } + virtual ~sai__CertificateChainType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__UpdateCoreUrlKeyType +#define SOAP_TYPE_sai__UpdateCoreUrlKeyType (26) +/* sai:UpdateCoreUrlKeyType */ +class SOAP_CMAC sai__UpdateCoreUrlKeyType +{ +public: + unsigned int KeyLength; /* required element of type xsd:unsignedInt */ + unsigned int KeyAlgorithm; /* required element of type xsd:unsignedInt */ + xsd__base64Binary KeyData; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 26; } /* = unique id SOAP_TYPE_sai__UpdateCoreUrlKeyType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__UpdateCoreUrlKeyType() : soap(NULL) { } + virtual ~sai__UpdateCoreUrlKeyType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__AmtVersion +#define SOAP_TYPE_sai__AmtVersion (27) +/* sai:AmtVersion */ +class SOAP_CMAC sai__AmtVersion +{ +public: + unsigned char major; /* required element of type xsd:unsignedByte */ + unsigned char minor; /* required element of type xsd:unsignedByte */ + unsigned short micro; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 27; } /* = unique id SOAP_TYPE_sai__AmtVersion */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__AmtVersion() : soap(NULL) { } + virtual ~sai__AmtVersion() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__UserEntryDigestType +#define SOAP_TYPE_sai__UserEntryDigestType (28) +/* sai:UserEntryDigestType */ +class SOAP_CMAC sai__UserEntryDigestType +{ +public: + std::string Username; /* required element of type sai:AclStringType */ + xsd__base64Binary DigestPassword; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 28; } /* = unique id SOAP_TYPE_sai__UserEntryDigestType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__UserEntryDigestType() : soap(NULL) { } + virtual ~sai__UserEntryDigestType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__UserEntryKerberosType +#define SOAP_TYPE_sai__UserEntryKerberosType (29) +/* sai:UserEntryKerberosType */ +class SOAP_CMAC sai__UserEntryKerberosType +{ +public: + xsd__base64Binary Sid; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 29; } /* = unique id SOAP_TYPE_sai__UserEntryKerberosType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__UserEntryKerberosType() : soap(NULL) { } + virtual ~sai__UserEntryKerberosType() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__union_UserAclEntryExType +#define SOAP_TYPE__sai__union_UserAclEntryExType (674) +/* xsd:choice */ +union _sai__union_UserAclEntryExType +{ +#define SOAP_UNION__sai__union_UserAclEntryExType_DigestUser (1) + sai__UserEntryDigestType *DigestUser; +#define SOAP_UNION__sai__union_UserAclEntryExType_KerberosUser (2) + sai__UserEntryKerberosType *KerberosUser; +}; +#endif + +#ifndef SOAP_TYPE_sai__UserAclEntryExType +#define SOAP_TYPE_sai__UserAclEntryExType (30) +/* sai:UserAclEntryExType */ +class SOAP_CMAC sai__UserAclEntryExType +{ +public: + enum sai__AccessPermissionType AccessPermission; /* required element of type sai:AccessPermissionType */ + sai__UserAclRealmListType *Realms; /* required element of type sai:UserAclRealmListType */ + int __union_UserAclEntryExType; /* union discriminant (of union defined below) */ + union _sai__union_UserAclEntryExType union_UserAclEntryExType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 30; } /* = unique id SOAP_TYPE_sai__UserAclEntryExType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__UserAclEntryExType() : Realms(NULL), soap(NULL) { } + virtual ~sai__UserAclEntryExType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__AdminAclEntryExType +#define SOAP_TYPE_sai__AdminAclEntryExType (31) +/* sai:AdminAclEntryExType */ +class SOAP_CMAC sai__AdminAclEntryExType +{ +public: + std::string Username; /* required element of type sai:AclStringType */ + xsd__base64Binary DigestPassword; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 31; } /* = unique id SOAP_TYPE_sai__AdminAclEntryExType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__AdminAclEntryExType() : soap(NULL) { } + virtual ~sai__AdminAclEntryExType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__KerberosSpnType +#define SOAP_TYPE_sai__KerberosSpnType (32) +/* sai:KerberosSpnType */ +class SOAP_CMAC sai__KerberosSpnType +{ +public: + enum sai__KerberosSpnProtocolType SpnProtocolIndex; /* required element of type sai:KerberosSpnProtocolType */ + std::string SpnString; /* required element of type sai:SpnString */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 32; } /* = unique id SOAP_TYPE_sai__KerberosSpnType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__KerberosSpnType() : soap(NULL) { } + virtual ~sai__KerberosSpnType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__KerberosOptionsType +#define SOAP_TYPE_sai__KerberosOptionsType (33) +/* sai:KerberosOptionsType */ +class SOAP_CMAC sai__KerberosOptionsType +{ +public: + std::string KerberosRealmName; /* required element of type sai:KerberosRealmName */ + std::vectorKerberosSpn; /* sequence of 1 to 4 elements */ + unsigned int KerberosKeyVersion; /* required element of type xsd:unsignedInt */ + enum sai__KerberosEncryptionType KerberosEncryption; /* required element of type sai:KerberosEncryptionType */ + xsd__base64Binary KerberosMasterKey; /* required element of type xsd:base64Binary */ + unsigned int KerberosMaximumClockTolerance; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 33; } /* = unique id SOAP_TYPE_sai__KerberosOptionsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__KerberosOptionsType() : soap(NULL) { } + virtual ~sai__KerberosOptionsType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__TlsOptionsType +#define SOAP_TYPE_sai__TlsOptionsType (34) +/* sai:TlsOptionsType */ +class SOAP_CMAC sai__TlsOptionsType +{ +public: + enum sai__InterfaceType Interface; /* required element of type sai:InterfaceType */ + enum sai__TlsAthenticationType TlsAuthentication; /* required element of type sai:TlsAthenticationType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 34; } /* = unique id SOAP_TYPE_sai__TlsOptionsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__TlsOptionsType() : soap(NULL) { } + virtual ~sai__TlsOptionsType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__CertificateType +#define SOAP_TYPE_sai__CertificateType (35) +/* sai:CertificateType */ +class SOAP_CMAC sai__CertificateType +{ +public: + xsd__base64Binary X509cert; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 35; } /* = unique id SOAP_TYPE_sai__CertificateType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__CertificateType() : soap(NULL) { } + virtual ~sai__CertificateType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__CrlType +#define SOAP_TYPE_sai__CrlType (36) +/* sai:CrlType */ +class SOAP_CMAC sai__CrlType +{ +public: + std::string CrlUrl; /* required element of type xsd:string */ + std::vectorSerialNumber; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 36; } /* = unique id SOAP_TYPE_sai__CrlType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__CrlType() : soap(NULL) { } + virtual ~sai__CrlType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__PkiCapsType +#define SOAP_TYPE_sai__PkiCapsType (37) +/* sai:PkiCapsType */ +class SOAP_CMAC sai__PkiCapsType +{ +public: + unsigned int CrlStoreSize; /* required element of type xsd:unsignedInt */ + unsigned int RootCertMaxSize; /* required element of type xsd:unsignedInt */ + unsigned int RootCertMaxInstances; /* required element of type xsd:unsignedInt */ + unsigned int FqdnSuffixMaxEntries; /* required element of type xsd:unsignedInt */ + unsigned int FqdnSuffixMaxEntryLength; /* required element of type xsd:unsignedInt */ + unsigned int CertChainMaxSize; /* required element of type xsd:unsignedInt */ + std::vectorSupportedKeyLengths; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 37; } /* = unique id SOAP_TYPE_sai__PkiCapsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__PkiCapsType() : soap(NULL) { } + virtual ~sai__PkiCapsType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__CertHashEntryType +#define SOAP_TYPE_sai__CertHashEntryType (38) +/* sai:CertHashEntryType */ +class SOAP_CMAC sai__CertHashEntryType +{ +public: + bool Default; /* required element of type xsd:boolean */ + bool Active; /* required element of type xsd:boolean */ + enum sai__HashTypeType HashType; /* required element of type sai:HashTypeType */ + xsd__base64Binary Hash; /* required element of type xsd:base64Binary */ + std::string FriendlyName; /* required element of type sai:FriendlyNameType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 38; } /* = unique id SOAP_TYPE_sai__CertHashEntryType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__CertHashEntryType() : soap(NULL) { } + virtual ~sai__CertHashEntryType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__ProvisioningAuditRecordType +#define SOAP_TYPE_sai__ProvisioningAuditRecordType (39) +/* sai:ProvisioningAuditRecordType */ +class SOAP_CMAC sai__ProvisioningAuditRecordType +{ +public: + enum sai__ProvisioningTLSModeType ProvisioningTLSMode; /* required element of type sai:ProvisioningTLSModeType */ + bool SecureDNS; /* required element of type xsd:boolean */ + bool HostInitiated; /* required element of type xsd:boolean */ + std::string *ProvServerFQDN; /* optional element of type xsd:string */ + enum sai__HashTypeType SelectedHashType; /* required element of type sai:HashTypeType */ + xsd__base64Binary SelectedHashData; /* required element of type xsd:base64Binary */ + std::vectorCaCertSerials; /* optional element of type xsd:base64Binary */ + bool *AdditionalCaSerialNums; /* optional element of type xsd:boolean */ + bool IsOemDefault; /* required element of type xsd:boolean */ + bool IsTimeValid; /* required element of type xsd:boolean */ + unsigned int ProvServerIP; /* required element of type sai:IPv4AddressType */ + unsigned int TlsStartTime; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 39; } /* = unique id SOAP_TYPE_sai__ProvisioningAuditRecordType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__ProvisioningAuditRecordType() : ProvServerFQDN(NULL), AdditionalCaSerialNums(NULL), soap(NULL) { } + virtual ~sai__ProvisioningAuditRecordType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__EnvironmentDetectionDomainType +#define SOAP_TYPE_sai__EnvironmentDetectionDomainType (40) +/* sai:EnvironmentDetectionDomainType */ +class SOAP_CMAC sai__EnvironmentDetectionDomainType +{ +public: + std::vectorvalues; /* sequence of 0 to 5 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 40; } /* = unique id SOAP_TYPE_sai__EnvironmentDetectionDomainType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__EnvironmentDetectionDomainType() : soap(NULL) { } + virtual ~sai__EnvironmentDetectionDomainType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__EnvironmentDetectionType +#define SOAP_TYPE_sai__EnvironmentDetectionType (41) +/* sai:EnvironmentDetectionType */ +class SOAP_CMAC sai__EnvironmentDetectionType +{ +public: + sai__EnvironmentDetectionDomainType *LocalDomains; /* required element of type sai:EnvironmentDetectionDomainType */ + unsigned int *ExternalCircuitBreakerPolicy; /* optional element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 41; } /* = unique id SOAP_TYPE_sai__EnvironmentDetectionType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__EnvironmentDetectionType() : LocalDomains(NULL), ExternalCircuitBreakerPolicy(NULL), soap(NULL) { } + virtual ~sai__EnvironmentDetectionType() { } +}; +#endif + +#ifndef SOAP_TYPE_sai__GlobalPowerPolicyType +#define SOAP_TYPE_sai__GlobalPowerPolicyType (42) +/* sai:GlobalPowerPolicyType */ +class SOAP_CMAC sai__GlobalPowerPolicyType +{ +public: + unsigned int IdleWakeTimeout; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 42; } /* = unique id SOAP_TYPE_sai__GlobalPowerPolicyType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + sai__GlobalPowerPolicyType() : soap(NULL) { } + virtual ~sai__GlobalPowerPolicyType() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__AddUserAclEntry +#define SOAP_TYPE__sai__AddUserAclEntry (43) +/* sai:AddUserAclEntry */ +class SOAP_CMAC _sai__AddUserAclEntry +{ +public: + sai__UserAclEntryType *Entry; /* required element of type sai:UserAclEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 43; } /* = unique id SOAP_TYPE__sai__AddUserAclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__AddUserAclEntry() : Entry(NULL), soap(NULL) { } + virtual ~_sai__AddUserAclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__AddUserAclEntryResponse +#define SOAP_TYPE__sai__AddUserAclEntryResponse (44) +/* sai:AddUserAclEntryResponse */ +class SOAP_CMAC _sai__AddUserAclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + unsigned int Handle; /* required element of type sai:UserAclEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 44; } /* = unique id SOAP_TYPE__sai__AddUserAclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__AddUserAclEntryResponse() : soap(NULL) { } + virtual ~_sai__AddUserAclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetAdminAclEntry +#define SOAP_TYPE__sai__SetAdminAclEntry (45) +/* sai:SetAdminAclEntry */ +class SOAP_CMAC _sai__SetAdminAclEntry +{ +public: + sai__AdminAclEntryType *Entry; /* required element of type sai:AdminAclEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 45; } /* = unique id SOAP_TYPE__sai__SetAdminAclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetAdminAclEntry() : Entry(NULL), soap(NULL) { } + virtual ~_sai__SetAdminAclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetAdminAclEntryResponse +#define SOAP_TYPE__sai__SetAdminAclEntryResponse (46) +/* sai:SetAdminAclEntryResponse */ +class SOAP_CMAC _sai__SetAdminAclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 46; } /* = unique id SOAP_TYPE__sai__SetAdminAclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetAdminAclEntryResponse() : soap(NULL) { } + virtual ~_sai__SetAdminAclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnumerateUserAclEntries +#define SOAP_TYPE__sai__EnumerateUserAclEntries (47) +/* sai:EnumerateUserAclEntries */ +class SOAP_CMAC _sai__EnumerateUserAclEntries +{ +public: + unsigned int StartIndex; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 47; } /* = unique id SOAP_TYPE__sai__EnumerateUserAclEntries */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnumerateUserAclEntries() : soap(NULL) { } + virtual ~_sai__EnumerateUserAclEntries() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnumerateUserAclEntriesResponse +#define SOAP_TYPE__sai__EnumerateUserAclEntriesResponse (48) +/* sai:EnumerateUserAclEntriesResponse */ +class SOAP_CMAC _sai__EnumerateUserAclEntriesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + unsigned int TotalCount; /* required element of type xsd:unsignedInt */ + unsigned int HandleCount; /* required element of type xsd:unsignedInt */ + sai__UserAclEntryHandleListType *Handles; /* required element of type sai:UserAclEntryHandleListType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 48; } /* = unique id SOAP_TYPE__sai__EnumerateUserAclEntriesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnumerateUserAclEntriesResponse() : Handles(NULL), soap(NULL) { } + virtual ~_sai__EnumerateUserAclEntriesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetUserAclEntry +#define SOAP_TYPE__sai__GetUserAclEntry (49) +/* sai:GetUserAclEntry */ +class SOAP_CMAC _sai__GetUserAclEntry +{ +public: + unsigned int Handle; /* required element of type sai:UserAclEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 49; } /* = unique id SOAP_TYPE__sai__GetUserAclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetUserAclEntry() : soap(NULL) { } + virtual ~_sai__GetUserAclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetUserAclEntryResponse +#define SOAP_TYPE__sai__GetUserAclEntryResponse (50) +/* sai:GetUserAclEntryResponse */ +class SOAP_CMAC _sai__GetUserAclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + sai__UserAclEntryType *Entry; /* required element of type sai:UserAclEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 50; } /* = unique id SOAP_TYPE__sai__GetUserAclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetUserAclEntryResponse() : Entry(NULL), soap(NULL) { } + virtual ~_sai__GetUserAclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetAdminAclEntry +#define SOAP_TYPE__sai__GetAdminAclEntry (51) +/* sai:GetAdminAclEntry */ +class SOAP_CMAC _sai__GetAdminAclEntry +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 51; } /* = unique id SOAP_TYPE__sai__GetAdminAclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetAdminAclEntry() : soap(NULL) { } + virtual ~_sai__GetAdminAclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetAdminAclEntryResponse +#define SOAP_TYPE__sai__GetAdminAclEntryResponse (52) +/* sai:GetAdminAclEntryResponse */ +class SOAP_CMAC _sai__GetAdminAclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + std::string Username; /* required element of type sai:AclStringType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 52; } /* = unique id SOAP_TYPE__sai__GetAdminAclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetAdminAclEntryResponse() : soap(NULL) { } + virtual ~_sai__GetAdminAclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__UpdateUserAclEntry +#define SOAP_TYPE__sai__UpdateUserAclEntry (53) +/* sai:UpdateUserAclEntry */ +class SOAP_CMAC _sai__UpdateUserAclEntry +{ +public: + unsigned int Handle; /* required element of type sai:UserAclEntryHandleType */ + sai__UserAclEntryType *Entry; /* required element of type sai:UserAclEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 53; } /* = unique id SOAP_TYPE__sai__UpdateUserAclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__UpdateUserAclEntry() : Entry(NULL), soap(NULL) { } + virtual ~_sai__UpdateUserAclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__UpdateUserAclEntryResponse +#define SOAP_TYPE__sai__UpdateUserAclEntryResponse (54) +/* sai:UpdateUserAclEntryResponse */ +class SOAP_CMAC _sai__UpdateUserAclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 54; } /* = unique id SOAP_TYPE__sai__UpdateUserAclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__UpdateUserAclEntryResponse() : soap(NULL) { } + virtual ~_sai__UpdateUserAclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__RemoveUserAclEntry +#define SOAP_TYPE__sai__RemoveUserAclEntry (55) +/* sai:RemoveUserAclEntry */ +class SOAP_CMAC _sai__RemoveUserAclEntry +{ +public: + unsigned int Handle; /* required element of type sai:UserAclEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 55; } /* = unique id SOAP_TYPE__sai__RemoveUserAclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__RemoveUserAclEntry() : soap(NULL) { } + virtual ~_sai__RemoveUserAclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__RemoveUserAclEntryResponse +#define SOAP_TYPE__sai__RemoveUserAclEntryResponse (56) +/* sai:RemoveUserAclEntryResponse */ +class SOAP_CMAC _sai__RemoveUserAclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 56; } /* = unique id SOAP_TYPE__sai__RemoveUserAclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__RemoveUserAclEntryResponse() : soap(NULL) { } + virtual ~_sai__RemoveUserAclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTlsEnabled +#define SOAP_TYPE__sai__SetTlsEnabled (57) +/* sai:SetTlsEnabled */ +class SOAP_CMAC _sai__SetTlsEnabled +{ +public: + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 57; } /* = unique id SOAP_TYPE__sai__SetTlsEnabled */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTlsEnabled() : soap(NULL) { } + virtual ~_sai__SetTlsEnabled() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTlsEnabledResponse +#define SOAP_TYPE__sai__SetTlsEnabledResponse (58) +/* sai:SetTlsEnabledResponse */ +class SOAP_CMAC _sai__SetTlsEnabledResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 58; } /* = unique id SOAP_TYPE__sai__SetTlsEnabledResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTlsEnabledResponse() : soap(NULL) { } + virtual ~_sai__SetTlsEnabledResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTLSKeyAndCertificate +#define SOAP_TYPE__sai__SetTLSKeyAndCertificate (59) +/* sai:SetTLSKeyAndCertificate */ +class SOAP_CMAC _sai__SetTLSKeyAndCertificate +{ +public: + sai__RsaKeyType *PrivateKey; /* optional element of type sai:RsaKeyType */ + sai__CertificateChainType *CertificateChain; /* required element of type sai:CertificateChainType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 59; } /* = unique id SOAP_TYPE__sai__SetTLSKeyAndCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTLSKeyAndCertificate() : PrivateKey(NULL), CertificateChain(NULL), soap(NULL) { } + virtual ~_sai__SetTLSKeyAndCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse +#define SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse (60) +/* sai:SetTLSKeyAndCertificateResponse */ +class SOAP_CMAC _sai__SetTLSKeyAndCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 60; } /* = unique id SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTLSKeyAndCertificateResponse() : soap(NULL) { } + virtual ~_sai__SetTLSKeyAndCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetRngKey +#define SOAP_TYPE__sai__SetRngKey (61) +/* sai:SetRngKey */ +class SOAP_CMAC _sai__SetRngKey +{ +public: + sai__RngKeyType *Key; /* required element of type sai:RngKeyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 61; } /* = unique id SOAP_TYPE__sai__SetRngKey */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetRngKey() : Key(NULL), soap(NULL) { } + virtual ~_sai__SetRngKey() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetRngKeyResponse +#define SOAP_TYPE__sai__SetRngKeyResponse (62) +/* sai:SetRngKeyResponse */ +class SOAP_CMAC _sai__SetRngKeyResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 62; } /* = unique id SOAP_TYPE__sai__SetRngKeyResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetRngKeyResponse() : soap(NULL) { } + virtual ~_sai__SetRngKeyResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTLSCertificate +#define SOAP_TYPE__sai__SetTLSCertificate (63) +/* sai:SetTLSCertificate */ +class SOAP_CMAC _sai__SetTLSCertificate +{ +public: + sai__CertificateChainType *CertificateChain; /* required element of type sai:CertificateChainType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 63; } /* = unique id SOAP_TYPE__sai__SetTLSCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTLSCertificate() : CertificateChain(NULL), soap(NULL) { } + virtual ~_sai__SetTLSCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTLSCertificateResponse +#define SOAP_TYPE__sai__SetTLSCertificateResponse (64) +/* sai:SetTLSCertificateResponse */ +class SOAP_CMAC _sai__SetTLSCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 64; } /* = unique id SOAP_TYPE__sai__SetTLSCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTLSCertificateResponse() : soap(NULL) { } + virtual ~_sai__SetTLSCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTLSCertificate +#define SOAP_TYPE__sai__GetTLSCertificate (65) +/* sai:GetTLSCertificate */ +class SOAP_CMAC _sai__GetTLSCertificate +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 65; } /* = unique id SOAP_TYPE__sai__GetTLSCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTLSCertificate() : soap(NULL) { } + virtual ~_sai__GetTLSCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTLSCertificateResponse +#define SOAP_TYPE__sai__GetTLSCertificateResponse (66) +/* sai:GetTLSCertificateResponse */ +class SOAP_CMAC _sai__GetTLSCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + sai__CertificateChainType *CertificateChain; /* required element of type sai:CertificateChainType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 66; } /* = unique id SOAP_TYPE__sai__GetTLSCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTLSCertificateResponse() : CertificateChain(NULL), soap(NULL) { } + virtual ~_sai__GetTLSCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__UpdateCoreFromUrl +#define SOAP_TYPE__sai__UpdateCoreFromUrl (67) +/* sai:UpdateCoreFromUrl */ +class SOAP_CMAC _sai__UpdateCoreFromUrl +{ +public: + unsigned int tftpServerIp; /* required element of type sai:IPv4AddressType */ + std::string *tftpServerName; /* optional element of type xsd:string */ + unsigned short tftpServerPort; /* required element of type xsd:unsignedShort */ + unsigned short MagicPacketPort; /* required element of type xsd:unsignedShort */ + std::string packagePath; /* required element of type xsd:string */ + sai__AmtVersion *AmtAppVersion; /* required element of type sai:AmtVersion */ + sai__AmtVersion *UpdateAppVersion; /* required element of type sai:AmtVersion */ + unsigned int MgmtConsoleAddr; /* required element of type sai:IPv4AddressType */ + sai__UpdateCoreUrlKeyType *Key; /* required element of type sai:UpdateCoreUrlKeyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 67; } /* = unique id SOAP_TYPE__sai__UpdateCoreFromUrl */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__UpdateCoreFromUrl() : tftpServerName(NULL), AmtAppVersion(NULL), UpdateAppVersion(NULL), Key(NULL), soap(NULL) { } + virtual ~_sai__UpdateCoreFromUrl() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__UpdateCoreFromUrlResponse +#define SOAP_TYPE__sai__UpdateCoreFromUrlResponse (68) +/* sai:UpdateCoreFromUrlResponse */ +class SOAP_CMAC _sai__UpdateCoreFromUrlResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 68; } /* = unique id SOAP_TYPE__sai__UpdateCoreFromUrlResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__UpdateCoreFromUrlResponse() : soap(NULL) { } + virtual ~_sai__UpdateCoreFromUrlResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetProvisioningMode +#define SOAP_TYPE__sai__GetProvisioningMode (69) +/* sai:GetProvisioningMode */ +class SOAP_CMAC _sai__GetProvisioningMode +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 69; } /* = unique id SOAP_TYPE__sai__GetProvisioningMode */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetProvisioningMode() : soap(NULL) { } + virtual ~_sai__GetProvisioningMode() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetProvisioningModeResponse +#define SOAP_TYPE__sai__GetProvisioningModeResponse (70) +/* sai:GetProvisioningModeResponse */ +class SOAP_CMAC _sai__GetProvisioningModeResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + enum sai__ProvisioningModeType ProvisioningMode; /* required element of type sai:ProvisioningModeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 70; } /* = unique id SOAP_TYPE__sai__GetProvisioningModeResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetProvisioningModeResponse() : soap(NULL) { } + virtual ~_sai__GetProvisioningModeResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetProvisioningMode +#define SOAP_TYPE__sai__SetProvisioningMode (71) +/* sai:SetProvisioningMode */ +class SOAP_CMAC _sai__SetProvisioningMode +{ +public: + enum sai__ProvisioningModeType ProvisioningMode; /* required element of type sai:ProvisioningModeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 71; } /* = unique id SOAP_TYPE__sai__SetProvisioningMode */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetProvisioningMode() : soap(NULL) { } + virtual ~_sai__SetProvisioningMode() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetProvisioningModeResponse +#define SOAP_TYPE__sai__SetProvisioningModeResponse (72) +/* sai:SetProvisioningModeResponse */ +class SOAP_CMAC _sai__SetProvisioningModeResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 72; } /* = unique id SOAP_TYPE__sai__SetProvisioningModeResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetProvisioningModeResponse() : soap(NULL) { } + virtual ~_sai__SetProvisioningModeResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__Unprovision +#define SOAP_TYPE__sai__Unprovision (73) +/* sai:Unprovision */ +class SOAP_CMAC _sai__Unprovision +{ +public: + enum sai__ProvisioningModeType ProvisioningMode; /* required element of type sai:ProvisioningModeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 73; } /* = unique id SOAP_TYPE__sai__Unprovision */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__Unprovision() : soap(NULL) { } + virtual ~_sai__Unprovision() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__UnprovisionResponse +#define SOAP_TYPE__sai__UnprovisionResponse (74) +/* sai:UnprovisionResponse */ +class SOAP_CMAC _sai__UnprovisionResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 74; } /* = unique id SOAP_TYPE__sai__UnprovisionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__UnprovisionResponse() : soap(NULL) { } + virtual ~_sai__UnprovisionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CommitChanges +#define SOAP_TYPE__sai__CommitChanges (75) +/* sai:CommitChanges */ +class SOAP_CMAC _sai__CommitChanges +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 75; } /* = unique id SOAP_TYPE__sai__CommitChanges */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CommitChanges() : soap(NULL) { } + virtual ~_sai__CommitChanges() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CommitChangesResponse +#define SOAP_TYPE__sai__CommitChangesResponse (76) +/* sai:CommitChangesResponse */ +class SOAP_CMAC _sai__CommitChangesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 76; } /* = unique id SOAP_TYPE__sai__CommitChangesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CommitChangesResponse() : soap(NULL) { } + virtual ~_sai__CommitChangesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__ResetFlashWearOutProtection +#define SOAP_TYPE__sai__ResetFlashWearOutProtection (77) +/* sai:ResetFlashWearOutProtection */ +class SOAP_CMAC _sai__ResetFlashWearOutProtection +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 77; } /* = unique id SOAP_TYPE__sai__ResetFlashWearOutProtection */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__ResetFlashWearOutProtection() : soap(NULL) { } + virtual ~_sai__ResetFlashWearOutProtection() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse +#define SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse (78) +/* sai:ResetFlashWearOutProtectionResponse */ +class SOAP_CMAC _sai__ResetFlashWearOutProtectionResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 78; } /* = unique id SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__ResetFlashWearOutProtectionResponse() : soap(NULL) { } + virtual ~_sai__ResetFlashWearOutProtectionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetCoreVersion +#define SOAP_TYPE__sai__GetCoreVersion (79) +/* sai:GetCoreVersion */ +class SOAP_CMAC _sai__GetCoreVersion +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 79; } /* = unique id SOAP_TYPE__sai__GetCoreVersion */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetCoreVersion() : soap(NULL) { } + virtual ~_sai__GetCoreVersion() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetCoreVersionResponse +#define SOAP_TYPE__sai__GetCoreVersionResponse (80) +/* sai:GetCoreVersionResponse */ +class SOAP_CMAC _sai__GetCoreVersionResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + std::string Version; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 80; } /* = unique id SOAP_TYPE__sai__GetCoreVersionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetCoreVersionResponse() : soap(NULL) { } + virtual ~_sai__GetCoreVersionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__AddUserAclEntryEx +#define SOAP_TYPE__sai__AddUserAclEntryEx (81) +/* sai:AddUserAclEntryEx */ +class SOAP_CMAC _sai__AddUserAclEntryEx +{ +public: + sai__UserAclEntryExType *EntryEx; /* required element of type sai:UserAclEntryExType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 81; } /* = unique id SOAP_TYPE__sai__AddUserAclEntryEx */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__AddUserAclEntryEx() : EntryEx(NULL), soap(NULL) { } + virtual ~_sai__AddUserAclEntryEx() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__AddUserAclEntryExResponse +#define SOAP_TYPE__sai__AddUserAclEntryExResponse (82) +/* sai:AddUserAclEntryExResponse */ +class SOAP_CMAC _sai__AddUserAclEntryExResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + unsigned int Handle; /* required element of type sai:UserAclEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 82; } /* = unique id SOAP_TYPE__sai__AddUserAclEntryExResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__AddUserAclEntryExResponse() : soap(NULL) { } + virtual ~_sai__AddUserAclEntryExResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetUserAclEntryEx +#define SOAP_TYPE__sai__GetUserAclEntryEx (83) +/* sai:GetUserAclEntryEx */ +class SOAP_CMAC _sai__GetUserAclEntryEx +{ +public: + unsigned int Handle; /* required element of type sai:UserAclEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 83; } /* = unique id SOAP_TYPE__sai__GetUserAclEntryEx */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetUserAclEntryEx() : soap(NULL) { } + virtual ~_sai__GetUserAclEntryEx() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetUserAclEntryExResponse +#define SOAP_TYPE__sai__GetUserAclEntryExResponse (84) +/* sai:GetUserAclEntryExResponse */ +class SOAP_CMAC _sai__GetUserAclEntryExResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + sai__UserAclEntryExType *EntryEx; /* required element of type sai:UserAclEntryExType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 84; } /* = unique id SOAP_TYPE__sai__GetUserAclEntryExResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetUserAclEntryExResponse() : EntryEx(NULL), soap(NULL) { } + virtual ~_sai__GetUserAclEntryExResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__UpdateUserAclEntryEx +#define SOAP_TYPE__sai__UpdateUserAclEntryEx (85) +/* sai:UpdateUserAclEntryEx */ +class SOAP_CMAC _sai__UpdateUserAclEntryEx +{ +public: + unsigned int Handle; /* required element of type sai:UserAclEntryHandleType */ + sai__UserAclEntryExType *EntryEx; /* required element of type sai:UserAclEntryExType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 85; } /* = unique id SOAP_TYPE__sai__UpdateUserAclEntryEx */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__UpdateUserAclEntryEx() : EntryEx(NULL), soap(NULL) { } + virtual ~_sai__UpdateUserAclEntryEx() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__UpdateUserAclEntryExResponse +#define SOAP_TYPE__sai__UpdateUserAclEntryExResponse (86) +/* sai:UpdateUserAclEntryExResponse */ +class SOAP_CMAC _sai__UpdateUserAclEntryExResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 86; } /* = unique id SOAP_TYPE__sai__UpdateUserAclEntryExResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__UpdateUserAclEntryExResponse() : soap(NULL) { } + virtual ~_sai__UpdateUserAclEntryExResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetAdminAclEntryEx +#define SOAP_TYPE__sai__SetAdminAclEntryEx (87) +/* sai:SetAdminAclEntryEx */ +class SOAP_CMAC _sai__SetAdminAclEntryEx +{ +public: + sai__AdminAclEntryExType *EntryEx; /* required element of type sai:AdminAclEntryExType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 87; } /* = unique id SOAP_TYPE__sai__SetAdminAclEntryEx */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetAdminAclEntryEx() : EntryEx(NULL), soap(NULL) { } + virtual ~_sai__SetAdminAclEntryEx() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetAdminAclEntryExResponse +#define SOAP_TYPE__sai__SetAdminAclEntryExResponse (88) +/* sai:SetAdminAclEntryExResponse */ +class SOAP_CMAC _sai__SetAdminAclEntryExResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 88; } /* = unique id SOAP_TYPE__sai__SetAdminAclEntryExResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetAdminAclEntryExResponse() : soap(NULL) { } + virtual ~_sai__SetAdminAclEntryExResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetDigestRealm +#define SOAP_TYPE__sai__GetDigestRealm (89) +/* sai:GetDigestRealm */ +class SOAP_CMAC _sai__GetDigestRealm +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 89; } /* = unique id SOAP_TYPE__sai__GetDigestRealm */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetDigestRealm() : soap(NULL) { } + virtual ~_sai__GetDigestRealm() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetDigestRealmResponse +#define SOAP_TYPE__sai__GetDigestRealmResponse (90) +/* sai:GetDigestRealmResponse */ +class SOAP_CMAC _sai__GetDigestRealmResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + std::string DigestRealm; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 90; } /* = unique id SOAP_TYPE__sai__GetDigestRealmResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetDigestRealmResponse() : soap(NULL) { } + virtual ~_sai__GetDigestRealmResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetKerberosOptions +#define SOAP_TYPE__sai__SetKerberosOptions (91) +/* sai:SetKerberosOptions */ +class SOAP_CMAC _sai__SetKerberosOptions +{ +public: + sai__KerberosOptionsType *KerberosOptions; /* optional element of type sai:KerberosOptionsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 91; } /* = unique id SOAP_TYPE__sai__SetKerberosOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetKerberosOptions() : KerberosOptions(NULL), soap(NULL) { } + virtual ~_sai__SetKerberosOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetKerberosOptionsResponse +#define SOAP_TYPE__sai__SetKerberosOptionsResponse (92) +/* sai:SetKerberosOptionsResponse */ +class SOAP_CMAC _sai__SetKerberosOptionsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 92; } /* = unique id SOAP_TYPE__sai__SetKerberosOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetKerberosOptionsResponse() : soap(NULL) { } + virtual ~_sai__SetKerberosOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetKerberosOptions +#define SOAP_TYPE__sai__GetKerberosOptions (93) +/* sai:GetKerberosOptions */ +class SOAP_CMAC _sai__GetKerberosOptions +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 93; } /* = unique id SOAP_TYPE__sai__GetKerberosOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetKerberosOptions() : soap(NULL) { } + virtual ~_sai__GetKerberosOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetKerberosOptionsResponse +#define SOAP_TYPE__sai__GetKerberosOptionsResponse (94) +/* sai:GetKerberosOptionsResponse */ +class SOAP_CMAC _sai__GetKerberosOptionsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + sai__KerberosOptionsType *KerberosOptions; /* required element of type sai:KerberosOptionsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 94; } /* = unique id SOAP_TYPE__sai__GetKerberosOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetKerberosOptionsResponse() : KerberosOptions(NULL), soap(NULL) { } + virtual ~_sai__GetKerberosOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetEnabledInterfaces +#define SOAP_TYPE__sai__SetEnabledInterfaces (95) +/* sai:SetEnabledInterfaces */ +class SOAP_CMAC _sai__SetEnabledInterfaces +{ +public: + std::vectorEnabledInterfaces; /* optional element of type sai:EnabledInterfacesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 95; } /* = unique id SOAP_TYPE__sai__SetEnabledInterfaces */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetEnabledInterfaces() : soap(NULL) { } + virtual ~_sai__SetEnabledInterfaces() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetEnabledInterfacesResponse +#define SOAP_TYPE__sai__SetEnabledInterfacesResponse (96) +/* sai:SetEnabledInterfacesResponse */ +class SOAP_CMAC _sai__SetEnabledInterfacesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 96; } /* = unique id SOAP_TYPE__sai__SetEnabledInterfacesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetEnabledInterfacesResponse() : soap(NULL) { } + virtual ~_sai__SetEnabledInterfacesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetEnabledInterfaces +#define SOAP_TYPE__sai__GetEnabledInterfaces (97) +/* sai:GetEnabledInterfaces */ +class SOAP_CMAC _sai__GetEnabledInterfaces +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 97; } /* = unique id SOAP_TYPE__sai__GetEnabledInterfaces */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetEnabledInterfaces() : soap(NULL) { } + virtual ~_sai__GetEnabledInterfaces() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetEnabledInterfacesResponse +#define SOAP_TYPE__sai__GetEnabledInterfacesResponse (98) +/* sai:GetEnabledInterfacesResponse */ +class SOAP_CMAC _sai__GetEnabledInterfacesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + std::vectorEnabledInterfaces; /* optional element of type sai:EnabledInterfacesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 98; } /* = unique id SOAP_TYPE__sai__GetEnabledInterfacesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetEnabledInterfacesResponse() : soap(NULL) { } + virtual ~_sai__GetEnabledInterfacesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTlsOptions +#define SOAP_TYPE__sai__SetTlsOptions (99) +/* sai:SetTlsOptions */ +class SOAP_CMAC _sai__SetTlsOptions +{ +public: + std::vectorTlsOptions; /* sequence of 0 to 2 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 99; } /* = unique id SOAP_TYPE__sai__SetTlsOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTlsOptions() : soap(NULL) { } + virtual ~_sai__SetTlsOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTlsOptionsResponse +#define SOAP_TYPE__sai__SetTlsOptionsResponse (100) +/* sai:SetTlsOptionsResponse */ +class SOAP_CMAC _sai__SetTlsOptionsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 100; } /* = unique id SOAP_TYPE__sai__SetTlsOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTlsOptionsResponse() : soap(NULL) { } + virtual ~_sai__SetTlsOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTlsOptions +#define SOAP_TYPE__sai__GetTlsOptions (101) +/* sai:GetTlsOptions */ +class SOAP_CMAC _sai__GetTlsOptions +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 101; } /* = unique id SOAP_TYPE__sai__GetTlsOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTlsOptions() : soap(NULL) { } + virtual ~_sai__GetTlsOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTlsOptionsResponse +#define SOAP_TYPE__sai__GetTlsOptionsResponse (102) +/* sai:GetTlsOptionsResponse */ +class SOAP_CMAC _sai__GetTlsOptionsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + std::vectorTlsOptions; /* sequence of 0 to 2 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 102; } /* = unique id SOAP_TYPE__sai__GetTlsOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTlsOptionsResponse() : soap(NULL) { } + virtual ~_sai__GetTlsOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__AddTrustedRootCertificate +#define SOAP_TYPE__sai__AddTrustedRootCertificate (103) +/* sai:AddTrustedRootCertificate */ +class SOAP_CMAC _sai__AddTrustedRootCertificate +{ +public: + sai__CertificateType *Certificate; /* required element of type sai:CertificateType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 103; } /* = unique id SOAP_TYPE__sai__AddTrustedRootCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__AddTrustedRootCertificate() : Certificate(NULL), soap(NULL) { } + virtual ~_sai__AddTrustedRootCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__AddTrustedRootCertificateResponse +#define SOAP_TYPE__sai__AddTrustedRootCertificateResponse (104) +/* sai:AddTrustedRootCertificateResponse */ +class SOAP_CMAC _sai__AddTrustedRootCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + unsigned int CertHandle; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 104; } /* = unique id SOAP_TYPE__sai__AddTrustedRootCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__AddTrustedRootCertificateResponse() : soap(NULL) { } + virtual ~_sai__AddTrustedRootCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTrustedRootCertificate +#define SOAP_TYPE__sai__GetTrustedRootCertificate (105) +/* sai:GetTrustedRootCertificate */ +class SOAP_CMAC _sai__GetTrustedRootCertificate +{ +public: + unsigned int CertHandle; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 105; } /* = unique id SOAP_TYPE__sai__GetTrustedRootCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTrustedRootCertificate() : soap(NULL) { } + virtual ~_sai__GetTrustedRootCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTrustedRootCertificateResponse +#define SOAP_TYPE__sai__GetTrustedRootCertificateResponse (106) +/* sai:GetTrustedRootCertificateResponse */ +class SOAP_CMAC _sai__GetTrustedRootCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + sai__CertificateType *Certificate; /* required element of type sai:CertificateType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 106; } /* = unique id SOAP_TYPE__sai__GetTrustedRootCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTrustedRootCertificateResponse() : Certificate(NULL), soap(NULL) { } + virtual ~_sai__GetTrustedRootCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__DeleteTrustedRootCertificate +#define SOAP_TYPE__sai__DeleteTrustedRootCertificate (107) +/* sai:DeleteTrustedRootCertificate */ +class SOAP_CMAC _sai__DeleteTrustedRootCertificate +{ +public: + unsigned int CertHandle; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 107; } /* = unique id SOAP_TYPE__sai__DeleteTrustedRootCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__DeleteTrustedRootCertificate() : soap(NULL) { } + virtual ~_sai__DeleteTrustedRootCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse +#define SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse (108) +/* sai:DeleteTrustedRootCertificateResponse */ +class SOAP_CMAC _sai__DeleteTrustedRootCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 108; } /* = unique id SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__DeleteTrustedRootCertificateResponse() : soap(NULL) { } + virtual ~_sai__DeleteTrustedRootCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnumerateTrustedRootCertificates +#define SOAP_TYPE__sai__EnumerateTrustedRootCertificates (109) +/* sai:EnumerateTrustedRootCertificates */ +class SOAP_CMAC _sai__EnumerateTrustedRootCertificates +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 109; } /* = unique id SOAP_TYPE__sai__EnumerateTrustedRootCertificates */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnumerateTrustedRootCertificates() : soap(NULL) { } + virtual ~_sai__EnumerateTrustedRootCertificates() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse +#define SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse (110) +/* sai:EnumerateTrustedRootCertificatesResponse */ +class SOAP_CMAC _sai__EnumerateTrustedRootCertificatesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + std::vectorCertHandle; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 110; } /* = unique id SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnumerateTrustedRootCertificatesResponse() : soap(NULL) { } + virtual ~_sai__EnumerateTrustedRootCertificatesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTrustedFqdnCN +#define SOAP_TYPE__sai__SetTrustedFqdnCN (111) +/* sai:SetTrustedFqdnCN */ +class SOAP_CMAC _sai__SetTrustedFqdnCN +{ +public: + std::vectorFqdnSuffix; /* optional element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 111; } /* = unique id SOAP_TYPE__sai__SetTrustedFqdnCN */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTrustedFqdnCN() : soap(NULL) { } + virtual ~_sai__SetTrustedFqdnCN() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTrustedFqdnCNResponse +#define SOAP_TYPE__sai__SetTrustedFqdnCNResponse (112) +/* sai:SetTrustedFqdnCNResponse */ +class SOAP_CMAC _sai__SetTrustedFqdnCNResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 112; } /* = unique id SOAP_TYPE__sai__SetTrustedFqdnCNResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTrustedFqdnCNResponse() : soap(NULL) { } + virtual ~_sai__SetTrustedFqdnCNResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTrustedFqdnCN +#define SOAP_TYPE__sai__GetTrustedFqdnCN (113) +/* sai:GetTrustedFqdnCN */ +class SOAP_CMAC _sai__GetTrustedFqdnCN +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 113; } /* = unique id SOAP_TYPE__sai__GetTrustedFqdnCN */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTrustedFqdnCN() : soap(NULL) { } + virtual ~_sai__GetTrustedFqdnCN() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTrustedFqdnCNResponse +#define SOAP_TYPE__sai__GetTrustedFqdnCNResponse (114) +/* sai:GetTrustedFqdnCNResponse */ +class SOAP_CMAC _sai__GetTrustedFqdnCNResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + std::vectorFqdnSuffix; /* optional element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 114; } /* = unique id SOAP_TYPE__sai__GetTrustedFqdnCNResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTrustedFqdnCNResponse() : soap(NULL) { } + virtual ~_sai__GetTrustedFqdnCNResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetCRL +#define SOAP_TYPE__sai__SetCRL (115) +/* sai:SetCRL */ +class SOAP_CMAC _sai__SetCRL +{ +public: + std::vectorCrl; /* optional element of type sai:CrlType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 115; } /* = unique id SOAP_TYPE__sai__SetCRL */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetCRL() : soap(NULL) { } + virtual ~_sai__SetCRL() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetCRLResponse +#define SOAP_TYPE__sai__SetCRLResponse (116) +/* sai:SetCRLResponse */ +class SOAP_CMAC _sai__SetCRLResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 116; } /* = unique id SOAP_TYPE__sai__SetCRLResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetCRLResponse() : soap(NULL) { } + virtual ~_sai__SetCRLResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetCRL +#define SOAP_TYPE__sai__GetCRL (117) +/* sai:GetCRL */ +class SOAP_CMAC _sai__GetCRL +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 117; } /* = unique id SOAP_TYPE__sai__GetCRL */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetCRL() : soap(NULL) { } + virtual ~_sai__GetCRL() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetCRLResponse +#define SOAP_TYPE__sai__GetCRLResponse (118) +/* sai:GetCRLResponse */ +class SOAP_CMAC _sai__GetCRLResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + std::vectorCrl; /* optional element of type sai:CrlType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 118; } /* = unique id SOAP_TYPE__sai__GetCRLResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetCRLResponse() : soap(NULL) { } + virtual ~_sai__GetCRLResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetServerCertificateReq +#define SOAP_TYPE__sai__GetServerCertificateReq (119) +/* sai:GetServerCertificateReq */ +class SOAP_CMAC _sai__GetServerCertificateReq +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 119; } /* = unique id SOAP_TYPE__sai__GetServerCertificateReq */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetServerCertificateReq() : soap(NULL) { } + virtual ~_sai__GetServerCertificateReq() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetServerCertificateReqResponse +#define SOAP_TYPE__sai__GetServerCertificateReqResponse (120) +/* sai:GetServerCertificateReqResponse */ +class SOAP_CMAC _sai__GetServerCertificateReqResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + xsd__base64Binary CertReq; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 120; } /* = unique id SOAP_TYPE__sai__GetServerCertificateReqResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetServerCertificateReqResponse() : soap(NULL) { } + virtual ~_sai__GetServerCertificateReqResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetPkiCapabilities +#define SOAP_TYPE__sai__GetPkiCapabilities (121) +/* sai:GetPkiCapabilities */ +class SOAP_CMAC _sai__GetPkiCapabilities +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 121; } /* = unique id SOAP_TYPE__sai__GetPkiCapabilities */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetPkiCapabilities() : soap(NULL) { } + virtual ~_sai__GetPkiCapabilities() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetPkiCapabilitiesResponse +#define SOAP_TYPE__sai__GetPkiCapabilitiesResponse (122) +/* sai:GetPkiCapabilitiesResponse */ +class SOAP_CMAC _sai__GetPkiCapabilitiesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + sai__PkiCapsType *PkiCaps; /* required element of type sai:PkiCapsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 122; } /* = unique id SOAP_TYPE__sai__GetPkiCapabilitiesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetPkiCapabilitiesResponse() : PkiCaps(NULL), soap(NULL) { } + virtual ~_sai__GetPkiCapabilitiesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetPowerSavingOptions +#define SOAP_TYPE__sai__SetPowerSavingOptions (123) +/* sai:SetPowerSavingOptions */ +class SOAP_CMAC _sai__SetPowerSavingOptions +{ +public: + enum sai__PowerStateType ActiveStateAC; /* required element of type sai:PowerStateType */ + enum sai__PowerStateType *WakeOnNetAccessThresholdAC; /* optional element of type sai:PowerStateType */ + unsigned short *WakeOnNetAccessSleepTimer; /* optional element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 123; } /* = unique id SOAP_TYPE__sai__SetPowerSavingOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetPowerSavingOptions() : WakeOnNetAccessThresholdAC(NULL), WakeOnNetAccessSleepTimer(NULL), soap(NULL) { } + virtual ~_sai__SetPowerSavingOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetPowerSavingOptionsResponse +#define SOAP_TYPE__sai__SetPowerSavingOptionsResponse (124) +/* sai:SetPowerSavingOptionsResponse */ +class SOAP_CMAC _sai__SetPowerSavingOptionsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 124; } /* = unique id SOAP_TYPE__sai__SetPowerSavingOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetPowerSavingOptionsResponse() : soap(NULL) { } + virtual ~_sai__SetPowerSavingOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetPowerSavingOptions +#define SOAP_TYPE__sai__GetPowerSavingOptions (125) +/* sai:GetPowerSavingOptions */ +class SOAP_CMAC _sai__GetPowerSavingOptions +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 125; } /* = unique id SOAP_TYPE__sai__GetPowerSavingOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetPowerSavingOptions() : soap(NULL) { } + virtual ~_sai__GetPowerSavingOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetPowerSavingOptionsResponse +#define SOAP_TYPE__sai__GetPowerSavingOptionsResponse (126) +/* sai:GetPowerSavingOptionsResponse */ +class SOAP_CMAC _sai__GetPowerSavingOptionsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + enum sai__PowerStateType ActiveStateAC; /* required element of type sai:PowerStateType */ + enum sai__PowerStateType *WakeOnNetAccessThresholdAC; /* optional element of type sai:PowerStateType */ + unsigned short *WakeOnNetAccessSleepTimer; /* optional element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 126; } /* = unique id SOAP_TYPE__sai__GetPowerSavingOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetPowerSavingOptionsResponse() : WakeOnNetAccessThresholdAC(NULL), WakeOnNetAccessSleepTimer(NULL), soap(NULL) { } + virtual ~_sai__GetPowerSavingOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTLSPSK +#define SOAP_TYPE__sai__SetTLSPSK (127) +/* sai:SetTLSPSK */ +class SOAP_CMAC _sai__SetTLSPSK +{ +public: + xsd__base64Binary PID; /* required element of type xsd:base64Binary */ + xsd__base64Binary PPS; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 127; } /* = unique id SOAP_TYPE__sai__SetTLSPSK */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTLSPSK() : soap(NULL) { } + virtual ~_sai__SetTLSPSK() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTLSPSKResponse +#define SOAP_TYPE__sai__SetTLSPSKResponse (128) +/* sai:SetTLSPSKResponse */ +class SOAP_CMAC _sai__SetTLSPSKResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 128; } /* = unique id SOAP_TYPE__sai__SetTLSPSKResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTLSPSKResponse() : soap(NULL) { } + virtual ~_sai__SetTLSPSKResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__PartialUnprovision +#define SOAP_TYPE__sai__PartialUnprovision (129) +/* sai:PartialUnprovision */ +class SOAP_CMAC _sai__PartialUnprovision +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 129; } /* = unique id SOAP_TYPE__sai__PartialUnprovision */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__PartialUnprovision() : soap(NULL) { } + virtual ~_sai__PartialUnprovision() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__PartialUnprovisionResponse +#define SOAP_TYPE__sai__PartialUnprovisionResponse (130) +/* sai:PartialUnprovisionResponse */ +class SOAP_CMAC _sai__PartialUnprovisionResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 130; } /* = unique id SOAP_TYPE__sai__PartialUnprovisionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__PartialUnprovisionResponse() : soap(NULL) { } + virtual ~_sai__PartialUnprovisionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetMEBxPassword +#define SOAP_TYPE__sai__SetMEBxPassword (131) +/* sai:SetMEBxPassword */ +class SOAP_CMAC _sai__SetMEBxPassword +{ +public: + std::string Password; /* required element of type sai:MEBxPasswordType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 131; } /* = unique id SOAP_TYPE__sai__SetMEBxPassword */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetMEBxPassword() : soap(NULL) { } + virtual ~_sai__SetMEBxPassword() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetMEBxPasswordResponse +#define SOAP_TYPE__sai__SetMEBxPasswordResponse (132) +/* sai:SetMEBxPasswordResponse */ +class SOAP_CMAC _sai__SetMEBxPasswordResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 132; } /* = unique id SOAP_TYPE__sai__SetMEBxPasswordResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetMEBxPasswordResponse() : soap(NULL) { } + virtual ~_sai__SetMEBxPasswordResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetProvisioningServerOTP +#define SOAP_TYPE__sai__SetProvisioningServerOTP (133) +/* sai:SetProvisioningServerOTP */ +class SOAP_CMAC _sai__SetProvisioningServerOTP +{ +public: + xsd__base64Binary *OTP; /* optional element of type sai:ProvisioningOTPType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 133; } /* = unique id SOAP_TYPE__sai__SetProvisioningServerOTP */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetProvisioningServerOTP() : OTP(NULL), soap(NULL) { } + virtual ~_sai__SetProvisioningServerOTP() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetProvisioningServerOTPResponse +#define SOAP_TYPE__sai__SetProvisioningServerOTPResponse (134) +/* sai:SetProvisioningServerOTPResponse */ +class SOAP_CMAC _sai__SetProvisioningServerOTPResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 134; } /* = unique id SOAP_TYPE__sai__SetProvisioningServerOTPResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetProvisioningServerOTPResponse() : soap(NULL) { } + virtual ~_sai__SetProvisioningServerOTPResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetProvisioningServerOTP +#define SOAP_TYPE__sai__GetProvisioningServerOTP (135) +/* sai:GetProvisioningServerOTP */ +class SOAP_CMAC _sai__GetProvisioningServerOTP +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 135; } /* = unique id SOAP_TYPE__sai__GetProvisioningServerOTP */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetProvisioningServerOTP() : soap(NULL) { } + virtual ~_sai__GetProvisioningServerOTP() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetProvisioningServerOTPResponse +#define SOAP_TYPE__sai__GetProvisioningServerOTPResponse (136) +/* sai:GetProvisioningServerOTPResponse */ +class SOAP_CMAC _sai__GetProvisioningServerOTPResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + xsd__base64Binary OTP; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 136; } /* = unique id SOAP_TYPE__sai__GetProvisioningServerOTPResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetProvisioningServerOTPResponse() : soap(NULL) { } + virtual ~_sai__GetProvisioningServerOTPResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnumerateCertificateHashEntries +#define SOAP_TYPE__sai__EnumerateCertificateHashEntries (137) +/* sai:EnumerateCertificateHashEntries */ +class SOAP_CMAC _sai__EnumerateCertificateHashEntries +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 137; } /* = unique id SOAP_TYPE__sai__EnumerateCertificateHashEntries */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnumerateCertificateHashEntries() : soap(NULL) { } + virtual ~_sai__EnumerateCertificateHashEntries() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse +#define SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse (138) +/* sai:EnumerateCertificateHashEntriesResponse */ +class SOAP_CMAC _sai__EnumerateCertificateHashEntriesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + std::vectorHandles; /* optional element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 138; } /* = unique id SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnumerateCertificateHashEntriesResponse() : soap(NULL) { } + virtual ~_sai__EnumerateCertificateHashEntriesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetCertificateHashEntry +#define SOAP_TYPE__sai__GetCertificateHashEntry (139) +/* sai:GetCertificateHashEntry */ +class SOAP_CMAC _sai__GetCertificateHashEntry +{ +public: + unsigned int Handle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 139; } /* = unique id SOAP_TYPE__sai__GetCertificateHashEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetCertificateHashEntry() : soap(NULL) { } + virtual ~_sai__GetCertificateHashEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetCertificateHashEntryResponse +#define SOAP_TYPE__sai__GetCertificateHashEntryResponse (140) +/* sai:GetCertificateHashEntryResponse */ +class SOAP_CMAC _sai__GetCertificateHashEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + sai__CertHashEntryType *CertHashEntry; /* required element of type sai:CertHashEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 140; } /* = unique id SOAP_TYPE__sai__GetCertificateHashEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetCertificateHashEntryResponse() : CertHashEntry(NULL), soap(NULL) { } + virtual ~_sai__GetCertificateHashEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__AddCertificateHashEntry +#define SOAP_TYPE__sai__AddCertificateHashEntry (141) +/* sai:AddCertificateHashEntry */ +class SOAP_CMAC _sai__AddCertificateHashEntry +{ +public: + sai__CertHashEntryType *CertHashEntry; /* required element of type sai:CertHashEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 141; } /* = unique id SOAP_TYPE__sai__AddCertificateHashEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__AddCertificateHashEntry() : CertHashEntry(NULL), soap(NULL) { } + virtual ~_sai__AddCertificateHashEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__AddCertificateHashEntryResponse +#define SOAP_TYPE__sai__AddCertificateHashEntryResponse (142) +/* sai:AddCertificateHashEntryResponse */ +class SOAP_CMAC _sai__AddCertificateHashEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + unsigned int Handle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 142; } /* = unique id SOAP_TYPE__sai__AddCertificateHashEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__AddCertificateHashEntryResponse() : soap(NULL) { } + virtual ~_sai__AddCertificateHashEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__DeleteCertificateHashEntry +#define SOAP_TYPE__sai__DeleteCertificateHashEntry (143) +/* sai:DeleteCertificateHashEntry */ +class SOAP_CMAC _sai__DeleteCertificateHashEntry +{ +public: + unsigned int Handle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 143; } /* = unique id SOAP_TYPE__sai__DeleteCertificateHashEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__DeleteCertificateHashEntry() : soap(NULL) { } + virtual ~_sai__DeleteCertificateHashEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__DeleteCertificateHashEntryResponse +#define SOAP_TYPE__sai__DeleteCertificateHashEntryResponse (144) +/* sai:DeleteCertificateHashEntryResponse */ +class SOAP_CMAC _sai__DeleteCertificateHashEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 144; } /* = unique id SOAP_TYPE__sai__DeleteCertificateHashEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__DeleteCertificateHashEntryResponse() : soap(NULL) { } + virtual ~_sai__DeleteCertificateHashEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnableCertificateHashEntry +#define SOAP_TYPE__sai__EnableCertificateHashEntry (145) +/* sai:EnableCertificateHashEntry */ +class SOAP_CMAC _sai__EnableCertificateHashEntry +{ +public: + unsigned int Handle; /* required element of type xsd:unsignedInt */ + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 145; } /* = unique id SOAP_TYPE__sai__EnableCertificateHashEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnableCertificateHashEntry() : soap(NULL) { } + virtual ~_sai__EnableCertificateHashEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnableCertificateHashEntryResponse +#define SOAP_TYPE__sai__EnableCertificateHashEntryResponse (146) +/* sai:EnableCertificateHashEntryResponse */ +class SOAP_CMAC _sai__EnableCertificateHashEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 146; } /* = unique id SOAP_TYPE__sai__EnableCertificateHashEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnableCertificateHashEntryResponse() : soap(NULL) { } + virtual ~_sai__EnableCertificateHashEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetZeroTouchConfigurationMode +#define SOAP_TYPE__sai__GetZeroTouchConfigurationMode (147) +/* sai:GetZeroTouchConfigurationMode */ +class SOAP_CMAC _sai__GetZeroTouchConfigurationMode +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 147; } /* = unique id SOAP_TYPE__sai__GetZeroTouchConfigurationMode */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetZeroTouchConfigurationMode() : soap(NULL) { } + virtual ~_sai__GetZeroTouchConfigurationMode() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse +#define SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse (148) +/* sai:GetZeroTouchConfigurationModeResponse */ +class SOAP_CMAC _sai__GetZeroTouchConfigurationModeResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 148; } /* = unique id SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetZeroTouchConfigurationModeResponse() : soap(NULL) { } + virtual ~_sai__GetZeroTouchConfigurationModeResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetZeroTouchConfigurationMode +#define SOAP_TYPE__sai__SetZeroTouchConfigurationMode (149) +/* sai:SetZeroTouchConfigurationMode */ +class SOAP_CMAC _sai__SetZeroTouchConfigurationMode +{ +public: + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 149; } /* = unique id SOAP_TYPE__sai__SetZeroTouchConfigurationMode */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetZeroTouchConfigurationMode() : soap(NULL) { } + virtual ~_sai__SetZeroTouchConfigurationMode() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse +#define SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse (150) +/* sai:SetZeroTouchConfigurationModeResponse */ +class SOAP_CMAC _sai__SetZeroTouchConfigurationModeResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 150; } /* = unique id SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetZeroTouchConfigurationModeResponse() : soap(NULL) { } + virtual ~_sai__SetZeroTouchConfigurationModeResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetProvisioningAuditRecord +#define SOAP_TYPE__sai__GetProvisioningAuditRecord (151) +/* sai:GetProvisioningAuditRecord */ +class SOAP_CMAC _sai__GetProvisioningAuditRecord +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 151; } /* = unique id SOAP_TYPE__sai__GetProvisioningAuditRecord */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetProvisioningAuditRecord() : soap(NULL) { } + virtual ~_sai__GetProvisioningAuditRecord() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetProvisioningAuditRecordResponse +#define SOAP_TYPE__sai__GetProvisioningAuditRecordResponse (152) +/* sai:GetProvisioningAuditRecordResponse */ +class SOAP_CMAC _sai__GetProvisioningAuditRecordResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + sai__ProvisioningAuditRecordType *ProvisioningAuditRecord; /* required element of type sai:ProvisioningAuditRecordType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 152; } /* = unique id SOAP_TYPE__sai__GetProvisioningAuditRecordResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetProvisioningAuditRecordResponse() : ProvisioningAuditRecord(NULL), soap(NULL) { } + virtual ~_sai__GetProvisioningAuditRecordResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetProvisioningPID +#define SOAP_TYPE__sai__GetProvisioningPID (153) +/* sai:GetProvisioningPID */ +class SOAP_CMAC _sai__GetProvisioningPID +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 153; } /* = unique id SOAP_TYPE__sai__GetProvisioningPID */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetProvisioningPID() : soap(NULL) { } + virtual ~_sai__GetProvisioningPID() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetProvisioningPIDResponse +#define SOAP_TYPE__sai__GetProvisioningPIDResponse (154) +/* sai:GetProvisioningPIDResponse */ +class SOAP_CMAC _sai__GetProvisioningPIDResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + xsd__base64Binary PID; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 154; } /* = unique id SOAP_TYPE__sai__GetProvisioningPIDResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetProvisioningPIDResponse() : soap(NULL) { } + virtual ~_sai__GetProvisioningPIDResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__ExtendProvisioningPeriod +#define SOAP_TYPE__sai__ExtendProvisioningPeriod (155) +/* sai:ExtendProvisioningPeriod */ +class SOAP_CMAC _sai__ExtendProvisioningPeriod +{ +public: + unsigned int Duration; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 155; } /* = unique id SOAP_TYPE__sai__ExtendProvisioningPeriod */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__ExtendProvisioningPeriod() : soap(NULL) { } + virtual ~_sai__ExtendProvisioningPeriod() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__ExtendProvisioningPeriodResponse +#define SOAP_TYPE__sai__ExtendProvisioningPeriodResponse (156) +/* sai:ExtendProvisioningPeriodResponse */ +class SOAP_CMAC _sai__ExtendProvisioningPeriodResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 156; } /* = unique id SOAP_TYPE__sai__ExtendProvisioningPeriodResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__ExtendProvisioningPeriodResponse() : soap(NULL) { } + virtual ~_sai__ExtendProvisioningPeriodResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetRealmAuthOptions +#define SOAP_TYPE__sai__GetRealmAuthOptions (157) +/* sai:GetRealmAuthOptions */ +class SOAP_CMAC _sai__GetRealmAuthOptions +{ +public: + enum sai__UserAclRealmType Realm; /* required element of type sai:UserAclRealmType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 157; } /* = unique id SOAP_TYPE__sai__GetRealmAuthOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetRealmAuthOptions() : soap(NULL) { } + virtual ~_sai__GetRealmAuthOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetRealmAuthOptionsResponse +#define SOAP_TYPE__sai__GetRealmAuthOptionsResponse (158) +/* sai:GetRealmAuthOptionsResponse */ +class SOAP_CMAC _sai__GetRealmAuthOptionsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + enum sai__HTTPAuthOptionType HTTPAuthOption; /* required element of type sai:HTTPAuthOptionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 158; } /* = unique id SOAP_TYPE__sai__GetRealmAuthOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetRealmAuthOptionsResponse() : soap(NULL) { } + virtual ~_sai__GetRealmAuthOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetRealmAuthOptions +#define SOAP_TYPE__sai__SetRealmAuthOptions (159) +/* sai:SetRealmAuthOptions */ +class SOAP_CMAC _sai__SetRealmAuthOptions +{ +public: + enum sai__UserAclRealmType Realm; /* required element of type sai:UserAclRealmType */ + enum sai__HTTPAuthOptionType HTTPAuthOption; /* required element of type sai:HTTPAuthOptionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 159; } /* = unique id SOAP_TYPE__sai__SetRealmAuthOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetRealmAuthOptions() : soap(NULL) { } + virtual ~_sai__SetRealmAuthOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetRealmAuthOptionsResponse +#define SOAP_TYPE__sai__SetRealmAuthOptionsResponse (160) +/* sai:SetRealmAuthOptionsResponse */ +class SOAP_CMAC _sai__SetRealmAuthOptionsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type sai:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 160; } /* = unique id SOAP_TYPE__sai__SetRealmAuthOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetRealmAuthOptionsResponse() : soap(NULL) { } + virtual ~_sai__SetRealmAuthOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetEnvironmentDetection +#define SOAP_TYPE__sai__SetEnvironmentDetection (161) +/* sai:SetEnvironmentDetection */ +class SOAP_CMAC _sai__SetEnvironmentDetection +{ +public: + sai__EnvironmentDetectionType *Params; /* required element of type sai:EnvironmentDetectionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 161; } /* = unique id SOAP_TYPE__sai__SetEnvironmentDetection */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetEnvironmentDetection() : Params(NULL), soap(NULL) { } + virtual ~_sai__SetEnvironmentDetection() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetEnvironmentDetectionResponse +#define SOAP_TYPE__sai__SetEnvironmentDetectionResponse (162) +/* sai:SetEnvironmentDetectionResponse */ +class SOAP_CMAC _sai__SetEnvironmentDetectionResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 162; } /* = unique id SOAP_TYPE__sai__SetEnvironmentDetectionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetEnvironmentDetectionResponse() : soap(NULL) { } + virtual ~_sai__SetEnvironmentDetectionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetEnvironmentDetection +#define SOAP_TYPE__sai__GetEnvironmentDetection (163) +/* sai:GetEnvironmentDetection */ +class SOAP_CMAC _sai__GetEnvironmentDetection +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 163; } /* = unique id SOAP_TYPE__sai__GetEnvironmentDetection */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetEnvironmentDetection() : soap(NULL) { } + virtual ~_sai__GetEnvironmentDetection() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetEnvironmentDetectionResponse +#define SOAP_TYPE__sai__GetEnvironmentDetectionResponse (164) +/* sai:GetEnvironmentDetectionResponse */ +class SOAP_CMAC _sai__GetEnvironmentDetectionResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + sai__EnvironmentDetectionType *Params; /* required element of type sai:EnvironmentDetectionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 164; } /* = unique id SOAP_TYPE__sai__GetEnvironmentDetectionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetEnvironmentDetectionResponse() : Params(NULL), soap(NULL) { } + virtual ~_sai__GetEnvironmentDetectionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnumeratePowerPackages +#define SOAP_TYPE__sai__EnumeratePowerPackages (165) +/* sai:EnumeratePowerPackages */ +class SOAP_CMAC _sai__EnumeratePowerPackages +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 165; } /* = unique id SOAP_TYPE__sai__EnumeratePowerPackages */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnumeratePowerPackages() : soap(NULL) { } + virtual ~_sai__EnumeratePowerPackages() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnumeratePowerPackagesResponse +#define SOAP_TYPE__sai__EnumeratePowerPackagesResponse (166) +/* sai:EnumeratePowerPackagesResponse */ +class SOAP_CMAC _sai__EnumeratePowerPackagesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + std::vectorPolicyGUID; /* optional element of type cmn:GuidBuf */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 166; } /* = unique id SOAP_TYPE__sai__EnumeratePowerPackagesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnumeratePowerPackagesResponse() : soap(NULL) { } + virtual ~_sai__EnumeratePowerPackagesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetActivePowerPackage +#define SOAP_TYPE__sai__GetActivePowerPackage (167) +/* sai:GetActivePowerPackage */ +class SOAP_CMAC _sai__GetActivePowerPackage +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 167; } /* = unique id SOAP_TYPE__sai__GetActivePowerPackage */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetActivePowerPackage() : soap(NULL) { } + virtual ~_sai__GetActivePowerPackage() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetActivePowerPackageResponse +#define SOAP_TYPE__sai__GetActivePowerPackageResponse (168) +/* sai:GetActivePowerPackageResponse */ +class SOAP_CMAC _sai__GetActivePowerPackageResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + xsd__base64Binary PolicyGUID; /* required element of type cmn:GuidBuf */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 168; } /* = unique id SOAP_TYPE__sai__GetActivePowerPackageResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetActivePowerPackageResponse() : soap(NULL) { } + virtual ~_sai__GetActivePowerPackageResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetPowerPackage +#define SOAP_TYPE__sai__GetPowerPackage (169) +/* sai:GetPowerPackage */ +class SOAP_CMAC _sai__GetPowerPackage +{ +public: + xsd__base64Binary PolicyGUID; /* required element of type cmn:GuidBuf */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 169; } /* = unique id SOAP_TYPE__sai__GetPowerPackage */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetPowerPackage() : soap(NULL) { } + virtual ~_sai__GetPowerPackage() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetPowerPackageResponse +#define SOAP_TYPE__sai__GetPowerPackageResponse (170) +/* sai:GetPowerPackageResponse */ +class SOAP_CMAC _sai__GetPowerPackageResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + std::string PolicyDescriptor; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 170; } /* = unique id SOAP_TYPE__sai__GetPowerPackageResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetPowerPackageResponse() : soap(NULL) { } + virtual ~_sai__GetPowerPackageResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetActivePowerPackage +#define SOAP_TYPE__sai__SetActivePowerPackage (171) +/* sai:SetActivePowerPackage */ +class SOAP_CMAC _sai__SetActivePowerPackage +{ +public: + xsd__base64Binary PolicyGUID; /* required element of type cmn:GuidBuf */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 171; } /* = unique id SOAP_TYPE__sai__SetActivePowerPackage */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetActivePowerPackage() : soap(NULL) { } + virtual ~_sai__SetActivePowerPackage() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetActivePowerPackageResponse +#define SOAP_TYPE__sai__SetActivePowerPackageResponse (172) +/* sai:SetActivePowerPackageResponse */ +class SOAP_CMAC _sai__SetActivePowerPackageResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 172; } /* = unique id SOAP_TYPE__sai__SetActivePowerPackageResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetActivePowerPackageResponse() : soap(NULL) { } + virtual ~_sai__SetActivePowerPackageResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetGlobalPowerPolicy +#define SOAP_TYPE__sai__SetGlobalPowerPolicy (173) +/* sai:SetGlobalPowerPolicy */ +class SOAP_CMAC _sai__SetGlobalPowerPolicy +{ +public: + sai__GlobalPowerPolicyType *GlobalPowerPolicy; /* required element of type sai:GlobalPowerPolicyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 173; } /* = unique id SOAP_TYPE__sai__SetGlobalPowerPolicy */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetGlobalPowerPolicy() : GlobalPowerPolicy(NULL), soap(NULL) { } + virtual ~_sai__SetGlobalPowerPolicy() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetGlobalPowerPolicyResponse +#define SOAP_TYPE__sai__SetGlobalPowerPolicyResponse (174) +/* sai:SetGlobalPowerPolicyResponse */ +class SOAP_CMAC _sai__SetGlobalPowerPolicyResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 174; } /* = unique id SOAP_TYPE__sai__SetGlobalPowerPolicyResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetGlobalPowerPolicyResponse() : soap(NULL) { } + virtual ~_sai__SetGlobalPowerPolicyResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetGlobalPowerPolicy +#define SOAP_TYPE__sai__GetGlobalPowerPolicy (175) +/* sai:GetGlobalPowerPolicy */ +class SOAP_CMAC _sai__GetGlobalPowerPolicy +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 175; } /* = unique id SOAP_TYPE__sai__GetGlobalPowerPolicy */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetGlobalPowerPolicy() : soap(NULL) { } + virtual ~_sai__GetGlobalPowerPolicy() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetGlobalPowerPolicyResponse +#define SOAP_TYPE__sai__GetGlobalPowerPolicyResponse (176) +/* sai:GetGlobalPowerPolicyResponse */ +class SOAP_CMAC _sai__GetGlobalPowerPolicyResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + sai__GlobalPowerPolicyType *GlobalPowerPolicy; /* required element of type sai:GlobalPowerPolicyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 176; } /* = unique id SOAP_TYPE__sai__GetGlobalPowerPolicyResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetGlobalPowerPolicyResponse() : GlobalPowerPolicy(NULL), soap(NULL) { } + virtual ~_sai__GetGlobalPowerPolicyResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreAddKey +#define SOAP_TYPE__sai__CertStoreAddKey (177) +/* sai:CertStoreAddKey */ +class SOAP_CMAC _sai__CertStoreAddKey +{ +public: + cstr__KeyPairType *KeyPair; /* required element of type cstr:KeyPairType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 177; } /* = unique id SOAP_TYPE__sai__CertStoreAddKey */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreAddKey() : KeyPair(NULL), soap(NULL) { } + virtual ~_sai__CertStoreAddKey() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreAddKeyResponse +#define SOAP_TYPE__sai__CertStoreAddKeyResponse (178) +/* sai:CertStoreAddKeyResponse */ +class SOAP_CMAC _sai__CertStoreAddKeyResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + unsigned int KeyPairHandle; /* required element of type cstr:KeyPairHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 178; } /* = unique id SOAP_TYPE__sai__CertStoreAddKeyResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreAddKeyResponse() : soap(NULL) { } + virtual ~_sai__CertStoreAddKeyResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreEnumerateKeys +#define SOAP_TYPE__sai__CertStoreEnumerateKeys (179) +/* sai:CertStoreEnumerateKeys */ +class SOAP_CMAC _sai__CertStoreEnumerateKeys +{ +public: + unsigned int *FindByCert; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 179; } /* = unique id SOAP_TYPE__sai__CertStoreEnumerateKeys */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreEnumerateKeys() : FindByCert(NULL), soap(NULL) { } + virtual ~_sai__CertStoreEnumerateKeys() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreEnumerateKeysResponse +#define SOAP_TYPE__sai__CertStoreEnumerateKeysResponse (180) +/* sai:CertStoreEnumerateKeysResponse */ +class SOAP_CMAC _sai__CertStoreEnumerateKeysResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + std::vectorKeyPairHandles; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 180; } /* = unique id SOAP_TYPE__sai__CertStoreEnumerateKeysResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreEnumerateKeysResponse() : soap(NULL) { } + virtual ~_sai__CertStoreEnumerateKeysResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreGetKey +#define SOAP_TYPE__sai__CertStoreGetKey (181) +/* sai:CertStoreGetKey */ +class SOAP_CMAC _sai__CertStoreGetKey +{ +public: + unsigned int KeyPairHandle; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 181; } /* = unique id SOAP_TYPE__sai__CertStoreGetKey */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreGetKey() : soap(NULL) { } + virtual ~_sai__CertStoreGetKey() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreGetKeyResponse +#define SOAP_TYPE__sai__CertStoreGetKeyResponse (182) +/* sai:CertStoreGetKeyResponse */ +class SOAP_CMAC _sai__CertStoreGetKeyResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + cstr__KeyPairType *PublicKey; /* required element of type cstr:KeyPairType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 182; } /* = unique id SOAP_TYPE__sai__CertStoreGetKeyResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreGetKeyResponse() : PublicKey(NULL), soap(NULL) { } + virtual ~_sai__CertStoreGetKeyResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreRemoveKey +#define SOAP_TYPE__sai__CertStoreRemoveKey (183) +/* sai:CertStoreRemoveKey */ +class SOAP_CMAC _sai__CertStoreRemoveKey +{ +public: + unsigned int KeyPairHandle; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 183; } /* = unique id SOAP_TYPE__sai__CertStoreRemoveKey */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreRemoveKey() : soap(NULL) { } + virtual ~_sai__CertStoreRemoveKey() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreRemoveKeyResponse +#define SOAP_TYPE__sai__CertStoreRemoveKeyResponse (184) +/* sai:CertStoreRemoveKeyResponse */ +class SOAP_CMAC _sai__CertStoreRemoveKeyResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 184; } /* = unique id SOAP_TYPE__sai__CertStoreRemoveKeyResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreRemoveKeyResponse() : soap(NULL) { } + virtual ~_sai__CertStoreRemoveKeyResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreAddCertificate +#define SOAP_TYPE__sai__CertStoreAddCertificate (185) +/* sai:CertStoreAddCertificate */ +class SOAP_CMAC _sai__CertStoreAddCertificate +{ +public: + sai__CertificateType *Certificate; /* required element of type sai:CertificateType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 185; } /* = unique id SOAP_TYPE__sai__CertStoreAddCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreAddCertificate() : Certificate(NULL), soap(NULL) { } + virtual ~_sai__CertStoreAddCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreAddCertificateResponse +#define SOAP_TYPE__sai__CertStoreAddCertificateResponse (186) +/* sai:CertStoreAddCertificateResponse */ +class SOAP_CMAC _sai__CertStoreAddCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + unsigned int CertHandle; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 186; } /* = unique id SOAP_TYPE__sai__CertStoreAddCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreAddCertificateResponse() : soap(NULL) { } + virtual ~_sai__CertStoreAddCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreEnumerateCertificates +#define SOAP_TYPE__sai__CertStoreEnumerateCertificates (187) +/* sai:CertStoreEnumerateCertificates */ +class SOAP_CMAC _sai__CertStoreEnumerateCertificates +{ +public: + std::string *FindByDNName; /* optional element of type xsd:string */ + std::string *FindByUsage; /* optional element of type xsd:string */ + std::string *FindByIssuer; /* optional element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 187; } /* = unique id SOAP_TYPE__sai__CertStoreEnumerateCertificates */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreEnumerateCertificates() : FindByDNName(NULL), FindByUsage(NULL), FindByIssuer(NULL), soap(NULL) { } + virtual ~_sai__CertStoreEnumerateCertificates() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse +#define SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse (188) +/* sai:CertStoreEnumerateCertificatesResponse */ +class SOAP_CMAC _sai__CertStoreEnumerateCertificatesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + std::vectorCertHandles; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 188; } /* = unique id SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreEnumerateCertificatesResponse() : soap(NULL) { } + virtual ~_sai__CertStoreEnumerateCertificatesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreGetCertificate +#define SOAP_TYPE__sai__CertStoreGetCertificate (189) +/* sai:CertStoreGetCertificate */ +class SOAP_CMAC _sai__CertStoreGetCertificate +{ +public: + unsigned int CertHandle; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 189; } /* = unique id SOAP_TYPE__sai__CertStoreGetCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreGetCertificate() : soap(NULL) { } + virtual ~_sai__CertStoreGetCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreGetCertificateResponse +#define SOAP_TYPE__sai__CertStoreGetCertificateResponse (190) +/* sai:CertStoreGetCertificateResponse */ +class SOAP_CMAC _sai__CertStoreGetCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + sai__CertificateType *Certificate; /* required element of type sai:CertificateType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 190; } /* = unique id SOAP_TYPE__sai__CertStoreGetCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreGetCertificateResponse() : Certificate(NULL), soap(NULL) { } + virtual ~_sai__CertStoreGetCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreRemoveCertificate +#define SOAP_TYPE__sai__CertStoreRemoveCertificate (191) +/* sai:CertStoreRemoveCertificate */ +class SOAP_CMAC _sai__CertStoreRemoveCertificate +{ +public: + unsigned int CertHandle; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 191; } /* = unique id SOAP_TYPE__sai__CertStoreRemoveCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreRemoveCertificate() : soap(NULL) { } + virtual ~_sai__CertStoreRemoveCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreRemoveCertificateResponse +#define SOAP_TYPE__sai__CertStoreRemoveCertificateResponse (192) +/* sai:CertStoreRemoveCertificateResponse */ +class SOAP_CMAC _sai__CertStoreRemoveCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 192; } /* = unique id SOAP_TYPE__sai__CertStoreRemoveCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreRemoveCertificateResponse() : soap(NULL) { } + virtual ~_sai__CertStoreRemoveCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreGetPKCS10Request +#define SOAP_TYPE__sai__CertStoreGetPKCS10Request (193) +/* sai:CertStoreGetPKCS10Request */ +class SOAP_CMAC _sai__CertStoreGetPKCS10Request +{ +public: + unsigned int KeyPairHandle; /* required element of type sai:CertificateHandleType */ + std::string *DNName; /* optional element of type xsd:string */ + std::string *Usage; /* optional element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 193; } /* = unique id SOAP_TYPE__sai__CertStoreGetPKCS10Request */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreGetPKCS10Request() : DNName(NULL), Usage(NULL), soap(NULL) { } + virtual ~_sai__CertStoreGetPKCS10Request() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse +#define SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse (194) +/* sai:CertStoreGetPKCS10RequestResponse */ +class SOAP_CMAC _sai__CertStoreGetPKCS10RequestResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + xsd__base64Binary CertificateRequest; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 194; } /* = unique id SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreGetPKCS10RequestResponse() : soap(NULL) { } + virtual ~_sai__CertStoreGetPKCS10RequestResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreUpdateCertificate +#define SOAP_TYPE__sai__CertStoreUpdateCertificate (195) +/* sai:CertStoreUpdateCertificate */ +class SOAP_CMAC _sai__CertStoreUpdateCertificate +{ +public: + unsigned int CertHandle; /* required element of type sai:CertificateHandleType */ + sai__CertificateType *Certificate; /* required element of type sai:CertificateType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 195; } /* = unique id SOAP_TYPE__sai__CertStoreUpdateCertificate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreUpdateCertificate() : Certificate(NULL), soap(NULL) { } + virtual ~_sai__CertStoreUpdateCertificate() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__CertStoreUpdateCertificateResponse +#define SOAP_TYPE__sai__CertStoreUpdateCertificateResponse (196) +/* sai:CertStoreUpdateCertificateResponse */ +class SOAP_CMAC _sai__CertStoreUpdateCertificateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 196; } /* = unique id SOAP_TYPE__sai__CertStoreUpdateCertificateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__CertStoreUpdateCertificateResponse() : soap(NULL) { } + virtual ~_sai__CertStoreUpdateCertificateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTLSCredentials +#define SOAP_TYPE__sai__SetTLSCredentials (197) +/* sai:SetTLSCredentials */ +class SOAP_CMAC _sai__SetTLSCredentials +{ +public: + unsigned int *CertHandle; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 197; } /* = unique id SOAP_TYPE__sai__SetTLSCredentials */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTLSCredentials() : CertHandle(NULL), soap(NULL) { } + virtual ~_sai__SetTLSCredentials() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetTLSCredentialsResponse +#define SOAP_TYPE__sai__SetTLSCredentialsResponse (198) +/* sai:SetTLSCredentialsResponse */ +class SOAP_CMAC _sai__SetTLSCredentialsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 198; } /* = unique id SOAP_TYPE__sai__SetTLSCredentialsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetTLSCredentialsResponse() : soap(NULL) { } + virtual ~_sai__SetTLSCredentialsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTLSCredentials +#define SOAP_TYPE__sai__GetTLSCredentials (199) +/* sai:GetTLSCredentials */ +class SOAP_CMAC _sai__GetTLSCredentials +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 199; } /* = unique id SOAP_TYPE__sai__GetTLSCredentials */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTLSCredentials() : soap(NULL) { } + virtual ~_sai__GetTLSCredentials() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetTLSCredentialsResponse +#define SOAP_TYPE__sai__GetTLSCredentialsResponse (200) +/* sai:GetTLSCredentialsResponse */ +class SOAP_CMAC _sai__GetTLSCredentialsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + unsigned int *CertHandle; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 200; } /* = unique id SOAP_TYPE__sai__GetTLSCredentialsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetTLSCredentialsResponse() : CertHandle(NULL), soap(NULL) { } + virtual ~_sai__GetTLSCredentialsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnableVpnRouting +#define SOAP_TYPE__sai__EnableVpnRouting (201) +/* sai:EnableVpnRouting */ +class SOAP_CMAC _sai__EnableVpnRouting +{ +public: + bool Enable; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 201; } /* = unique id SOAP_TYPE__sai__EnableVpnRouting */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnableVpnRouting() : soap(NULL) { } + virtual ~_sai__EnableVpnRouting() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__EnableVpnRoutingResponse +#define SOAP_TYPE__sai__EnableVpnRoutingResponse (202) +/* sai:EnableVpnRoutingResponse */ +class SOAP_CMAC _sai__EnableVpnRoutingResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 202; } /* = unique id SOAP_TYPE__sai__EnableVpnRoutingResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__EnableVpnRoutingResponse() : soap(NULL) { } + virtual ~_sai__EnableVpnRoutingResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetConfigurationServerFQDN +#define SOAP_TYPE__sai__SetConfigurationServerFQDN (203) +/* sai:SetConfigurationServerFQDN */ +class SOAP_CMAC _sai__SetConfigurationServerFQDN +{ +public: + std::string fqdn; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 203; } /* = unique id SOAP_TYPE__sai__SetConfigurationServerFQDN */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetConfigurationServerFQDN() : soap(NULL) { } + virtual ~_sai__SetConfigurationServerFQDN() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetConfigurationServerFQDNResponse +#define SOAP_TYPE__sai__SetConfigurationServerFQDNResponse (204) +/* sai:SetConfigurationServerFQDNResponse */ +class SOAP_CMAC _sai__SetConfigurationServerFQDNResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 204; } /* = unique id SOAP_TYPE__sai__SetConfigurationServerFQDNResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetConfigurationServerFQDNResponse() : soap(NULL) { } + virtual ~_sai__SetConfigurationServerFQDNResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetConfigurationServerFQDN +#define SOAP_TYPE__sai__GetConfigurationServerFQDN (205) +/* sai:GetConfigurationServerFQDN */ +class SOAP_CMAC _sai__GetConfigurationServerFQDN +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 205; } /* = unique id SOAP_TYPE__sai__GetConfigurationServerFQDN */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetConfigurationServerFQDN() : soap(NULL) { } + virtual ~_sai__GetConfigurationServerFQDN() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetConfigurationServerFQDNResponse +#define SOAP_TYPE__sai__GetConfigurationServerFQDNResponse (206) +/* sai:GetConfigurationServerFQDNResponse */ +class SOAP_CMAC _sai__GetConfigurationServerFQDNResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + std::string fqdn; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 206; } /* = unique id SOAP_TYPE__sai__GetConfigurationServerFQDNResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetConfigurationServerFQDNResponse() : soap(NULL) { } + virtual ~_sai__GetConfigurationServerFQDNResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetAclEnabledState +#define SOAP_TYPE__sai__SetAclEnabledState (207) +/* sai:SetAclEnabledState */ +class SOAP_CMAC _sai__SetAclEnabledState +{ +public: + unsigned int Handle; /* required element of type sai:UserAclEntryHandleType */ + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 207; } /* = unique id SOAP_TYPE__sai__SetAclEnabledState */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetAclEnabledState() : soap(NULL) { } + virtual ~_sai__SetAclEnabledState() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__SetAclEnabledStateResponse +#define SOAP_TYPE__sai__SetAclEnabledStateResponse (208) +/* sai:SetAclEnabledStateResponse */ +class SOAP_CMAC _sai__SetAclEnabledStateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 208; } /* = unique id SOAP_TYPE__sai__SetAclEnabledStateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__SetAclEnabledStateResponse() : soap(NULL) { } + virtual ~_sai__SetAclEnabledStateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetAclEnabledState +#define SOAP_TYPE__sai__GetAclEnabledState (209) +/* sai:GetAclEnabledState */ +class SOAP_CMAC _sai__GetAclEnabledState +{ +public: + unsigned int Handle; /* required element of type sai:UserAclEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 209; } /* = unique id SOAP_TYPE__sai__GetAclEnabledState */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetAclEnabledState() : soap(NULL) { } + virtual ~_sai__GetAclEnabledState() { } +}; +#endif + +#ifndef SOAP_TYPE__sai__GetAclEnabledStateResponse +#define SOAP_TYPE__sai__GetAclEnabledStateResponse (210) +/* sai:GetAclEnabledStateResponse */ +class SOAP_CMAC _sai__GetAclEnabledStateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 210; } /* = unique id SOAP_TYPE__sai__GetAclEnabledStateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _sai__GetAclEnabledStateResponse() : soap(NULL) { } + virtual ~_sai__GetAclEnabledStateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__UserCredentialsType +#define SOAP_TYPE_xcfg__UserCredentialsType (211) +/* xcfg:UserCredentialsType */ +class SOAP_CMAC xcfg__UserCredentialsType +{ +public: + std::string Username; /* required element of type xsd:string */ + std::string Password; /* required element of type xsd:string */ + std::string *Domain; /* optional element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 211; } /* = unique id SOAP_TYPE_xcfg__UserCredentialsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__UserCredentialsType() : Domain(NULL), soap(NULL) { } + virtual ~xcfg__UserCredentialsType() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__CertificateNameType +#define SOAP_TYPE_xcfg__CertificateNameType (212) +/* xcfg:CertificateNameType */ +class SOAP_CMAC xcfg__CertificateNameType +{ +public: + std::string ServerOrCertName; /* required element of type xsd:string */ + enum xcfg__CertNameOptionsType Options; /* required element of type xcfg:CertNameOptionsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 212; } /* = unique id SOAP_TYPE_xcfg__CertificateNameType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__CertificateNameType() : soap(NULL) { } + virtual ~xcfg__CertificateNameType() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__ManualPACType +#define SOAP_TYPE_xcfg__ManualPACType (213) +/* xcfg:ManualPACType */ +class SOAP_CMAC xcfg__ManualPACType +{ +public: + xsd__base64Binary PACData; /* required element of type xsd:base64Binary */ + std::string *Password; /* optional element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 213; } /* = unique id SOAP_TYPE_xcfg__ManualPACType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__ManualPACType() : Password(NULL), soap(NULL) { } + virtual ~xcfg__ManualPACType() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__ServerIdentityType +#define SOAP_TYPE_xcfg__ServerIdentityType (214) +/* xcfg:ServerIdentityType */ +class SOAP_CMAC xcfg__ServerIdentityType +{ +public: + unsigned int *CertificateIssuer; /* optional element of type sai:CertificateHandleType */ + xcfg__CertificateNameType *ServerNameOptions; /* optional element of type xcfg:CertificateNameType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 214; } /* = unique id SOAP_TYPE_xcfg__ServerIdentityType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__ServerIdentityType() : CertificateIssuer(NULL), ServerNameOptions(NULL), soap(NULL) { } + virtual ~xcfg__ServerIdentityType() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__XProfileTLSType +#define SOAP_TYPE_xcfg__XProfileTLSType (215) +/* xcfg:XProfileTLSType */ +class SOAP_CMAC xcfg__XProfileTLSType +{ +public: + std::string Username; /* required element of type xsd:string */ + xcfg__ServerIdentityType *ServerIdentity; /* required element of type xcfg:ServerIdentityType */ + unsigned int ClientCertificate; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 215; } /* = unique id SOAP_TYPE_xcfg__XProfileTLSType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__XProfileTLSType() : ServerIdentity(NULL), soap(NULL) { } + virtual ~xcfg__XProfileTLSType() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type +#define SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type (216) +/* xcfg:XProfileTTLS_MSCHAPv2Type */ +class SOAP_CMAC xcfg__XProfileTTLS_USCOREMSCHAPv2Type +{ +public: + std::string *RoamingIdentity; /* optional element of type xsd:string */ + xcfg__ServerIdentityType *ServerIdentity; /* required element of type xcfg:ServerIdentityType */ + xcfg__UserCredentialsType *UserCredentials; /* required element of type xcfg:UserCredentialsType */ + unsigned int *ClientCertificate; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 216; } /* = unique id SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__XProfileTTLS_USCOREMSCHAPv2Type() : RoamingIdentity(NULL), ServerIdentity(NULL), UserCredentials(NULL), ClientCertificate(NULL), soap(NULL) { } + virtual ~xcfg__XProfileTTLS_USCOREMSCHAPv2Type() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type +#define SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type (217) +/* xcfg:XProfilePEAP_MSCHAPv2Type */ +class SOAP_CMAC xcfg__XProfilePEAP_USCOREMSCHAPv2Type +{ +public: + std::string *RoamingIdentity; /* optional element of type xsd:string */ + xcfg__ServerIdentityType *ServerIdentity; /* required element of type xcfg:ServerIdentityType */ + xcfg__UserCredentialsType *UserCredentials; /* required element of type xcfg:UserCredentialsType */ + unsigned int *ClientCertificate; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 217; } /* = unique id SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__XProfilePEAP_USCOREMSCHAPv2Type() : RoamingIdentity(NULL), ServerIdentity(NULL), UserCredentials(NULL), ClientCertificate(NULL), soap(NULL) { } + virtual ~xcfg__XProfilePEAP_USCOREMSCHAPv2Type() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType +#define SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType (218) +/* xcfg:XProfileEAP_GTCType */ +class SOAP_CMAC xcfg__XProfileEAP_USCOREGTCType +{ +public: + xcfg__UserCredentialsType *UserCredentials; /* required element of type xcfg:UserCredentialsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 218; } /* = unique id SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__XProfileEAP_USCOREGTCType() : UserCredentials(NULL), soap(NULL) { } + virtual ~xcfg__XProfileEAP_USCOREGTCType() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type +#define SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type (219) +/* xcfg:XProfileEAPFAST_MSCHAPv2Type */ +class SOAP_CMAC xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type +{ +public: + std::string *RoamingIdentity; /* optional element of type xsd:string */ + xcfg__ServerIdentityType *ServerIdentity; /* required element of type xcfg:ServerIdentityType */ + xcfg__UserCredentialsType *UserCredentials; /* required element of type xcfg:UserCredentialsType */ + xcfg__ManualPACType *ProtectedAccessCredentials; /* optional element of type xcfg:ManualPACType */ + unsigned int *ClientCertificate; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 219; } /* = unique id SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type() : RoamingIdentity(NULL), ServerIdentity(NULL), UserCredentials(NULL), ProtectedAccessCredentials(NULL), ClientCertificate(NULL), soap(NULL) { } + virtual ~xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType +#define SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType (220) +/* xcfg:XProfileEAPFAST_GTCType */ +class SOAP_CMAC xcfg__XProfileEAPFAST_USCOREGTCType +{ +public: + std::string *RoamingIdentity; /* optional element of type xsd:string */ + xcfg__ServerIdentityType *ServerIdentity; /* required element of type xcfg:ServerIdentityType */ + xcfg__UserCredentialsType *UserCredentials; /* required element of type xcfg:UserCredentialsType */ + xcfg__ManualPACType *ProtectedAccessCredentials; /* optional element of type xcfg:ManualPACType */ + unsigned int *ClientCertificate; /* optional element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 220; } /* = unique id SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__XProfileEAPFAST_USCOREGTCType() : RoamingIdentity(NULL), ServerIdentity(NULL), UserCredentials(NULL), ProtectedAccessCredentials(NULL), ClientCertificate(NULL), soap(NULL) { } + virtual ~xcfg__XProfileEAPFAST_USCOREGTCType() { } +}; +#endif + +#ifndef SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType +#define SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType (221) +/* xcfg:XProfileEAPFAST_TLSType */ +class SOAP_CMAC xcfg__XProfileEAPFAST_USCORETLSType +{ +public: + std::string *RoamingIdentity; /* optional element of type xsd:string */ + xcfg__ServerIdentityType *ServerIdentity; /* required element of type xcfg:ServerIdentityType */ + xcfg__UserCredentialsType *UserCredentials; /* required element of type xcfg:UserCredentialsType */ + xcfg__ManualPACType *ProtectedAccessCredentials; /* optional element of type xcfg:ManualPACType */ + unsigned int ClientCertificate; /* required element of type sai:CertificateHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 221; } /* = unique id SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__XProfileEAPFAST_USCORETLSType() : RoamingIdentity(NULL), ServerIdentity(NULL), UserCredentials(NULL), ProtectedAccessCredentials(NULL), soap(NULL) { } + virtual ~xcfg__XProfileEAPFAST_USCORETLSType() { } +}; +#endif + +#ifndef SOAP_TYPE__xcfg__union_XProfileType +#define SOAP_TYPE__xcfg__union_XProfileType (725) +/* xsd:choice */ +union _xcfg__union_XProfileType +{ +#define SOAP_UNION__xcfg__union_XProfileType_TLS (1) + xcfg__XProfileTLSType *TLS; +#define SOAP_UNION__xcfg__union_XProfileType_TTLS_USCOREMSCHAPv2 (2) + xcfg__XProfileTTLS_USCOREMSCHAPv2Type *TTLS_USCOREMSCHAPv2; +#define SOAP_UNION__xcfg__union_XProfileType_PEAP_USCOREMSCHAPv2 (3) + xcfg__XProfilePEAP_USCOREMSCHAPv2Type *PEAP_USCOREMSCHAPv2; +#define SOAP_UNION__xcfg__union_XProfileType_EAP_USCOREGTC (4) + xcfg__XProfileEAP_USCOREGTCType *EAP_USCOREGTC; +#define SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCOREMSCHAPv2 (5) + xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *EAPFAST_USCOREMSCHAPv2; +#define SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCOREGTC (6) + xcfg__XProfileEAPFAST_USCOREGTCType *EAPFAST_USCOREGTC; +#define SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCORETLS (7) + xcfg__XProfileEAPFAST_USCORETLSType *EAPFAST_USCORETLS; +}; +#endif + +#ifndef SOAP_TYPE_xcfg__XProfileType +#define SOAP_TYPE_xcfg__XProfileType (222) +/* xcfg:XProfileType */ +class SOAP_CMAC xcfg__XProfileType +{ +public: + int __union_XProfileType; /* union discriminant (of union defined below) */ + union _xcfg__union_XProfileType union_XProfileType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 222; } /* = unique id SOAP_TYPE_xcfg__XProfileType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + xcfg__XProfileType() : soap(NULL) { } + virtual ~xcfg__XProfileType() { } +}; +#endif + +#ifndef SOAP_TYPE_net__StaticIPv4ParametersType +#define SOAP_TYPE_net__StaticIPv4ParametersType (223) +/* net:StaticIPv4ParametersType */ +class SOAP_CMAC net__StaticIPv4ParametersType +{ +public: + unsigned int LocalAddress; /* required element of type net:IPv4AddressType */ + unsigned int SubnetMask; /* required element of type net:IPv4AddressType */ + unsigned int DefaultGatewayAddress; /* required element of type net:IPv4AddressType */ + unsigned int PrimaryDnsAddress; /* required element of type net:IPv4AddressType */ + unsigned int SecondaryDnsAddress; /* required element of type net:IPv4AddressType */ + std::string *DomainName; /* optional element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 223; } /* = unique id SOAP_TYPE_net__StaticIPv4ParametersType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + net__StaticIPv4ParametersType() : DomainName(NULL), soap(NULL) { } + virtual ~net__StaticIPv4ParametersType() { } +}; +#endif + +#ifndef SOAP_TYPE_net__IPv4ParametersType +#define SOAP_TYPE_net__IPv4ParametersType (224) +/* net:IPv4ParametersType */ +class SOAP_CMAC net__IPv4ParametersType +{ +public: + unsigned int LocalAddress; /* required element of type net:IPv4AddressType */ + unsigned int SubnetMask; /* required element of type net:IPv4AddressType */ + unsigned int DefaultGatewayAddress; /* required element of type net:IPv4AddressType */ + unsigned int PrimaryDnsAddress; /* required element of type net:IPv4AddressType */ + unsigned int SecondaryDnsAddress; /* required element of type net:IPv4AddressType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 224; } /* = unique id SOAP_TYPE_net__IPv4ParametersType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + net__IPv4ParametersType() : soap(NULL) { } + virtual ~net__IPv4ParametersType() { } +}; +#endif + +#ifndef SOAP_TYPE_net__InterfaceDescriptorSetType +#define SOAP_TYPE_net__InterfaceDescriptorSetType (225) +/* net:InterfaceDescriptorSetType */ +class SOAP_CMAC net__InterfaceDescriptorSetType +{ +public: + enum net__InterfaceModeType InterfaceMode; /* required element of type net:InterfaceModeType */ + unsigned char LinkPolicy; /* required element of type net:LinkPolicyType */ + net__IPv4ParametersType *IPv4Parameters; /* optional element of type net:IPv4ParametersType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 225; } /* = unique id SOAP_TYPE_net__InterfaceDescriptorSetType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + net__InterfaceDescriptorSetType() : IPv4Parameters(NULL), soap(NULL) { } + virtual ~net__InterfaceDescriptorSetType() { } +}; +#endif + +#ifndef SOAP_TYPE_net__InterfaceDescriptorGetType +#define SOAP_TYPE_net__InterfaceDescriptorGetType (226) +/* net:InterfaceDescriptorGetType */ +class SOAP_CMAC net__InterfaceDescriptorGetType +{ +public: + std::string HardwareAddressDescription; /* required element of type xsd:string */ + std::string MACAddress; /* required element of type net:MACAddressType */ + enum net__InterfaceModeType InterfaceMode; /* required element of type net:InterfaceModeType */ + unsigned char LinkPolicy; /* required element of type net:LinkPolicyType */ + bool DhcpEnabled; /* required element of type xsd:boolean */ + net__IPv4ParametersType *IPv4Parameters; /* optional element of type net:IPv4ParametersType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 226; } /* = unique id SOAP_TYPE_net__InterfaceDescriptorGetType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + net__InterfaceDescriptorGetType() : IPv4Parameters(NULL), soap(NULL) { } + virtual ~net__InterfaceDescriptorGetType() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetHostName +#define SOAP_TYPE__net__SetHostName (227) +/* net:SetHostName */ +class SOAP_CMAC _net__SetHostName +{ +public: + std::string HostName; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 227; } /* = unique id SOAP_TYPE__net__SetHostName */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetHostName() : soap(NULL) { } + virtual ~_net__SetHostName() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetHostNameResponse +#define SOAP_TYPE__net__SetHostNameResponse (228) +/* net:SetHostNameResponse */ +class SOAP_CMAC _net__SetHostNameResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 228; } /* = unique id SOAP_TYPE__net__SetHostNameResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetHostNameResponse() : soap(NULL) { } + virtual ~_net__SetHostNameResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetHostName +#define SOAP_TYPE__net__GetHostName (229) +/* net:GetHostName */ +class SOAP_CMAC _net__GetHostName +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 229; } /* = unique id SOAP_TYPE__net__GetHostName */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetHostName() : soap(NULL) { } + virtual ~_net__GetHostName() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetHostNameResponse +#define SOAP_TYPE__net__GetHostNameResponse (230) +/* net:GetHostNameResponse */ +class SOAP_CMAC _net__GetHostNameResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + std::string HostName; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 230; } /* = unique id SOAP_TYPE__net__GetHostNameResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetHostNameResponse() : soap(NULL) { } + virtual ~_net__GetHostNameResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetDomainName +#define SOAP_TYPE__net__SetDomainName (231) +/* net:SetDomainName */ +class SOAP_CMAC _net__SetDomainName +{ +public: + std::string DomainName; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 231; } /* = unique id SOAP_TYPE__net__SetDomainName */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetDomainName() : soap(NULL) { } + virtual ~_net__SetDomainName() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetDomainNameResponse +#define SOAP_TYPE__net__SetDomainNameResponse (232) +/* net:SetDomainNameResponse */ +class SOAP_CMAC _net__SetDomainNameResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 232; } /* = unique id SOAP_TYPE__net__SetDomainNameResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetDomainNameResponse() : soap(NULL) { } + virtual ~_net__SetDomainNameResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetDomainName +#define SOAP_TYPE__net__GetDomainName (233) +/* net:GetDomainName */ +class SOAP_CMAC _net__GetDomainName +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 233; } /* = unique id SOAP_TYPE__net__GetDomainName */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetDomainName() : soap(NULL) { } + virtual ~_net__GetDomainName() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetDomainNameResponse +#define SOAP_TYPE__net__GetDomainNameResponse (234) +/* net:GetDomainNameResponse */ +class SOAP_CMAC _net__GetDomainNameResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + std::string DomainName; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 234; } /* = unique id SOAP_TYPE__net__GetDomainNameResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetDomainNameResponse() : soap(NULL) { } + virtual ~_net__GetDomainNameResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetTcpIpParameters +#define SOAP_TYPE__net__SetTcpIpParameters (235) +/* net:SetTcpIpParameters */ +class SOAP_CMAC _net__SetTcpIpParameters +{ +public: + enum net__DhcpModeType DhcpMode; /* required element of type net:DhcpModeType */ + net__StaticIPv4ParametersType *StaticIPv4Parameters; /* optional element of type net:StaticIPv4ParametersType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 235; } /* = unique id SOAP_TYPE__net__SetTcpIpParameters */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetTcpIpParameters() : StaticIPv4Parameters(NULL), soap(NULL) { } + virtual ~_net__SetTcpIpParameters() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetTcpIpParametersResponse +#define SOAP_TYPE__net__SetTcpIpParametersResponse (236) +/* net:SetTcpIpParametersResponse */ +class SOAP_CMAC _net__SetTcpIpParametersResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 236; } /* = unique id SOAP_TYPE__net__SetTcpIpParametersResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetTcpIpParametersResponse() : soap(NULL) { } + virtual ~_net__SetTcpIpParametersResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetTcpIpParameters +#define SOAP_TYPE__net__GetTcpIpParameters (237) +/* net:GetTcpIpParameters */ +class SOAP_CMAC _net__GetTcpIpParameters +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 237; } /* = unique id SOAP_TYPE__net__GetTcpIpParameters */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetTcpIpParameters() : soap(NULL) { } + virtual ~_net__GetTcpIpParameters() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetTcpIpParametersResponse +#define SOAP_TYPE__net__GetTcpIpParametersResponse (238) +/* net:GetTcpIpParametersResponse */ +class SOAP_CMAC _net__GetTcpIpParametersResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + enum net__DhcpModeType DhcpMode; /* required element of type net:DhcpModeType */ + net__StaticIPv4ParametersType *StaticIPv4Parameters; /* required element of type net:StaticIPv4ParametersType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 238; } /* = unique id SOAP_TYPE__net__GetTcpIpParametersResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetTcpIpParametersResponse() : StaticIPv4Parameters(NULL), soap(NULL) { } + virtual ~_net__GetTcpIpParametersResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetVlanParameters +#define SOAP_TYPE__net__SetVlanParameters (239) +/* net:SetVlanParameters */ +class SOAP_CMAC _net__SetVlanParameters +{ +public: + unsigned int *InterfaceHandle; /* optional element of type cmn:InterfaceHandleType */ + bool VlanMode; /* required element of type xsd:boolean */ + unsigned short VlanTag; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 239; } /* = unique id SOAP_TYPE__net__SetVlanParameters */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetVlanParameters() : InterfaceHandle(NULL), soap(NULL) { } + virtual ~_net__SetVlanParameters() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetVlanParametersResponse +#define SOAP_TYPE__net__SetVlanParametersResponse (240) +/* net:SetVlanParametersResponse */ +class SOAP_CMAC _net__SetVlanParametersResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 240; } /* = unique id SOAP_TYPE__net__SetVlanParametersResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetVlanParametersResponse() : soap(NULL) { } + virtual ~_net__SetVlanParametersResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetVlanParameters +#define SOAP_TYPE__net__GetVlanParameters (241) +/* net:GetVlanParameters */ +class SOAP_CMAC _net__GetVlanParameters +{ +public: + unsigned int *InterfaceHandle; /* optional element of type cmn:InterfaceHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 241; } /* = unique id SOAP_TYPE__net__GetVlanParameters */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetVlanParameters() : InterfaceHandle(NULL), soap(NULL) { } + virtual ~_net__GetVlanParameters() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetVlanParametersResponse +#define SOAP_TYPE__net__GetVlanParametersResponse (242) +/* net:GetVlanParametersResponse */ +class SOAP_CMAC _net__GetVlanParametersResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + bool VlanMode; /* required element of type xsd:boolean */ + unsigned short VlanTag; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 242; } /* = unique id SOAP_TYPE__net__GetVlanParametersResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetVlanParametersResponse() : soap(NULL) { } + virtual ~_net__GetVlanParametersResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetPingResponse +#define SOAP_TYPE__net__SetPingResponse (243) +/* net:SetPingResponse */ +class SOAP_CMAC _net__SetPingResponse +{ +public: + bool enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 243; } /* = unique id SOAP_TYPE__net__SetPingResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetPingResponse() : soap(NULL) { } + virtual ~_net__SetPingResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetPingResponseResponse +#define SOAP_TYPE__net__SetPingResponseResponse (244) +/* net:SetPingResponseResponse */ +class SOAP_CMAC _net__SetPingResponseResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 244; } /* = unique id SOAP_TYPE__net__SetPingResponseResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetPingResponseResponse() : soap(NULL) { } + virtual ~_net__SetPingResponseResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetPingResponse +#define SOAP_TYPE__net__GetPingResponse (245) +/* net:GetPingResponse */ +class SOAP_CMAC _net__GetPingResponse +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 245; } /* = unique id SOAP_TYPE__net__GetPingResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetPingResponse() : soap(NULL) { } + virtual ~_net__GetPingResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetPingResponseResponse +#define SOAP_TYPE__net__GetPingResponseResponse (246) +/* net:GetPingResponseResponse */ +class SOAP_CMAC _net__GetPingResponseResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type net:PT_STATUS */ + bool enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 246; } /* = unique id SOAP_TYPE__net__GetPingResponseResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetPingResponseResponse() : soap(NULL) { } + virtual ~_net__GetPingResponseResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__EnumerateInterfaces +#define SOAP_TYPE__net__EnumerateInterfaces (247) +/* net:EnumerateInterfaces */ +class SOAP_CMAC _net__EnumerateInterfaces +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 247; } /* = unique id SOAP_TYPE__net__EnumerateInterfaces */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__EnumerateInterfaces() : soap(NULL) { } + virtual ~_net__EnumerateInterfaces() { } +}; +#endif + +#ifndef SOAP_TYPE__net__EnumerateInterfacesResponse +#define SOAP_TYPE__net__EnumerateInterfacesResponse (248) +/* net:EnumerateInterfacesResponse */ +class SOAP_CMAC _net__EnumerateInterfacesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + std::vectorInterfaceHandles; /* optional element of type net:InterfaceHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 248; } /* = unique id SOAP_TYPE__net__EnumerateInterfacesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__EnumerateInterfacesResponse() : soap(NULL) { } + virtual ~_net__EnumerateInterfacesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetInterfaceSettings +#define SOAP_TYPE__net__GetInterfaceSettings (249) +/* net:GetInterfaceSettings */ +class SOAP_CMAC _net__GetInterfaceSettings +{ +public: + unsigned int InterfaceHandle; /* required element of type net:InterfaceHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 249; } /* = unique id SOAP_TYPE__net__GetInterfaceSettings */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetInterfaceSettings() : soap(NULL) { } + virtual ~_net__GetInterfaceSettings() { } +}; +#endif + +#ifndef SOAP_TYPE__net__GetInterfaceSettingsResponse +#define SOAP_TYPE__net__GetInterfaceSettingsResponse (250) +/* net:GetInterfaceSettingsResponse */ +class SOAP_CMAC _net__GetInterfaceSettingsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + net__InterfaceDescriptorGetType *InterfaceDescriptor; /* required element of type net:InterfaceDescriptorGetType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 250; } /* = unique id SOAP_TYPE__net__GetInterfaceSettingsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__GetInterfaceSettingsResponse() : InterfaceDescriptor(NULL), soap(NULL) { } + virtual ~_net__GetInterfaceSettingsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetInterfaceSettings +#define SOAP_TYPE__net__SetInterfaceSettings (251) +/* net:SetInterfaceSettings */ +class SOAP_CMAC _net__SetInterfaceSettings +{ +public: + unsigned int InterfaceHandle; /* required element of type net:InterfaceHandleType */ + net__InterfaceDescriptorSetType *InterfaceDescriptor; /* required element of type net:InterfaceDescriptorSetType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 251; } /* = unique id SOAP_TYPE__net__SetInterfaceSettings */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetInterfaceSettings() : InterfaceDescriptor(NULL), soap(NULL) { } + virtual ~_net__SetInterfaceSettings() { } +}; +#endif + +#ifndef SOAP_TYPE__net__SetInterfaceSettingsResponse +#define SOAP_TYPE__net__SetInterfaceSettingsResponse (252) +/* net:SetInterfaceSettingsResponse */ +class SOAP_CMAC _net__SetInterfaceSettingsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 252; } /* = unique id SOAP_TYPE__net__SetInterfaceSettingsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__SetInterfaceSettingsResponse() : soap(NULL) { } + virtual ~_net__SetInterfaceSettingsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Get8021XWiredProfile +#define SOAP_TYPE__net__Get8021XWiredProfile (253) +/* net:Get8021XWiredProfile */ +class SOAP_CMAC _net__Get8021XWiredProfile +{ +public: + unsigned int InterfaceHandle; /* required element of type cmn:InterfaceHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 253; } /* = unique id SOAP_TYPE__net__Get8021XWiredProfile */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Get8021XWiredProfile() : soap(NULL) { } + virtual ~_net__Get8021XWiredProfile() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Get8021XWiredProfileResponse +#define SOAP_TYPE__net__Get8021XWiredProfileResponse (254) +/* net:Get8021XWiredProfileResponse */ +class SOAP_CMAC _net__Get8021XWiredProfileResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + xcfg__XProfileType *XProfile; /* optional element of type xcfg:XProfileType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 254; } /* = unique id SOAP_TYPE__net__Get8021XWiredProfileResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Get8021XWiredProfileResponse() : XProfile(NULL), soap(NULL) { } + virtual ~_net__Get8021XWiredProfileResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Set8021XWiredProfile +#define SOAP_TYPE__net__Set8021XWiredProfile (255) +/* net:Set8021XWiredProfile */ +class SOAP_CMAC _net__Set8021XWiredProfile +{ +public: + unsigned int InterfaceHandle; /* required element of type cmn:InterfaceHandleType */ + xcfg__XProfileType *XProfile; /* optional element of type xcfg:XProfileType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 255; } /* = unique id SOAP_TYPE__net__Set8021XWiredProfile */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Set8021XWiredProfile() : XProfile(NULL), soap(NULL) { } + virtual ~_net__Set8021XWiredProfile() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Set8021XWiredProfileResponse +#define SOAP_TYPE__net__Set8021XWiredProfileResponse (256) +/* net:Set8021XWiredProfileResponse */ +class SOAP_CMAC _net__Set8021XWiredProfileResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 256; } /* = unique id SOAP_TYPE__net__Set8021XWiredProfileResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Set8021XWiredProfileResponse() : soap(NULL) { } + virtual ~_net__Set8021XWiredProfileResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Set8021XActiveS0 +#define SOAP_TYPE__net__Set8021XActiveS0 (257) +/* net:Set8021XActiveS0 */ +class SOAP_CMAC _net__Set8021XActiveS0 +{ +public: + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 257; } /* = unique id SOAP_TYPE__net__Set8021XActiveS0 */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Set8021XActiveS0() : soap(NULL) { } + virtual ~_net__Set8021XActiveS0() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Set8021XActiveS0Response +#define SOAP_TYPE__net__Set8021XActiveS0Response (258) +/* net:Set8021XActiveS0Response */ +class SOAP_CMAC _net__Set8021XActiveS0Response +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 258; } /* = unique id SOAP_TYPE__net__Set8021XActiveS0Response */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Set8021XActiveS0Response() : soap(NULL) { } + virtual ~_net__Set8021XActiveS0Response() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Get8021XActiveS0 +#define SOAP_TYPE__net__Get8021XActiveS0 (259) +/* net:Get8021XActiveS0 */ +class SOAP_CMAC _net__Get8021XActiveS0 +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 259; } /* = unique id SOAP_TYPE__net__Get8021XActiveS0 */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Get8021XActiveS0() : soap(NULL) { } + virtual ~_net__Get8021XActiveS0() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Get8021XActiveS0Response +#define SOAP_TYPE__net__Get8021XActiveS0Response (260) +/* net:Get8021XActiveS0Response */ +class SOAP_CMAC _net__Get8021XActiveS0Response +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 260; } /* = unique id SOAP_TYPE__net__Get8021XActiveS0Response */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Get8021XActiveS0Response() : soap(NULL) { } + virtual ~_net__Get8021XActiveS0Response() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Set8021XPxeTimeout +#define SOAP_TYPE__net__Set8021XPxeTimeout (261) +/* net:Set8021XPxeTimeout */ +class SOAP_CMAC _net__Set8021XPxeTimeout +{ +public: + unsigned int *Timeout; /* optional element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 261; } /* = unique id SOAP_TYPE__net__Set8021XPxeTimeout */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Set8021XPxeTimeout() : Timeout(NULL), soap(NULL) { } + virtual ~_net__Set8021XPxeTimeout() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Set8021XPxeTimeoutResponse +#define SOAP_TYPE__net__Set8021XPxeTimeoutResponse (262) +/* net:Set8021XPxeTimeoutResponse */ +class SOAP_CMAC _net__Set8021XPxeTimeoutResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 262; } /* = unique id SOAP_TYPE__net__Set8021XPxeTimeoutResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Set8021XPxeTimeoutResponse() : soap(NULL) { } + virtual ~_net__Set8021XPxeTimeoutResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Get8021XPxeTimeout +#define SOAP_TYPE__net__Get8021XPxeTimeout (263) +/* net:Get8021XPxeTimeout */ +class SOAP_CMAC _net__Get8021XPxeTimeout +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 263; } /* = unique id SOAP_TYPE__net__Get8021XPxeTimeout */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Get8021XPxeTimeout() : soap(NULL) { } + virtual ~_net__Get8021XPxeTimeout() { } +}; +#endif + +#ifndef SOAP_TYPE__net__Get8021XPxeTimeoutResponse +#define SOAP_TYPE__net__Get8021XPxeTimeoutResponse (264) +/* net:Get8021XPxeTimeoutResponse */ +class SOAP_CMAC _net__Get8021XPxeTimeoutResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + unsigned int Timeout; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 264; } /* = unique id SOAP_TYPE__net__Get8021XPxeTimeoutResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _net__Get8021XPxeTimeoutResponse() : soap(NULL) { } + virtual ~_net__Get8021XPxeTimeoutResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__StorageEaclEntryType +#define SOAP_TYPE_stra__StorageEaclEntryType (265) +/* stra:StorageEaclEntryType */ +class SOAP_CMAC stra__StorageEaclEntryType +{ +public: + std::string EnterpriseName; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 265; } /* = unique id SOAP_TYPE_stra__StorageEaclEntryType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__StorageEaclEntryType() : soap(NULL) { } + virtual ~stra__StorageEaclEntryType() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__StorageEaclEntryHandleListType +#define SOAP_TYPE_stra__StorageEaclEntryHandleListType (266) +/* stra:StorageEaclEntryHandleListType */ +class SOAP_CMAC stra__StorageEaclEntryHandleListType +{ +public: + std::vectorHandle; /* sequence of 0 to 8 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 266; } /* = unique id SOAP_TYPE_stra__StorageEaclEntryHandleListType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__StorageEaclEntryHandleListType() : soap(NULL) { } + virtual ~stra__StorageEaclEntryHandleListType() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__StorageAllocEntryType +#define SOAP_TYPE_stra__StorageAllocEntryType (267) +/* stra:StorageAllocEntryType */ +class SOAP_CMAC stra__StorageAllocEntryType +{ +public: + enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE AttrType; /* required element of type stra:ISVS_APP_ATTR_TYPE */ + class stra__StorageAllocSnrpEntryType *StorageAllocSnrpEntry; /* required element of type stra:StorageAllocSnrpEntryType */ + bool IsPartner; /* required element of type xsd:boolean */ + unsigned int TotalAllocationSize; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 267; } /* = unique id SOAP_TYPE_stra__StorageAllocEntryType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__StorageAllocEntryType() : StorageAllocSnrpEntry(NULL), soap(NULL) { } + virtual ~stra__StorageAllocEntryType() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__StorageAllocSnrpEntryType +#define SOAP_TYPE_stra__StorageAllocSnrpEntryType (268) +/* stra:StorageAllocSnrpEntryType */ +class SOAP_CMAC stra__StorageAllocSnrpEntryType +{ +public: + std::string ApplicationName; /* required element of type xsd:string */ + std::string VendorName; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 268; } /* = unique id SOAP_TYPE_stra__StorageAllocSnrpEntryType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__StorageAllocSnrpEntryType() : soap(NULL) { } + virtual ~stra__StorageAllocSnrpEntryType() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__StorageAllocEntryHandleListType +#define SOAP_TYPE_stra__StorageAllocEntryHandleListType (269) +/* stra:StorageAllocEntryHandleListType */ +class SOAP_CMAC stra__StorageAllocEntryHandleListType +{ +public: + std::vectorHandle; /* sequence of 0 to 32 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 269; } /* = unique id SOAP_TYPE_stra__StorageAllocEntryHandleListType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__StorageAllocEntryHandleListType() : soap(NULL) { } + virtual ~stra__StorageAllocEntryHandleListType() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__GUID +#define SOAP_TYPE_stra__GUID (270) +/* stra:GUID */ +class SOAP_CMAC stra__GUID +{ +public: + std::vectorByte; /* sequence of 16 to 16 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 270; } /* = unique id SOAP_TYPE_stra__GUID */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__GUID() : soap(NULL) { } + virtual ~stra__GUID() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__GlobalStorageAttributesType +#define SOAP_TYPE_stra__GlobalStorageAttributesType (271) +/* stra:GlobalStorageAttributesType */ +class SOAP_CMAC stra__GlobalStorageAttributesType +{ +public: + unsigned int TotalStorage; /* required element of type xsd:unsignedInt */ + unsigned int TotalAllocatedStorage; /* required element of type xsd:unsignedInt */ + unsigned int MaxPartnerStorage; /* required element of type xsd:unsignedInt */ + unsigned int TotalPartnerAllocatedStorage; /* required element of type xsd:unsignedInt */ + unsigned int MaxNonPartnerStorage; /* required element of type xsd:unsignedInt */ + unsigned short MaxFpaclEntries; /* required element of type xsd:unsignedShort */ + unsigned short MaxAslEntries; /* required element of type xsd:unsignedShort */ + unsigned short MaxEaclEntries; /* required element of type xsd:unsignedShort */ + unsigned short MaxGroupsPerBlock; /* required element of type xsd:unsignedShort */ + unsigned short MaxMembersPerGroup; /* required element of type xsd:unsignedShort */ + unsigned short MaxNonPartnerTotalAllocationSize; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 271; } /* = unique id SOAP_TYPE_stra__GlobalStorageAttributesType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__GlobalStorageAttributesType() : soap(NULL) { } + virtual ~stra__GlobalStorageAttributesType() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__StorageApplicationHandleListType +#define SOAP_TYPE_stra__StorageApplicationHandleListType (272) +/* stra:StorageApplicationHandleListType */ +class SOAP_CMAC stra__StorageApplicationHandleListType +{ +public: + std::vectorHandle; /* sequence of 0 to 32 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 272; } /* = unique id SOAP_TYPE_stra__StorageApplicationHandleListType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__StorageApplicationHandleListType() : soap(NULL) { } + virtual ~stra__StorageApplicationHandleListType() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__StorageSnrpApplicationAttributeType +#define SOAP_TYPE_stra__StorageSnrpApplicationAttributeType (273) +/* stra:StorageSnrpApplicationAttributeType */ +class SOAP_CMAC stra__StorageSnrpApplicationAttributeType +{ +public: + stra__GUID *UUID; /* required element of type stra:GUID */ + std::string VendorName; /* required element of type xsd:string */ + std::string ApplicationName; /* required element of type xsd:string */ + std::string EnterpriseName; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 273; } /* = unique id SOAP_TYPE_stra__StorageSnrpApplicationAttributeType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__StorageSnrpApplicationAttributeType() : UUID(NULL), soap(NULL) { } + virtual ~stra__StorageSnrpApplicationAttributeType() { } +}; +#endif + +#ifndef SOAP_TYPE_stra__StorageApplicationAttributesType +#define SOAP_TYPE_stra__StorageApplicationAttributesType (274) +/* stra:StorageApplicationAttributesType */ +class SOAP_CMAC stra__StorageApplicationAttributesType +{ +public: + enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE AttrType; /* required element of type stra:ISVS_APP_ATTR_TYPE */ + stra__StorageSnrpApplicationAttributeType *ApplicationAttr; /* required element of type stra:StorageSnrpApplicationAttributeType */ + unsigned int CurrentAllocationSize; /* required element of type xsd:unsignedInt */ + bool ActiveSession; /* required element of type xsd:boolean */ + bool Partner; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 274; } /* = unique id SOAP_TYPE_stra__StorageApplicationAttributesType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + stra__StorageApplicationAttributesType() : ApplicationAttr(NULL), soap(NULL) { } + virtual ~stra__StorageApplicationAttributesType() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__GetGlobalStorageAttributes +#define SOAP_TYPE__stra__GetGlobalStorageAttributes (275) +/* stra:GetGlobalStorageAttributes */ +class SOAP_CMAC _stra__GetGlobalStorageAttributes +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 275; } /* = unique id SOAP_TYPE__stra__GetGlobalStorageAttributes */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__GetGlobalStorageAttributes() : soap(NULL) { } + virtual ~_stra__GetGlobalStorageAttributes() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__GetGlobalStorageAttributesResponse +#define SOAP_TYPE__stra__GetGlobalStorageAttributesResponse (276) +/* stra:GetGlobalStorageAttributesResponse */ +class SOAP_CMAC _stra__GetGlobalStorageAttributesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + stra__GlobalStorageAttributesType *Attributes; /* optional element of type stra:GlobalStorageAttributesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 276; } /* = unique id SOAP_TYPE__stra__GetGlobalStorageAttributesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__GetGlobalStorageAttributesResponse() : Attributes(NULL), soap(NULL) { } + virtual ~_stra__GetGlobalStorageAttributesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__SetGlobalStorageAttributes +#define SOAP_TYPE__stra__SetGlobalStorageAttributes (277) +/* stra:SetGlobalStorageAttributes */ +class SOAP_CMAC _stra__SetGlobalStorageAttributes +{ +public: + unsigned int *MaxPartnerStorage; /* optional element of type xsd:unsignedInt */ + unsigned short *MaxNonPartnerTotalAllocationSize; /* optional element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 277; } /* = unique id SOAP_TYPE__stra__SetGlobalStorageAttributes */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__SetGlobalStorageAttributes() : MaxPartnerStorage(NULL), MaxNonPartnerTotalAllocationSize(NULL), soap(NULL) { } + virtual ~_stra__SetGlobalStorageAttributes() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__SetGlobalStorageAttributesResponse +#define SOAP_TYPE__stra__SetGlobalStorageAttributesResponse (278) +/* stra:SetGlobalStorageAttributesResponse */ +class SOAP_CMAC _stra__SetGlobalStorageAttributesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 278; } /* = unique id SOAP_TYPE__stra__SetGlobalStorageAttributesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__SetGlobalStorageAttributesResponse() : soap(NULL) { } + virtual ~_stra__SetGlobalStorageAttributesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AdminGetRegisteredApplications +#define SOAP_TYPE__stra__AdminGetRegisteredApplications (279) +/* stra:AdminGetRegisteredApplications */ +class SOAP_CMAC _stra__AdminGetRegisteredApplications +{ +public: + unsigned int StartIndex; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 279; } /* = unique id SOAP_TYPE__stra__AdminGetRegisteredApplications */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AdminGetRegisteredApplications() : soap(NULL) { } + virtual ~_stra__AdminGetRegisteredApplications() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse +#define SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse (280) +/* stra:AdminGetRegisteredApplicationsResponse */ +class SOAP_CMAC _stra__AdminGetRegisteredApplicationsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + unsigned int TotalCount; /* required element of type xsd:unsignedInt */ + unsigned int HandlesCount; /* required element of type xsd:unsignedInt */ + stra__StorageApplicationHandleListType *ApplicationHandles; /* optional element of type stra:StorageApplicationHandleListType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 280; } /* = unique id SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AdminGetRegisteredApplicationsResponse() : ApplicationHandles(NULL), soap(NULL) { } + virtual ~_stra__AdminGetRegisteredApplicationsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AdminGetApplicationAttributes +#define SOAP_TYPE__stra__AdminGetApplicationAttributes (281) +/* stra:AdminGetApplicationAttributes */ +class SOAP_CMAC _stra__AdminGetApplicationAttributes +{ +public: + unsigned int Handle; /* required element of type stra:StorageApplicationHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 281; } /* = unique id SOAP_TYPE__stra__AdminGetApplicationAttributes */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AdminGetApplicationAttributes() : soap(NULL) { } + virtual ~_stra__AdminGetApplicationAttributes() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AdminGetApplicationAttributesResponse +#define SOAP_TYPE__stra__AdminGetApplicationAttributesResponse (282) +/* stra:AdminGetApplicationAttributesResponse */ +class SOAP_CMAC _stra__AdminGetApplicationAttributesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + stra__StorageApplicationAttributesType *Attributes; /* optional element of type stra:StorageApplicationAttributesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 282; } /* = unique id SOAP_TYPE__stra__AdminGetApplicationAttributesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AdminGetApplicationAttributesResponse() : Attributes(NULL), soap(NULL) { } + virtual ~_stra__AdminGetApplicationAttributesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AdminRemoveApplication +#define SOAP_TYPE__stra__AdminRemoveApplication (283) +/* stra:AdminRemoveApplication */ +class SOAP_CMAC _stra__AdminRemoveApplication +{ +public: + unsigned int Handle; /* required element of type stra:StorageApplicationHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 283; } /* = unique id SOAP_TYPE__stra__AdminRemoveApplication */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AdminRemoveApplication() : soap(NULL) { } + virtual ~_stra__AdminRemoveApplication() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AdminRemoveApplicationResponse +#define SOAP_TYPE__stra__AdminRemoveApplicationResponse (284) +/* stra:AdminRemoveApplicationResponse */ +class SOAP_CMAC _stra__AdminRemoveApplicationResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 284; } /* = unique id SOAP_TYPE__stra__AdminRemoveApplicationResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AdminRemoveApplicationResponse() : soap(NULL) { } + virtual ~_stra__AdminRemoveApplicationResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AddStorageEaclEntry +#define SOAP_TYPE__stra__AddStorageEaclEntry (285) +/* stra:AddStorageEaclEntry */ +class SOAP_CMAC _stra__AddStorageEaclEntry +{ +public: + stra__StorageEaclEntryType *Entry; /* required element of type stra:StorageEaclEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 285; } /* = unique id SOAP_TYPE__stra__AddStorageEaclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AddStorageEaclEntry() : Entry(NULL), soap(NULL) { } + virtual ~_stra__AddStorageEaclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AddStorageEaclEntryResponse +#define SOAP_TYPE__stra__AddStorageEaclEntryResponse (286) +/* stra:AddStorageEaclEntryResponse */ +class SOAP_CMAC _stra__AddStorageEaclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + unsigned int Handle; /* required element of type stra:StorageEaclEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 286; } /* = unique id SOAP_TYPE__stra__AddStorageEaclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AddStorageEaclEntryResponse() : soap(NULL) { } + virtual ~_stra__AddStorageEaclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__EnumerateStorageEaclEntries +#define SOAP_TYPE__stra__EnumerateStorageEaclEntries (287) +/* stra:EnumerateStorageEaclEntries */ +class SOAP_CMAC _stra__EnumerateStorageEaclEntries +{ +public: + unsigned short StartIndex; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 287; } /* = unique id SOAP_TYPE__stra__EnumerateStorageEaclEntries */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__EnumerateStorageEaclEntries() : soap(NULL) { } + virtual ~_stra__EnumerateStorageEaclEntries() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse +#define SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse (288) +/* stra:EnumerateStorageEaclEntriesResponse */ +class SOAP_CMAC _stra__EnumerateStorageEaclEntriesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + unsigned short TotalCount; /* required element of type xsd:unsignedShort */ + unsigned short HandlesCount; /* required element of type xsd:unsignedShort */ + stra__StorageEaclEntryHandleListType *Handles; /* required element of type stra:StorageEaclEntryHandleListType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 288; } /* = unique id SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__EnumerateStorageEaclEntriesResponse() : Handles(NULL), soap(NULL) { } + virtual ~_stra__EnumerateStorageEaclEntriesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__GetStorageEaclEntry +#define SOAP_TYPE__stra__GetStorageEaclEntry (289) +/* stra:GetStorageEaclEntry */ +class SOAP_CMAC _stra__GetStorageEaclEntry +{ +public: + unsigned int Handle; /* required element of type stra:StorageEaclEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 289; } /* = unique id SOAP_TYPE__stra__GetStorageEaclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__GetStorageEaclEntry() : soap(NULL) { } + virtual ~_stra__GetStorageEaclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__GetStorageEaclEntryResponse +#define SOAP_TYPE__stra__GetStorageEaclEntryResponse (290) +/* stra:GetStorageEaclEntryResponse */ +class SOAP_CMAC _stra__GetStorageEaclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + stra__StorageEaclEntryType *Entry; /* required element of type stra:StorageEaclEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 290; } /* = unique id SOAP_TYPE__stra__GetStorageEaclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__GetStorageEaclEntryResponse() : Entry(NULL), soap(NULL) { } + virtual ~_stra__GetStorageEaclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__RemoveStorageEaclEntry +#define SOAP_TYPE__stra__RemoveStorageEaclEntry (291) +/* stra:RemoveStorageEaclEntry */ +class SOAP_CMAC _stra__RemoveStorageEaclEntry +{ +public: + unsigned int Handle; /* required element of type stra:StorageEaclEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 291; } /* = unique id SOAP_TYPE__stra__RemoveStorageEaclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__RemoveStorageEaclEntry() : soap(NULL) { } + virtual ~_stra__RemoveStorageEaclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__RemoveStorageEaclEntryResponse +#define SOAP_TYPE__stra__RemoveStorageEaclEntryResponse (292) +/* stra:RemoveStorageEaclEntryResponse */ +class SOAP_CMAC _stra__RemoveStorageEaclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 292; } /* = unique id SOAP_TYPE__stra__RemoveStorageEaclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__RemoveStorageEaclEntryResponse() : soap(NULL) { } + virtual ~_stra__RemoveStorageEaclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AddStorageFpaclEntry +#define SOAP_TYPE__stra__AddStorageFpaclEntry (293) +/* stra:AddStorageFpaclEntry */ +class SOAP_CMAC _stra__AddStorageFpaclEntry +{ +public: + stra__StorageAllocEntryType *Entry; /* required element of type stra:StorageAllocEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 293; } /* = unique id SOAP_TYPE__stra__AddStorageFpaclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AddStorageFpaclEntry() : Entry(NULL), soap(NULL) { } + virtual ~_stra__AddStorageFpaclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__AddStorageFpaclEntryResponse +#define SOAP_TYPE__stra__AddStorageFpaclEntryResponse (294) +/* stra:AddStorageFpaclEntryResponse */ +class SOAP_CMAC _stra__AddStorageFpaclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + unsigned int Handle; /* required element of type stra:StorageAllocEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 294; } /* = unique id SOAP_TYPE__stra__AddStorageFpaclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__AddStorageFpaclEntryResponse() : soap(NULL) { } + virtual ~_stra__AddStorageFpaclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__EnumerateStorageAllocEntries +#define SOAP_TYPE__stra__EnumerateStorageAllocEntries (295) +/* stra:EnumerateStorageAllocEntries */ +class SOAP_CMAC _stra__EnumerateStorageAllocEntries +{ +public: + unsigned short StartIndex; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 295; } /* = unique id SOAP_TYPE__stra__EnumerateStorageAllocEntries */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__EnumerateStorageAllocEntries() : soap(NULL) { } + virtual ~_stra__EnumerateStorageAllocEntries() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse +#define SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse (296) +/* stra:EnumerateStorageAllocEntriesResponse */ +class SOAP_CMAC _stra__EnumerateStorageAllocEntriesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + unsigned short TotalCount; /* required element of type xsd:unsignedShort */ + unsigned short HandlesCount; /* required element of type xsd:unsignedShort */ + stra__StorageAllocEntryHandleListType *Handles; /* required element of type stra:StorageAllocEntryHandleListType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 296; } /* = unique id SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__EnumerateStorageAllocEntriesResponse() : Handles(NULL), soap(NULL) { } + virtual ~_stra__EnumerateStorageAllocEntriesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__GetStorageAllocEntry +#define SOAP_TYPE__stra__GetStorageAllocEntry (297) +/* stra:GetStorageAllocEntry */ +class SOAP_CMAC _stra__GetStorageAllocEntry +{ +public: + unsigned int Handle; /* required element of type stra:StorageAllocEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 297; } /* = unique id SOAP_TYPE__stra__GetStorageAllocEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__GetStorageAllocEntry() : soap(NULL) { } + virtual ~_stra__GetStorageAllocEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__GetStorageAllocEntryResponse +#define SOAP_TYPE__stra__GetStorageAllocEntryResponse (298) +/* stra:GetStorageAllocEntryResponse */ +class SOAP_CMAC _stra__GetStorageAllocEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + stra__StorageAllocEntryType *Entry; /* required element of type stra:StorageAllocEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 298; } /* = unique id SOAP_TYPE__stra__GetStorageAllocEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__GetStorageAllocEntryResponse() : Entry(NULL), soap(NULL) { } + virtual ~_stra__GetStorageAllocEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__UpdateStorageFpaclEntry +#define SOAP_TYPE__stra__UpdateStorageFpaclEntry (299) +/* stra:UpdateStorageFpaclEntry */ +class SOAP_CMAC _stra__UpdateStorageFpaclEntry +{ +public: + unsigned int Handle; /* required element of type stra:StorageAllocEntryHandleType */ + unsigned int NewAllocationSize; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 299; } /* = unique id SOAP_TYPE__stra__UpdateStorageFpaclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__UpdateStorageFpaclEntry() : soap(NULL) { } + virtual ~_stra__UpdateStorageFpaclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse +#define SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse (300) +/* stra:UpdateStorageFpaclEntryResponse */ +class SOAP_CMAC _stra__UpdateStorageFpaclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 300; } /* = unique id SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__UpdateStorageFpaclEntryResponse() : soap(NULL) { } + virtual ~_stra__UpdateStorageFpaclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__RemoveStorageFpaclEntry +#define SOAP_TYPE__stra__RemoveStorageFpaclEntry (301) +/* stra:RemoveStorageFpaclEntry */ +class SOAP_CMAC _stra__RemoveStorageFpaclEntry +{ +public: + unsigned int Handle; /* required element of type stra:StorageAllocEntryHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 301; } /* = unique id SOAP_TYPE__stra__RemoveStorageFpaclEntry */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__RemoveStorageFpaclEntry() : soap(NULL) { } + virtual ~_stra__RemoveStorageFpaclEntry() { } +}; +#endif + +#ifndef SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse +#define SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse (302) +/* stra:RemoveStorageFpaclEntryResponse */ +class SOAP_CMAC _stra__RemoveStorageFpaclEntryResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type stra:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 302; } /* = unique id SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _stra__RemoveStorageFpaclEntryResponse() : soap(NULL) { } + virtual ~_stra__RemoveStorageFpaclEntryResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType +#define SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType (303) +/* emi:AlertSubscriptionPolicyIDArrayType */ +class SOAP_CMAC emi__AlertSubscriptionPolicyIDArrayType +{ +public: + std::vectorAlertSubscriptionPolicyID; /* optional element of type emi:AlertSubscriptionPolicyIDType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 303; } /* = unique id SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__AlertSubscriptionPolicyIDArrayType() : soap(NULL) { } + virtual ~emi__AlertSubscriptionPolicyIDArrayType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__ByteData +#define SOAP_TYPE_emi__ByteData (304) +/* emi:ByteData */ +class SOAP_CMAC emi__ByteData +{ +public: + std::vectorByte; /* sequence of 8 to 8 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 304; } /* = unique id SOAP_TYPE_emi__ByteData */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__ByteData() : soap(NULL) { } + virtual ~emi__ByteData() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__EventLogRecordType +#define SOAP_TYPE_emi__EventLogRecordType (305) +/* emi:EventLogRecordType */ +class SOAP_CMAC emi__EventLogRecordType +{ +public: + unsigned int TimeStamp; /* required element of type emi:TimeType */ + unsigned char DeviceAddress; /* required element of type xsd:unsignedByte */ + unsigned char EventSensorType; /* required element of type xsd:unsignedByte */ + unsigned char EventType; /* required element of type xsd:unsignedByte */ + unsigned char EventOffset; /* required element of type xsd:unsignedByte */ + unsigned char EventSourceType; /* required element of type xsd:unsignedByte */ + enum emi__EventSeverityType EventSeverity; /* required element of type emi:EventSeverityType */ + unsigned char SensorNumber; /* required element of type xsd:unsignedByte */ + unsigned char Entity; /* required element of type xsd:unsignedByte */ + unsigned char EntityInstance; /* required element of type xsd:unsignedByte */ + emi__ByteData *EventData; /* required element of type emi:ByteData */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 305; } /* = unique id SOAP_TYPE_emi__EventLogRecordType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__EventLogRecordType() : EventData(NULL), soap(NULL) { } + virtual ~emi__EventLogRecordType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__EventFilterType +#define SOAP_TYPE_emi__EventFilterType (306) +/* emi:EventFilterType */ +class SOAP_CMAC emi__EventFilterType +{ +public: + unsigned char FilterConfiguration; /* required element of type xsd:unsignedByte */ + unsigned char FilterAction; /* required element of type xsd:unsignedByte */ + unsigned char AlertSubscriptionPolicyID; /* required element of type emi:AlertSubscriptionPolicyIDType */ + unsigned char DeviceAddress; /* required element of type xsd:unsignedByte */ + unsigned char EventSensorType; /* required element of type xsd:unsignedByte */ + unsigned char EventType; /* required element of type xsd:unsignedByte */ + unsigned char EventOffset; /* required element of type xsd:unsignedByte */ + unsigned char EventSourceType; /* required element of type xsd:unsignedByte */ + enum emi__EventSeverityType EventSeverity; /* required element of type emi:EventSeverityType */ + unsigned char SensorNumber; /* required element of type xsd:unsignedByte */ + unsigned char Entity; /* required element of type xsd:unsignedByte */ + unsigned char EntityInstance; /* required element of type xsd:unsignedByte */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 306; } /* = unique id SOAP_TYPE_emi__EventFilterType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__EventFilterType() : soap(NULL) { } + virtual ~emi__EventFilterType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__AlertSubscriptionType +#define SOAP_TYPE_emi__AlertSubscriptionType (307) +/* emi:AlertSubscriptionType */ +class SOAP_CMAC emi__AlertSubscriptionType +{ +public: + unsigned char AlertSubscriptionPolicyID; /* required element of type emi:AlertSubscriptionPolicyIDType */ + unsigned int DestinationAddress; /* required element of type emi:IPv4AddressType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 307; } /* = unique id SOAP_TYPE_emi__AlertSubscriptionType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__AlertSubscriptionType() : soap(NULL) { } + virtual ~emi__AlertSubscriptionType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__AlertSubscriptionHandleArrayType +#define SOAP_TYPE_emi__AlertSubscriptionHandleArrayType (308) +/* emi:AlertSubscriptionHandleArrayType */ +class SOAP_CMAC emi__AlertSubscriptionHandleArrayType +{ +public: + std::vectorAlertSubscriptionHandle; /* optional element of type emi:AlertSubscriptionHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 308; } /* = unique id SOAP_TYPE_emi__AlertSubscriptionHandleArrayType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__AlertSubscriptionHandleArrayType() : soap(NULL) { } + virtual ~emi__AlertSubscriptionHandleArrayType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__EventFilterHandleArrayType +#define SOAP_TYPE_emi__EventFilterHandleArrayType (309) +/* emi:EventFilterHandleArrayType */ +class SOAP_CMAC emi__EventFilterHandleArrayType +{ +public: + std::vectorEventFilterHandle; /* optional element of type emi:EventFilterHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 309; } /* = unique id SOAP_TYPE_emi__EventFilterHandleArrayType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__EventFilterHandleArrayType() : soap(NULL) { } + virtual ~emi__EventFilterHandleArrayType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__EventLogRecordArrayType +#define SOAP_TYPE_emi__EventLogRecordArrayType (310) +/* emi:EventLogRecordArrayType */ +class SOAP_CMAC emi__EventLogRecordArrayType +{ +public: + std::vectorEventLogRecord; /* optional element of type emi:EventLogRecordType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 310; } /* = unique id SOAP_TYPE_emi__EventLogRecordArrayType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__EventLogRecordArrayType() : soap(NULL) { } + virtual ~emi__EventLogRecordArrayType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__SensorHandleArrayType +#define SOAP_TYPE_emi__SensorHandleArrayType (311) +/* emi:SensorHandleArrayType */ +class SOAP_CMAC emi__SensorHandleArrayType +{ +public: + std::vectorSensorHandle; /* optional element of type emi:SensorHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 311; } /* = unique id SOAP_TYPE_emi__SensorHandleArrayType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__SensorHandleArrayType() : soap(NULL) { } + virtual ~emi__SensorHandleArrayType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__SensorAttributesType +#define SOAP_TYPE_emi__SensorAttributesType (312) +/* emi:SensorAttributesType */ +class SOAP_CMAC emi__SensorAttributesType +{ +public: + bool IsLegacySensor; /* required element of type xsd:boolean */ + bool AssertionEvent; /* required element of type xsd:boolean */ + bool DeassertionEvent; /* required element of type xsd:boolean */ + unsigned char Index; /* required element of type xsd:unsignedByte */ + unsigned char DeviceAddress; /* required element of type xsd:unsignedByte */ + unsigned char EventSensorType; /* required element of type xsd:unsignedByte */ + unsigned char EventType; /* required element of type xsd:unsignedByte */ + unsigned char EventOffset; /* required element of type xsd:unsignedByte */ + unsigned char EventSourceType; /* required element of type xsd:unsignedByte */ + enum emi__EventSeverityType EventSeverity; /* required element of type emi:EventSeverityType */ + unsigned char SensorNumber; /* required element of type xsd:unsignedByte */ + unsigned char Entity; /* required element of type xsd:unsignedByte */ + unsigned char EntityInstance; /* required element of type xsd:unsignedByte */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 312; } /* = unique id SOAP_TYPE_emi__SensorAttributesType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__SensorAttributesType() : soap(NULL) { } + virtual ~emi__SensorAttributesType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__ByteStr +#define SOAP_TYPE_emi__ByteStr (313) +/* emi:ByteStr */ +class SOAP_CMAC emi__ByteStr +{ +public: + std::vectorByte; /* sequence of 1 to 16 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 313; } /* = unique id SOAP_TYPE_emi__ByteStr */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__ByteStr() : soap(NULL) { } + virtual ~emi__ByteStr() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__AlertCredentialsType +#define SOAP_TYPE_emi__AlertCredentialsType (314) +/* emi:AlertCredentialsType */ +class SOAP_CMAC emi__AlertCredentialsType +{ +public: + std::string Username; /* required element of type xsd:string */ + std::string Password; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 314; } /* = unique id SOAP_TYPE_emi__AlertCredentialsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__AlertCredentialsType() : soap(NULL) { } + virtual ~emi__AlertCredentialsType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__AlertSubscriptionSNMPType +#define SOAP_TYPE_emi__AlertSubscriptionSNMPType (315) +/* emi:AlertSubscriptionSNMPType */ +class SOAP_CMAC emi__AlertSubscriptionSNMPType +{ +public: + cmn__NodeAddressType *Address; /* required element of type cmn:NodeAddressType */ + std::string *CommunityString; /* optional element of type emi:CommunityStringType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 315; } /* = unique id SOAP_TYPE_emi__AlertSubscriptionSNMPType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__AlertSubscriptionSNMPType() : Address(NULL), CommunityString(NULL), soap(NULL) { } + virtual ~emi__AlertSubscriptionSNMPType() { } +}; +#endif + +#ifndef SOAP_TYPE_emi__AlertSubscriptionSoapType +#define SOAP_TYPE_emi__AlertSubscriptionSoapType (316) +/* emi:AlertSubscriptionSoapType */ +class SOAP_CMAC emi__AlertSubscriptionSoapType +{ +public: + class cmn__URLType *Address; /* required element of type cmn:URLType */ + unsigned int *ClientCredentials; /* optional element of type sai:CertificateHandleType */ + emi__AlertCredentialsType *UserCredentials; /* optional element of type emi:AlertCredentialsType */ + std::vectorAlertAuthOptions; /* sequence of 0 to 3 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 316; } /* = unique id SOAP_TYPE_emi__AlertSubscriptionSoapType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__AlertSubscriptionSoapType() : Address(NULL), ClientCredentials(NULL), UserCredentials(NULL), soap(NULL) { } + virtual ~emi__AlertSubscriptionSoapType() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__union_AlertSubscriptionGeneralType +#define SOAP_TYPE__emi__union_AlertSubscriptionGeneralType (761) +/* xsd:choice */ +union _emi__union_AlertSubscriptionGeneralType +{ +#define SOAP_UNION__emi__union_AlertSubscriptionGeneralType_AlertSubscriptionSNMP (1) + emi__AlertSubscriptionSNMPType *AlertSubscriptionSNMP; +#define SOAP_UNION__emi__union_AlertSubscriptionGeneralType_AlertSubscriptionSoap (2) + emi__AlertSubscriptionSoapType *AlertSubscriptionSoap; +}; +#endif + +#ifndef SOAP_TYPE_emi__AlertSubscriptionGeneralType +#define SOAP_TYPE_emi__AlertSubscriptionGeneralType (317) +/* emi:AlertSubscriptionGeneralType */ +class SOAP_CMAC emi__AlertSubscriptionGeneralType +{ +public: + unsigned char PolicyID; /* required element of type emi:AlertSubscriptionPolicyIDType */ + int __union_AlertSubscriptionGeneralType; /* union discriminant (of union defined below) */ + union _emi__union_AlertSubscriptionGeneralType union_AlertSubscriptionGeneralType; /* required element of type xsd:choice */ + char *__any; + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 317; } /* = unique id SOAP_TYPE_emi__AlertSubscriptionGeneralType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + emi__AlertSubscriptionGeneralType() : __any(NULL), soap(NULL) { } + virtual ~emi__AlertSubscriptionGeneralType() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__SubscribeForAlert +#define SOAP_TYPE__emi__SubscribeForAlert (318) +/* emi:SubscribeForAlert */ +class SOAP_CMAC _emi__SubscribeForAlert +{ +public: + emi__AlertSubscriptionType *SubscriptionInfo; /* required element of type emi:AlertSubscriptionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 318; } /* = unique id SOAP_TYPE__emi__SubscribeForAlert */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__SubscribeForAlert() : SubscriptionInfo(NULL), soap(NULL) { } + virtual ~_emi__SubscribeForAlert() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__SubscribeForAlertResponse +#define SOAP_TYPE__emi__SubscribeForAlertResponse (319) +/* emi:SubscribeForAlertResponse */ +class SOAP_CMAC _emi__SubscribeForAlertResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int SubscriptionHandle; /* required element of type emi:AlertSubscriptionHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 319; } /* = unique id SOAP_TYPE__emi__SubscribeForAlertResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__SubscribeForAlertResponse() : soap(NULL) { } + virtual ~_emi__SubscribeForAlertResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateAlertSubscriptions +#define SOAP_TYPE__emi__EnumerateAlertSubscriptions (320) +/* emi:EnumerateAlertSubscriptions */ +class SOAP_CMAC _emi__EnumerateAlertSubscriptions +{ +public: + unsigned int StartIndex; /* required element of type xsd:unsignedInt */ + unsigned char *AlertSubscriptionPolicyID; /* optional element of type emi:AlertSubscriptionPolicyIDType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 320; } /* = unique id SOAP_TYPE__emi__EnumerateAlertSubscriptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateAlertSubscriptions() : AlertSubscriptionPolicyID(NULL), soap(NULL) { } + virtual ~_emi__EnumerateAlertSubscriptions() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse +#define SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse (321) +/* emi:EnumerateAlertSubscriptionsResponse */ +class SOAP_CMAC _emi__EnumerateAlertSubscriptionsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int TotalSubscriptionCount; /* required element of type xsd:unsignedInt */ + unsigned int SubscriptionsReturned; /* required element of type xsd:unsignedInt */ + emi__AlertSubscriptionHandleArrayType *SubscriptionHandles; /* required element of type emi:AlertSubscriptionHandleArrayType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 321; } /* = unique id SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateAlertSubscriptionsResponse() : SubscriptionHandles(NULL), soap(NULL) { } + virtual ~_emi__EnumerateAlertSubscriptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetAlertSubscription +#define SOAP_TYPE__emi__GetAlertSubscription (322) +/* emi:GetAlertSubscription */ +class SOAP_CMAC _emi__GetAlertSubscription +{ +public: + unsigned int SubscriptionID; /* required element of type emi:AlertSubscriptionHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 322; } /* = unique id SOAP_TYPE__emi__GetAlertSubscription */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetAlertSubscription() : soap(NULL) { } + virtual ~_emi__GetAlertSubscription() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetAlertSubscriptionResponse +#define SOAP_TYPE__emi__GetAlertSubscriptionResponse (323) +/* emi:GetAlertSubscriptionResponse */ +class SOAP_CMAC _emi__GetAlertSubscriptionResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + emi__AlertSubscriptionType *SubscriptionInfo; /* required element of type emi:AlertSubscriptionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 323; } /* = unique id SOAP_TYPE__emi__GetAlertSubscriptionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetAlertSubscriptionResponse() : SubscriptionInfo(NULL), soap(NULL) { } + virtual ~_emi__GetAlertSubscriptionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateAlertPolicies +#define SOAP_TYPE__emi__EnumerateAlertPolicies (324) +/* emi:EnumerateAlertPolicies */ +class SOAP_CMAC _emi__EnumerateAlertPolicies +{ +public: + unsigned int StartIndex; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 324; } /* = unique id SOAP_TYPE__emi__EnumerateAlertPolicies */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateAlertPolicies() : soap(NULL) { } + virtual ~_emi__EnumerateAlertPolicies() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateAlertPoliciesResponse +#define SOAP_TYPE__emi__EnumerateAlertPoliciesResponse (325) +/* emi:EnumerateAlertPoliciesResponse */ +class SOAP_CMAC _emi__EnumerateAlertPoliciesResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int TotalPolicyCount; /* required element of type xsd:unsignedInt */ + unsigned int PoliciesReturned; /* required element of type xsd:unsignedInt */ + emi__AlertSubscriptionPolicyIDArrayType *PolicyHandles; /* required element of type emi:AlertSubscriptionPolicyIDArrayType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 325; } /* = unique id SOAP_TYPE__emi__EnumerateAlertPoliciesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateAlertPoliciesResponse() : PolicyHandles(NULL), soap(NULL) { } + virtual ~_emi__EnumerateAlertPoliciesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__SetAlertCommunityString +#define SOAP_TYPE__emi__SetAlertCommunityString (326) +/* emi:SetAlertCommunityString */ +class SOAP_CMAC _emi__SetAlertCommunityString +{ +public: + unsigned char Length; /* required element of type xsd:unsignedByte */ + emi__ByteStr *CommunityString; /* required element of type emi:ByteStr */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 326; } /* = unique id SOAP_TYPE__emi__SetAlertCommunityString */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__SetAlertCommunityString() : CommunityString(NULL), soap(NULL) { } + virtual ~_emi__SetAlertCommunityString() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__SetAlertCommunityStringResponse +#define SOAP_TYPE__emi__SetAlertCommunityStringResponse (327) +/* emi:SetAlertCommunityStringResponse */ +class SOAP_CMAC _emi__SetAlertCommunityStringResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 327; } /* = unique id SOAP_TYPE__emi__SetAlertCommunityStringResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__SetAlertCommunityStringResponse() : soap(NULL) { } + virtual ~_emi__SetAlertCommunityStringResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetAlertCommunityString +#define SOAP_TYPE__emi__GetAlertCommunityString (328) +/* emi:GetAlertCommunityString */ +class SOAP_CMAC _emi__GetAlertCommunityString +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 328; } /* = unique id SOAP_TYPE__emi__GetAlertCommunityString */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetAlertCommunityString() : soap(NULL) { } + virtual ~_emi__GetAlertCommunityString() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetAlertCommunityStringResponse +#define SOAP_TYPE__emi__GetAlertCommunityStringResponse (329) +/* emi:GetAlertCommunityStringResponse */ +class SOAP_CMAC _emi__GetAlertCommunityStringResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned char Length; /* required element of type xsd:unsignedByte */ + emi__ByteStr *CommunityString; /* required element of type emi:ByteStr */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 329; } /* = unique id SOAP_TYPE__emi__GetAlertCommunityStringResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetAlertCommunityStringResponse() : CommunityString(NULL), soap(NULL) { } + virtual ~_emi__GetAlertCommunityStringResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__AddEventFilter +#define SOAP_TYPE__emi__AddEventFilter (330) +/* emi:AddEventFilter */ +class SOAP_CMAC _emi__AddEventFilter +{ +public: + emi__EventFilterType *EventFilter; /* required element of type emi:EventFilterType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 330; } /* = unique id SOAP_TYPE__emi__AddEventFilter */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__AddEventFilter() : EventFilter(NULL), soap(NULL) { } + virtual ~_emi__AddEventFilter() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__AddEventFilterResponse +#define SOAP_TYPE__emi__AddEventFilterResponse (331) +/* emi:AddEventFilterResponse */ +class SOAP_CMAC _emi__AddEventFilterResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int EventFilterHandle; /* required element of type emi:EventFilterHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 331; } /* = unique id SOAP_TYPE__emi__AddEventFilterResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__AddEventFilterResponse() : soap(NULL) { } + virtual ~_emi__AddEventFilterResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateEventFilters +#define SOAP_TYPE__emi__EnumerateEventFilters (332) +/* emi:EnumerateEventFilters */ +class SOAP_CMAC _emi__EnumerateEventFilters +{ +public: + unsigned int StartIndex; /* required element of type xsd:unsignedInt */ + unsigned char *AlertSubscriptionPolicyID; /* optional element of type emi:AlertSubscriptionPolicyIDType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 332; } /* = unique id SOAP_TYPE__emi__EnumerateEventFilters */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateEventFilters() : AlertSubscriptionPolicyID(NULL), soap(NULL) { } + virtual ~_emi__EnumerateEventFilters() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateEventFiltersResponse +#define SOAP_TYPE__emi__EnumerateEventFiltersResponse (333) +/* emi:EnumerateEventFiltersResponse */ +class SOAP_CMAC _emi__EnumerateEventFiltersResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int TotalEventFilterCount; /* required element of type xsd:unsignedInt */ + unsigned int FiltersReturned; /* required element of type xsd:unsignedInt */ + emi__EventFilterHandleArrayType *Filters; /* required element of type emi:EventFilterHandleArrayType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 333; } /* = unique id SOAP_TYPE__emi__EnumerateEventFiltersResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateEventFiltersResponse() : Filters(NULL), soap(NULL) { } + virtual ~_emi__EnumerateEventFiltersResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetEventFilter +#define SOAP_TYPE__emi__GetEventFilter (334) +/* emi:GetEventFilter */ +class SOAP_CMAC _emi__GetEventFilter +{ +public: + unsigned int EventFilterHandle; /* required element of type emi:EventFilterHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 334; } /* = unique id SOAP_TYPE__emi__GetEventFilter */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetEventFilter() : soap(NULL) { } + virtual ~_emi__GetEventFilter() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetEventFilterResponse +#define SOAP_TYPE__emi__GetEventFilterResponse (335) +/* emi:GetEventFilterResponse */ +class SOAP_CMAC _emi__GetEventFilterResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + emi__EventFilterType *EventFilter; /* required element of type emi:EventFilterType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 335; } /* = unique id SOAP_TYPE__emi__GetEventFilterResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetEventFilterResponse() : EventFilter(NULL), soap(NULL) { } + virtual ~_emi__GetEventFilterResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__UpdateEventFilter +#define SOAP_TYPE__emi__UpdateEventFilter (336) +/* emi:UpdateEventFilter */ +class SOAP_CMAC _emi__UpdateEventFilter +{ +public: + unsigned int EventFilterHandle; /* required element of type emi:EventFilterHandleType */ + emi__EventFilterType *EventFilter; /* required element of type emi:EventFilterType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 336; } /* = unique id SOAP_TYPE__emi__UpdateEventFilter */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__UpdateEventFilter() : EventFilter(NULL), soap(NULL) { } + virtual ~_emi__UpdateEventFilter() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__UpdateEventFilterResponse +#define SOAP_TYPE__emi__UpdateEventFilterResponse (337) +/* emi:UpdateEventFilterResponse */ +class SOAP_CMAC _emi__UpdateEventFilterResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 337; } /* = unique id SOAP_TYPE__emi__UpdateEventFilterResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__UpdateEventFilterResponse() : soap(NULL) { } + virtual ~_emi__UpdateEventFilterResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__RemoveEventFilter +#define SOAP_TYPE__emi__RemoveEventFilter (338) +/* emi:RemoveEventFilter */ +class SOAP_CMAC _emi__RemoveEventFilter +{ +public: + unsigned int EventFilterHandle; /* required element of type emi:EventFilterHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 338; } /* = unique id SOAP_TYPE__emi__RemoveEventFilter */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__RemoveEventFilter() : soap(NULL) { } + virtual ~_emi__RemoveEventFilter() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__RemoveEventFilterResponse +#define SOAP_TYPE__emi__RemoveEventFilterResponse (339) +/* emi:RemoveEventFilterResponse */ +class SOAP_CMAC _emi__RemoveEventFilterResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 339; } /* = unique id SOAP_TYPE__emi__RemoveEventFilterResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__RemoveEventFilterResponse() : soap(NULL) { } + virtual ~_emi__RemoveEventFilterResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__ReadEventLogRecords +#define SOAP_TYPE__emi__ReadEventLogRecords (340) +/* emi:ReadEventLogRecords */ +class SOAP_CMAC _emi__ReadEventLogRecords +{ +public: + unsigned int StartIndex; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 340; } /* = unique id SOAP_TYPE__emi__ReadEventLogRecords */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__ReadEventLogRecords() : soap(NULL) { } + virtual ~_emi__ReadEventLogRecords() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__ReadEventLogRecordsResponse +#define SOAP_TYPE__emi__ReadEventLogRecordsResponse (341) +/* emi:ReadEventLogRecordsResponse */ +class SOAP_CMAC _emi__ReadEventLogRecordsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int TotalRecordCount; /* required element of type xsd:unsignedInt */ + unsigned int RecordsReturned; /* required element of type xsd:unsignedInt */ + emi__EventLogRecordArrayType *EventRecords; /* required element of type emi:EventLogRecordArrayType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 341; } /* = unique id SOAP_TYPE__emi__ReadEventLogRecordsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__ReadEventLogRecordsResponse() : EventRecords(NULL), soap(NULL) { } + virtual ~_emi__ReadEventLogRecordsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetEventLogStatus +#define SOAP_TYPE__emi__GetEventLogStatus (342) +/* emi:GetEventLogStatus */ +class SOAP_CMAC _emi__GetEventLogStatus +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 342; } /* = unique id SOAP_TYPE__emi__GetEventLogStatus */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetEventLogStatus() : soap(NULL) { } + virtual ~_emi__GetEventLogStatus() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetEventLogStatusResponse +#define SOAP_TYPE__emi__GetEventLogStatusResponse (343) +/* emi:GetEventLogStatusResponse */ +class SOAP_CMAC _emi__GetEventLogStatusResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int NumberOfFreeRecords; /* required element of type xsd:unsignedInt */ + unsigned int NumberOfRecords; /* required element of type xsd:unsignedInt */ + unsigned int Time; /* required element of type emi:TimeType */ + bool IsFrozen; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 343; } /* = unique id SOAP_TYPE__emi__GetEventLogStatusResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetEventLogStatusResponse() : soap(NULL) { } + virtual ~_emi__GetEventLogStatusResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__ClearEventLog +#define SOAP_TYPE__emi__ClearEventLog (344) +/* emi:ClearEventLog */ +class SOAP_CMAC _emi__ClearEventLog +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 344; } /* = unique id SOAP_TYPE__emi__ClearEventLog */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__ClearEventLog() : soap(NULL) { } + virtual ~_emi__ClearEventLog() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__ClearEventLogResponse +#define SOAP_TYPE__emi__ClearEventLogResponse (345) +/* emi:ClearEventLogResponse */ +class SOAP_CMAC _emi__ClearEventLogResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 345; } /* = unique id SOAP_TYPE__emi__ClearEventLogResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__ClearEventLogResponse() : soap(NULL) { } + virtual ~_emi__ClearEventLogResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__FreezeEventLog +#define SOAP_TYPE__emi__FreezeEventLog (346) +/* emi:FreezeEventLog */ +class SOAP_CMAC _emi__FreezeEventLog +{ +public: + bool NewState; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 346; } /* = unique id SOAP_TYPE__emi__FreezeEventLog */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__FreezeEventLog() : soap(NULL) { } + virtual ~_emi__FreezeEventLog() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__FreezeEventLogResponse +#define SOAP_TYPE__emi__FreezeEventLogResponse (347) +/* emi:FreezeEventLogResponse */ +class SOAP_CMAC _emi__FreezeEventLogResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 347; } /* = unique id SOAP_TYPE__emi__FreezeEventLogResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__FreezeEventLogResponse() : soap(NULL) { } + virtual ~_emi__FreezeEventLogResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__SetEventLogTimestampClock +#define SOAP_TYPE__emi__SetEventLogTimestampClock (348) +/* emi:SetEventLogTimestampClock */ +class SOAP_CMAC _emi__SetEventLogTimestampClock +{ +public: + unsigned int Time; /* required element of type emi:TimeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 348; } /* = unique id SOAP_TYPE__emi__SetEventLogTimestampClock */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__SetEventLogTimestampClock() : soap(NULL) { } + virtual ~_emi__SetEventLogTimestampClock() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__SetEventLogTimestampClockResponse +#define SOAP_TYPE__emi__SetEventLogTimestampClockResponse (349) +/* emi:SetEventLogTimestampClockResponse */ +class SOAP_CMAC _emi__SetEventLogTimestampClockResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 349; } /* = unique id SOAP_TYPE__emi__SetEventLogTimestampClockResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__SetEventLogTimestampClockResponse() : soap(NULL) { } + virtual ~_emi__SetEventLogTimestampClockResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetEventLogTimestampClock +#define SOAP_TYPE__emi__GetEventLogTimestampClock (350) +/* emi:GetEventLogTimestampClock */ +class SOAP_CMAC _emi__GetEventLogTimestampClock +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 350; } /* = unique id SOAP_TYPE__emi__GetEventLogTimestampClock */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetEventLogTimestampClock() : soap(NULL) { } + virtual ~_emi__GetEventLogTimestampClock() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetEventLogTimestampClockResponse +#define SOAP_TYPE__emi__GetEventLogTimestampClockResponse (351) +/* emi:GetEventLogTimestampClockResponse */ +class SOAP_CMAC _emi__GetEventLogTimestampClockResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int Time; /* required element of type emi:TimeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 351; } /* = unique id SOAP_TYPE__emi__GetEventLogTimestampClockResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetEventLogTimestampClockResponse() : soap(NULL) { } + virtual ~_emi__GetEventLogTimestampClockResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateSensors +#define SOAP_TYPE__emi__EnumerateSensors (352) +/* emi:EnumerateSensors */ +class SOAP_CMAC _emi__EnumerateSensors +{ +public: + unsigned int StartIndex; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 352; } /* = unique id SOAP_TYPE__emi__EnumerateSensors */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateSensors() : soap(NULL) { } + virtual ~_emi__EnumerateSensors() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateSensorsResponse +#define SOAP_TYPE__emi__EnumerateSensorsResponse (353) +/* emi:EnumerateSensorsResponse */ +class SOAP_CMAC _emi__EnumerateSensorsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int TotalCount; /* required element of type xsd:unsignedInt */ + unsigned int HandleCount; /* required element of type xsd:unsignedInt */ + emi__SensorHandleArrayType *Handles; /* required element of type emi:SensorHandleArrayType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 353; } /* = unique id SOAP_TYPE__emi__EnumerateSensorsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateSensorsResponse() : Handles(NULL), soap(NULL) { } + virtual ~_emi__EnumerateSensorsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetSensorAttributes +#define SOAP_TYPE__emi__GetSensorAttributes (354) +/* emi:GetSensorAttributes */ +class SOAP_CMAC _emi__GetSensorAttributes +{ +public: + unsigned int Handle; /* required element of type emi:SensorHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 354; } /* = unique id SOAP_TYPE__emi__GetSensorAttributes */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetSensorAttributes() : soap(NULL) { } + virtual ~_emi__GetSensorAttributes() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetSensorAttributesResponse +#define SOAP_TYPE__emi__GetSensorAttributesResponse (355) +/* emi:GetSensorAttributesResponse */ +class SOAP_CMAC _emi__GetSensorAttributesResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + emi__SensorAttributesType *Attributes; /* required element of type emi:SensorAttributesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 355; } /* = unique id SOAP_TYPE__emi__GetSensorAttributesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetSensorAttributesResponse() : Attributes(NULL), soap(NULL) { } + virtual ~_emi__GetSensorAttributesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__CancelAlertSubscription +#define SOAP_TYPE__emi__CancelAlertSubscription (356) +/* emi:CancelAlertSubscription */ +class SOAP_CMAC _emi__CancelAlertSubscription +{ +public: + unsigned int SubscriptionHandle; /* required element of type emi:AlertSubscriptionHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 356; } /* = unique id SOAP_TYPE__emi__CancelAlertSubscription */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__CancelAlertSubscription() : soap(NULL) { } + virtual ~_emi__CancelAlertSubscription() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__CancelAlertSubscriptionResponse +#define SOAP_TYPE__emi__CancelAlertSubscriptionResponse (357) +/* emi:CancelAlertSubscriptionResponse */ +class SOAP_CMAC _emi__CancelAlertSubscriptionResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 357; } /* = unique id SOAP_TYPE__emi__CancelAlertSubscriptionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__CancelAlertSubscriptionResponse() : soap(NULL) { } + virtual ~_emi__CancelAlertSubscriptionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__SubscribeForGeneralAlert +#define SOAP_TYPE__emi__SubscribeForGeneralAlert (358) +/* emi:SubscribeForGeneralAlert */ +class SOAP_CMAC _emi__SubscribeForGeneralAlert +{ +public: + emi__AlertSubscriptionGeneralType *SubscriptionInfo; /* required element of type emi:AlertSubscriptionGeneralType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 358; } /* = unique id SOAP_TYPE__emi__SubscribeForGeneralAlert */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__SubscribeForGeneralAlert() : SubscriptionInfo(NULL), soap(NULL) { } + virtual ~_emi__SubscribeForGeneralAlert() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__SubscribeForGeneralAlertResponse +#define SOAP_TYPE__emi__SubscribeForGeneralAlertResponse (359) +/* emi:SubscribeForGeneralAlertResponse */ +class SOAP_CMAC _emi__SubscribeForGeneralAlertResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + unsigned int SubscriptionHandle; /* required element of type emi:AlertSubscriptionHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 359; } /* = unique id SOAP_TYPE__emi__SubscribeForGeneralAlertResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__SubscribeForGeneralAlertResponse() : soap(NULL) { } + virtual ~_emi__SubscribeForGeneralAlertResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions +#define SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions (360) +/* emi:EnumerateGeneralAlertSubscriptions */ +class SOAP_CMAC _emi__EnumerateGeneralAlertSubscriptions +{ +public: + unsigned char *PolicyID; /* optional element of type emi:AlertSubscriptionPolicyIDType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 360; } /* = unique id SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateGeneralAlertSubscriptions() : PolicyID(NULL), soap(NULL) { } + virtual ~_emi__EnumerateGeneralAlertSubscriptions() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse +#define SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse (361) +/* emi:EnumerateGeneralAlertSubscriptionsResponse */ +class SOAP_CMAC _emi__EnumerateGeneralAlertSubscriptionsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + std::vectorSubscriptionHandle; /* optional element of type emi:AlertSubscriptionHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 361; } /* = unique id SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__EnumerateGeneralAlertSubscriptionsResponse() : soap(NULL) { } + virtual ~_emi__EnumerateGeneralAlertSubscriptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetGeneralAlertSubscription +#define SOAP_TYPE__emi__GetGeneralAlertSubscription (362) +/* emi:GetGeneralAlertSubscription */ +class SOAP_CMAC _emi__GetGeneralAlertSubscription +{ +public: + unsigned int SubscriptionHandle; /* required element of type emi:AlertSubscriptionHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 362; } /* = unique id SOAP_TYPE__emi__GetGeneralAlertSubscription */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetGeneralAlertSubscription() : soap(NULL) { } + virtual ~_emi__GetGeneralAlertSubscription() { } +}; +#endif + +#ifndef SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse +#define SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse (363) +/* emi:GetGeneralAlertSubscriptionResponse */ +class SOAP_CMAC _emi__GetGeneralAlertSubscriptionResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type emi:PT_STATUS */ + emi__AlertSubscriptionGeneralType *SubscriptionInfo; /* required element of type emi:AlertSubscriptionGeneralType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 363; } /* = unique id SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _emi__GetGeneralAlertSubscriptionResponse() : SubscriptionInfo(NULL), soap(NULL) { } + virtual ~_emi__GetGeneralAlertSubscriptionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType +#define SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType (364) +/* cb:CircuitBreakerAntiSpoofingFilterType */ +class SOAP_CMAC cb__CircuitBreakerAntiSpoofingFilterType +{ +public: + bool ActionEventOnMatch; /* required element of type xsd:boolean */ + bool ActionCount; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 364; } /* = unique id SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerAntiSpoofingFilterType() : soap(NULL) { } + virtual ~cb__CircuitBreakerAntiSpoofingFilterType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerPolicyType +#define SOAP_TYPE_cb__CircuitBreakerPolicyType (366) +/* cb:CircuitBreakerPolicyType */ +class SOAP_CMAC cb__CircuitBreakerPolicyType +{ +public: + char *PolicyName; /* optional element of type xsd:anyType */ + unsigned int PolicyPrecedence; /* required element of type xsd:unsignedInt */ + cb__CircuitBreakerAntiSpoofingFilterType *AntiSpoofingFilter; /* optional element of type cb:CircuitBreakerAntiSpoofingFilterType */ + std::vectorFilterCreationHandles; /* optional element of type xsd:unsignedInt */ + class cb__CircuitBreakerDefaultFilterType *DefaultTXFilter; /* required element of type cb:CircuitBreakerDefaultFilterType */ + cb__CircuitBreakerDefaultFilterType *DefaultRXFilter; /* required element of type cb:CircuitBreakerDefaultFilterType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 366; } /* = unique id SOAP_TYPE_cb__CircuitBreakerPolicyType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerPolicyType() : PolicyName(NULL), AntiSpoofingFilter(NULL), DefaultTXFilter(NULL), DefaultRXFilter(NULL), soap(NULL) { } + virtual ~cb__CircuitBreakerPolicyType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerPolicyInfoType +#define SOAP_TYPE_cb__CircuitBreakerPolicyInfoType (367) +/* cb:CircuitBreakerPolicyInfoType */ +class SOAP_CMAC cb__CircuitBreakerPolicyInfoType +{ +public: + cb__CircuitBreakerPolicyType *Policy; /* required element of type cb:CircuitBreakerPolicyType */ + unsigned int PolicyCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 367; } /* = unique id SOAP_TYPE_cb__CircuitBreakerPolicyInfoType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerPolicyInfoType() : Policy(NULL), soap(NULL) { } + virtual ~cb__CircuitBreakerPolicyInfoType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType +#define SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType (368) +/* cb:CircuitBreakerIPv4AddressAndMaskType */ +class SOAP_CMAC cb__CircuitBreakerIPv4AddressAndMaskType +{ +public: + enum cb__CircuitBreakerFilterIPAddressDirectionType IPAddressDirection; /* required element of type cb:CircuitBreakerFilterIPAddressDirectionType */ + std::string Address; /* required element of type cb:IPv4AddressStringType */ + std::string AddressMask; /* required element of type cb:IPv4AddressStringType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 368; } /* = unique id SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerIPv4AddressAndMaskType() : soap(NULL) { } + virtual ~cb__CircuitBreakerIPv4AddressAndMaskType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType +#define SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType (369) +/* cb:CircuitBreakerIPv6AddressAndMaskType */ +class SOAP_CMAC cb__CircuitBreakerIPv6AddressAndMaskType +{ +public: + enum cb__CircuitBreakerFilterIPAddressDirectionType IPAddressDirection; /* required element of type cb:CircuitBreakerFilterIPAddressDirectionType */ + std::string Address; /* required element of type cb:IPv6AddressStringType */ + std::string AddressMask; /* required element of type cb:IPv6AddressStringType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 369; } /* = unique id SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerIPv6AddressAndMaskType() : soap(NULL) { } + virtual ~cb__CircuitBreakerIPv6AddressAndMaskType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType +#define SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType (370) +/* cb:CircuitBreakerIPLayeredPortSimpleType */ +class SOAP_CMAC cb__CircuitBreakerIPLayeredPortSimpleType +{ +public: + unsigned short SourcePort; /* required element of type xsd:unsignedShort */ + unsigned short DestinationPort; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 370; } /* = unique id SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerIPLayeredPortSimpleType() : soap(NULL) { } + virtual ~cb__CircuitBreakerIPLayeredPortSimpleType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType +#define SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType (371) +/* cb:CircuitBreakerIPLayeredPortRangeType */ +class SOAP_CMAC cb__CircuitBreakerIPLayeredPortRangeType +{ +public: + unsigned short PortMin; /* required element of type xsd:unsignedShort */ + unsigned short PortMax; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 371; } /* = unique id SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerIPLayeredPortRangeType() : soap(NULL) { } + virtual ~cb__CircuitBreakerIPLayeredPortRangeType() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__union_CircuitBreakerIPLayeredPortType +#define SOAP_TYPE__cb__union_CircuitBreakerIPLayeredPortType (778) +/* xsd:choice */ +union _cb__union_CircuitBreakerIPLayeredPortType +{ +#define SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortSimple (1) + cb__CircuitBreakerIPLayeredPortSimpleType *IPLayeredPortSimple; +#define SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortRangeSource (2) + cb__CircuitBreakerIPLayeredPortRangeType *IPLayeredPortRangeSource; +#define SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortRangeDestination (3) + cb__CircuitBreakerIPLayeredPortRangeType *IPLayeredPortRangeDestination; +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType +#define SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType (372) +/* cb:CircuitBreakerIPLayeredPortType */ +class SOAP_CMAC cb__CircuitBreakerIPLayeredPortType +{ +public: + int __union_CircuitBreakerIPLayeredPortType; /* union discriminant (of union defined below) */ + union _cb__union_CircuitBreakerIPLayeredPortType union_CircuitBreakerIPLayeredPortType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 372; } /* = unique id SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerIPLayeredPortType() : soap(NULL) { } + virtual ~cb__CircuitBreakerIPLayeredPortType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType +#define SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType (373) +/* cb:CircuitBreakerIPLayeredTCPFlagsType */ +class SOAP_CMAC cb__CircuitBreakerIPLayeredTCPFlagsType +{ +public: + bool *TCP_USCOREFLAG_USCOREFIN; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCORESYN; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCORERST; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCOREPUSH; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCOREACK; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCOREURG; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCOREECNE; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCORECWR; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCORENS; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCOREReserved1; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCOREReserved2; /* optional element of type xsd:boolean */ + bool *TCP_USCOREFLAG_USCOREReserved3; /* optional element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 373; } /* = unique id SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerIPLayeredTCPFlagsType() : TCP_USCOREFLAG_USCOREFIN(NULL), TCP_USCOREFLAG_USCORESYN(NULL), TCP_USCOREFLAG_USCORERST(NULL), TCP_USCOREFLAG_USCOREPUSH(NULL), TCP_USCOREFLAG_USCOREACK(NULL), TCP_USCOREFLAG_USCOREURG(NULL), TCP_USCOREFLAG_USCOREECNE(NULL), TCP_USCOREFLAG_USCORECWR(NULL), TCP_USCOREFLAG_USCORENS(NULL), TCP_USCOREFLAG_USCOREReserved1(NULL), TCP_USCOREFLAG_USCOREReserved2(NULL), TCP_USCOREFLAG_USCOREReserved3(NULL), soap(NULL) { } + virtual ~cb__CircuitBreakerIPLayeredTCPFlagsType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPv4Type +#define SOAP_TYPE_cb__CircuitBreakerIPv4Type (374) +/* cb:CircuitBreakerIPv4Type */ +class SOAP_CMAC cb__CircuitBreakerIPv4Type +{ +public: + cb__CircuitBreakerIPv4AddressAndMaskType *IPv4Desc; /* optional element of type cb:CircuitBreakerIPv4AddressAndMaskType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 374; } /* = unique id SOAP_TYPE_cb__CircuitBreakerIPv4Type */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerIPv4Type() : IPv4Desc(NULL), soap(NULL) { } + virtual ~cb__CircuitBreakerIPv4Type() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPv6Type +#define SOAP_TYPE_cb__CircuitBreakerIPv6Type (375) +/* cb:CircuitBreakerIPv6Type */ +class SOAP_CMAC cb__CircuitBreakerIPv6Type +{ +public: + cb__CircuitBreakerIPv6AddressAndMaskType *IPv6Desc; /* optional element of type cb:CircuitBreakerIPv6AddressAndMaskType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 375; } /* = unique id SOAP_TYPE_cb__CircuitBreakerIPv6Type */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerIPv6Type() : IPv6Desc(NULL), soap(NULL) { } + virtual ~cb__CircuitBreakerIPv6Type() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__union_CircuitBreakerIPPacketType +#define SOAP_TYPE__cb__union_CircuitBreakerIPPacketType (783) +/* xsd:choice */ +union _cb__union_CircuitBreakerIPPacketType +{ +#define SOAP_UNION__cb__union_CircuitBreakerIPPacketType_IPv4 (1) + cb__CircuitBreakerIPv4Type *IPv4; +#define SOAP_UNION__cb__union_CircuitBreakerIPPacketType_IPv6 (2) + cb__CircuitBreakerIPv6Type *IPv6; +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerIPPacketType +#define SOAP_TYPE_cb__CircuitBreakerIPPacketType (376) +/* cb:CircuitBreakerIPPacketType */ +class SOAP_CMAC cb__CircuitBreakerIPPacketType +{ +public: + int __union_CircuitBreakerIPPacketType; /* union discriminant (of union defined below) */ + union _cb__union_CircuitBreakerIPPacketType union_CircuitBreakerIPPacketType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 376; } /* = unique id SOAP_TYPE_cb__CircuitBreakerIPPacketType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerIPPacketType() : soap(NULL) { } + virtual ~cb__CircuitBreakerIPPacketType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketUDPType +#define SOAP_TYPE_cb__CircuitBreakerPacketUDPType (377) +/* cb:CircuitBreakerPacketUDPType */ +class SOAP_CMAC cb__CircuitBreakerPacketUDPType +{ +public: + cb__CircuitBreakerIPPacketType *IPPacket; /* required element of type cb:CircuitBreakerIPPacketType */ + cb__CircuitBreakerIPLayeredPortType *IPLayeredPort; /* optional element of type cb:CircuitBreakerIPLayeredPortType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 377; } /* = unique id SOAP_TYPE_cb__CircuitBreakerPacketUDPType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerPacketUDPType() : IPPacket(NULL), IPLayeredPort(NULL), soap(NULL) { } + virtual ~cb__CircuitBreakerPacketUDPType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketIPType +#define SOAP_TYPE_cb__CircuitBreakerPacketIPType (379) +/* cb:CircuitBreakerPacketIPType */ +class SOAP_CMAC cb__CircuitBreakerPacketIPType +{ +public: + cb__CircuitBreakerIPPacketType *IPPacket; /* required element of type cb:CircuitBreakerIPPacketType */ + unsigned short *NextProtocol; /* optional element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 379; } /* = unique id SOAP_TYPE_cb__CircuitBreakerPacketIPType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerPacketIPType() : IPPacket(NULL), NextProtocol(NULL), soap(NULL) { } + virtual ~cb__CircuitBreakerPacketIPType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketETHType +#define SOAP_TYPE_cb__CircuitBreakerPacketETHType (380) +/* cb:CircuitBreakerPacketETHType */ +class SOAP_CMAC cb__CircuitBreakerPacketETHType +{ +public: + unsigned short EthernetFrameType; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 380; } /* = unique id SOAP_TYPE_cb__CircuitBreakerPacketETHType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerPacketETHType() : soap(NULL) { } + virtual ~cb__CircuitBreakerPacketETHType() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__union_CircuitBreakerPacketType +#define SOAP_TYPE__cb__union_CircuitBreakerPacketType (790) +/* xsd:choice */ +union _cb__union_CircuitBreakerPacketType +{ +#define SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketTCP (1) + class cb__CircuitBreakerPacketTCPType *PacketTCP; +#define SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketUDP (2) + cb__CircuitBreakerPacketUDPType *PacketUDP; +#define SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketIP (3) + cb__CircuitBreakerPacketIPType *PacketIP; +#define SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketETH (4) + cb__CircuitBreakerPacketETHType *PacketETH; +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketType +#define SOAP_TYPE_cb__CircuitBreakerPacketType (381) +/* cb:CircuitBreakerPacketType */ +class SOAP_CMAC cb__CircuitBreakerPacketType +{ +public: + int __union_CircuitBreakerPacketType; /* union discriminant (of union defined below) */ + union _cb__union_CircuitBreakerPacketType union_CircuitBreakerPacketType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 381; } /* = unique id SOAP_TYPE_cb__CircuitBreakerPacketType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerPacketType() : soap(NULL) { } + virtual ~cb__CircuitBreakerPacketType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterType +#define SOAP_TYPE_cb__CircuitBreakerFilterType (382) +/* cb:CircuitBreakerFilterType */ +class SOAP_CMAC cb__CircuitBreakerFilterType +{ +public: + char *FilterName; /* optional element of type xsd:anyType */ + enum cb__CircuitBreakerFilterDirectionType FilterDirection; /* required element of type cb:CircuitBreakerFilterDirectionType */ + enum cb__CircuitBreakerProfileType FilterProfile; /* required element of type cb:CircuitBreakerProfileType */ + unsigned int FilterProfileData; /* required element of type xsd:unsignedInt */ + cb__CircuitBreakerPacketType *FilterPacket; /* required element of type cb:CircuitBreakerPacketType */ + bool ActionEventOnMatch; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 382; } /* = unique id SOAP_TYPE_cb__CircuitBreakerFilterType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerFilterType() : FilterName(NULL), FilterPacket(NULL), soap(NULL) { } + virtual ~cb__CircuitBreakerFilterType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterInfoType +#define SOAP_TYPE_cb__CircuitBreakerFilterInfoType (383) +/* cb:CircuitBreakerFilterInfoType */ +class SOAP_CMAC cb__CircuitBreakerFilterInfoType +{ +public: + cb__CircuitBreakerFilterType *Filter; /* required element of type cb:CircuitBreakerFilterType */ + unsigned int FilterCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 383; } /* = unique id SOAP_TYPE_cb__CircuitBreakerFilterInfoType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerFilterInfoType() : Filter(NULL), soap(NULL) { } + virtual ~cb__CircuitBreakerFilterInfoType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerCapabilitiesType +#define SOAP_TYPE_cb__CircuitBreakerCapabilitiesType (384) +/* cb:CircuitBreakerCapabilitiesType */ +class SOAP_CMAC cb__CircuitBreakerCapabilitiesType +{ +public: + std::string HardwareDescription; /* required element of type xsd:string */ + unsigned int HardwareID; /* required element of type xsd:unsignedInt */ + unsigned short IPv4_USCOREMaxTxFilters; /* required element of type xsd:unsignedShort */ + unsigned short IPv4_USCOREMaxTxCounters; /* required element of type xsd:unsignedShort */ + unsigned short IPv4_USCOREMaxRxFilters; /* required element of type xsd:unsignedShort */ + unsigned short IPv4_USCOREMaxRxCounters; /* required element of type xsd:unsignedShort */ + bool IPv4_USCOREAntiSpoofingCapable; /* required element of type xsd:boolean */ + unsigned short IPv6_USCOREMaxTxFilters; /* required element of type xsd:unsignedShort */ + unsigned short IPv6_USCOREMaxTxCounters; /* required element of type xsd:unsignedShort */ + unsigned short IPv6_USCOREMaxRxFilters; /* required element of type xsd:unsignedShort */ + unsigned short IPv6_USCOREMaxRxCounters; /* required element of type xsd:unsignedShort */ + bool IPv6_USCOREAntiSpoofingCapable; /* required element of type xsd:boolean */ + unsigned short IPv6_USCORETo_USCOREIPv4_USCORERatio; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 384; } /* = unique id SOAP_TYPE_cb__CircuitBreakerCapabilitiesType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerCapabilitiesType() : soap(NULL) { } + virtual ~cb__CircuitBreakerCapabilitiesType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType +#define SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType (385) +/* cb:CircuitBreakerFilterStatisticsType */ +class SOAP_CMAC cb__CircuitBreakerFilterStatisticsType +{ +public: + unsigned int FilterCreationHandle; /* required element of type xsd:unsignedInt */ + unsigned int ReadCount; /* required element of type xsd:unsignedInt */ + bool FilterMatched; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 385; } /* = unique id SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerFilterStatisticsType() : soap(NULL) { } + virtual ~cb__CircuitBreakerFilterStatisticsType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType +#define SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType (386) +/* cb:CircuitBreakerHardwarePolicyType */ +class SOAP_CMAC cb__CircuitBreakerHardwarePolicyType +{ +public: + unsigned int HardwareID; /* required element of type xsd:unsignedInt */ + unsigned int PolicyCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 386; } /* = unique id SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerHardwarePolicyType() : soap(NULL) { } + virtual ~cb__CircuitBreakerHardwarePolicyType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__TimedCounterType +#define SOAP_TYPE_cb__TimedCounterType (387) +/* cb:TimedCounterType */ +class SOAP_CMAC cb__TimedCounterType +{ +public: + unsigned int Threshold; /* required element of type xsd:unsignedInt */ + unsigned int ClearTime; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 387; } /* = unique id SOAP_TYPE_cb__TimedCounterType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__TimedCounterType() : soap(NULL) { } + virtual ~cb__TimedCounterType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__BlockedPortInfoType +#define SOAP_TYPE_cb__BlockedPortInfoType (388) +/* cb:BlockedPortInfoType */ +class SOAP_CMAC cb__BlockedPortInfoType +{ +public: + unsigned short PortBlocked; /* required element of type xsd:unsignedShort */ + unsigned short ProtocolBlocked; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 388; } /* = unique id SOAP_TYPE_cb__BlockedPortInfoType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__BlockedPortInfoType() : soap(NULL) { } + virtual ~cb__BlockedPortInfoType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__HcbOptionsType +#define SOAP_TYPE_cb__HcbOptionsType (389) +/* cb:HcbOptionsType */ +class SOAP_CMAC cb__HcbOptionsType +{ +public: + cb__TimedCounterType *FastConnectionRate; /* optional element of type cb:TimedCounterType */ + cb__TimedCounterType *SlowConnectionRate; /* optional element of type cb:TimedCounterType */ + bool BlockAll; /* required element of type xsd:boolean */ + bool BlockOffensivePort; /* required element of type xsd:boolean */ + unsigned int *PolicyCreationHandle; /* optional element of type xsd:unsignedInt */ + unsigned short EncounterTimeout; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 389; } /* = unique id SOAP_TYPE_cb__HcbOptionsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__HcbOptionsType() : FastConnectionRate(NULL), SlowConnectionRate(NULL), PolicyCreationHandle(NULL), soap(NULL) { } + virtual ~cb__HcbOptionsType() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyCreate +#define SOAP_TYPE__cb__CbPolicyCreate (390) +/* cb:CbPolicyCreate */ +class SOAP_CMAC _cb__CbPolicyCreate +{ +public: + cb__CircuitBreakerPolicyType *Policy; /* required element of type cb:CircuitBreakerPolicyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 390; } /* = unique id SOAP_TYPE__cb__CbPolicyCreate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyCreate() : Policy(NULL), soap(NULL) { } + virtual ~_cb__CbPolicyCreate() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyCreateResponse +#define SOAP_TYPE__cb__CbPolicyCreateResponse (391) +/* cb:CbPolicyCreateResponse */ +class SOAP_CMAC _cb__CbPolicyCreateResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + unsigned int PolicyCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 391; } /* = unique id SOAP_TYPE__cb__CbPolicyCreateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyCreateResponse() : soap(NULL) { } + virtual ~_cb__CbPolicyCreateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyGet +#define SOAP_TYPE__cb__CbPolicyGet (392) +/* cb:CbPolicyGet */ +class SOAP_CMAC _cb__CbPolicyGet +{ +public: + unsigned int PolicyCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 392; } /* = unique id SOAP_TYPE__cb__CbPolicyGet */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyGet() : soap(NULL) { } + virtual ~_cb__CbPolicyGet() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyGetResponse +#define SOAP_TYPE__cb__CbPolicyGetResponse (393) +/* cb:CbPolicyGetResponse */ +class SOAP_CMAC _cb__CbPolicyGetResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + cb__CircuitBreakerPolicyType *Policy; /* required element of type cb:CircuitBreakerPolicyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 393; } /* = unique id SOAP_TYPE__cb__CbPolicyGetResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyGetResponse() : Policy(NULL), soap(NULL) { } + virtual ~_cb__CbPolicyGetResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyDelete +#define SOAP_TYPE__cb__CbPolicyDelete (394) +/* cb:CbPolicyDelete */ +class SOAP_CMAC _cb__CbPolicyDelete +{ +public: + unsigned int PolicyCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 394; } /* = unique id SOAP_TYPE__cb__CbPolicyDelete */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyDelete() : soap(NULL) { } + virtual ~_cb__CbPolicyDelete() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyDeleteResponse +#define SOAP_TYPE__cb__CbPolicyDeleteResponse (395) +/* cb:CbPolicyDeleteResponse */ +class SOAP_CMAC _cb__CbPolicyDeleteResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 395; } /* = unique id SOAP_TYPE__cb__CbPolicyDeleteResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyDeleteResponse() : soap(NULL) { } + virtual ~_cb__CbPolicyDeleteResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyEnumerate +#define SOAP_TYPE__cb__CbPolicyEnumerate (396) +/* cb:CbPolicyEnumerate */ +class SOAP_CMAC _cb__CbPolicyEnumerate +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 396; } /* = unique id SOAP_TYPE__cb__CbPolicyEnumerate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyEnumerate() : soap(NULL) { } + virtual ~_cb__CbPolicyEnumerate() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyEnumerateResponse +#define SOAP_TYPE__cb__CbPolicyEnumerateResponse (397) +/* cb:CbPolicyEnumerateResponse */ +class SOAP_CMAC _cb__CbPolicyEnumerateResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + std::vectorPolicies; /* optional element of type cb:CircuitBreakerPolicyInfoType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 397; } /* = unique id SOAP_TYPE__cb__CbPolicyEnumerateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyEnumerateResponse() : soap(NULL) { } + virtual ~_cb__CbPolicyEnumerateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyEnable +#define SOAP_TYPE__cb__CbPolicyEnable (398) +/* cb:CbPolicyEnable */ +class SOAP_CMAC _cb__CbPolicyEnable +{ +public: + std::vectorEnablePolicies; /* required element of type cb:CircuitBreakerHardwarePolicyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 398; } /* = unique id SOAP_TYPE__cb__CbPolicyEnable */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyEnable() : soap(NULL) { } + virtual ~_cb__CbPolicyEnable() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyEnableResponse +#define SOAP_TYPE__cb__CbPolicyEnableResponse (399) +/* cb:CbPolicyEnableResponse */ +class SOAP_CMAC _cb__CbPolicyEnableResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + std::vectorActivePolicies; /* optional element of type cb:CircuitBreakerHardwarePolicyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 399; } /* = unique id SOAP_TYPE__cb__CbPolicyEnableResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyEnableResponse() : soap(NULL) { } + virtual ~_cb__CbPolicyEnableResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyDisable +#define SOAP_TYPE__cb__CbPolicyDisable (400) +/* cb:CbPolicyDisable */ +class SOAP_CMAC _cb__CbPolicyDisable +{ +public: + unsigned int *HardwareID; /* optional element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 400; } /* = unique id SOAP_TYPE__cb__CbPolicyDisable */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyDisable() : HardwareID(NULL), soap(NULL) { } + virtual ~_cb__CbPolicyDisable() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyDisableResponse +#define SOAP_TYPE__cb__CbPolicyDisableResponse (401) +/* cb:CbPolicyDisableResponse */ +class SOAP_CMAC _cb__CbPolicyDisableResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 401; } /* = unique id SOAP_TYPE__cb__CbPolicyDisableResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyDisableResponse() : soap(NULL) { } + virtual ~_cb__CbPolicyDisableResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyGetEnabled +#define SOAP_TYPE__cb__CbPolicyGetEnabled (402) +/* cb:CbPolicyGetEnabled */ +class SOAP_CMAC _cb__CbPolicyGetEnabled +{ +public: + enum cb__CircuitBreakerApplicationType *AppType; /* optional element of type cb:CircuitBreakerApplicationType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 402; } /* = unique id SOAP_TYPE__cb__CbPolicyGetEnabled */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyGetEnabled() : AppType(NULL), soap(NULL) { } + virtual ~_cb__CbPolicyGetEnabled() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyGetEnabledResponse +#define SOAP_TYPE__cb__CbPolicyGetEnabledResponse (403) +/* cb:CbPolicyGetEnabledResponse */ +class SOAP_CMAC _cb__CbPolicyGetEnabledResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + std::vectorHwPolicies; /* optional element of type cb:CircuitBreakerHardwarePolicyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 403; } /* = unique id SOAP_TYPE__cb__CbPolicyGetEnabledResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyGetEnabledResponse() : soap(NULL) { } + virtual ~_cb__CbPolicyGetEnabledResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyGetActiveStatistics +#define SOAP_TYPE__cb__CbPolicyGetActiveStatistics (404) +/* cb:CbPolicyGetActiveStatistics */ +class SOAP_CMAC _cb__CbPolicyGetActiveStatistics +{ +public: + unsigned int HardwareID; /* required element of type xsd:unsignedInt */ + bool ResetStatisticsOnRead; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 404; } /* = unique id SOAP_TYPE__cb__CbPolicyGetActiveStatistics */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyGetActiveStatistics() : soap(NULL) { } + virtual ~_cb__CbPolicyGetActiveStatistics() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse +#define SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse (405) +/* cb:CbPolicyGetActiveStatisticsResponse */ +class SOAP_CMAC _cb__CbPolicyGetActiveStatisticsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + unsigned int PolicyCreationHandle; /* required element of type xsd:unsignedInt */ + unsigned int ActivationTime; /* required element of type cb:TimeType */ + unsigned int LastResetTime; /* required element of type cb:TimeType */ + std::vectorStatistics; /* optional element of type cb:CircuitBreakerFilterStatisticsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 405; } /* = unique id SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbPolicyGetActiveStatisticsResponse() : soap(NULL) { } + virtual ~_cb__CbPolicyGetActiveStatisticsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbFilterCreate +#define SOAP_TYPE__cb__CbFilterCreate (406) +/* cb:CbFilterCreate */ +class SOAP_CMAC _cb__CbFilterCreate +{ +public: + cb__CircuitBreakerFilterType *Filter; /* required element of type cb:CircuitBreakerFilterType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 406; } /* = unique id SOAP_TYPE__cb__CbFilterCreate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbFilterCreate() : Filter(NULL), soap(NULL) { } + virtual ~_cb__CbFilterCreate() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbFilterCreateResponse +#define SOAP_TYPE__cb__CbFilterCreateResponse (407) +/* cb:CbFilterCreateResponse */ +class SOAP_CMAC _cb__CbFilterCreateResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + unsigned int FilterCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 407; } /* = unique id SOAP_TYPE__cb__CbFilterCreateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbFilterCreateResponse() : soap(NULL) { } + virtual ~_cb__CbFilterCreateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbFilterGet +#define SOAP_TYPE__cb__CbFilterGet (408) +/* cb:CbFilterGet */ +class SOAP_CMAC _cb__CbFilterGet +{ +public: + unsigned int FilterCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 408; } /* = unique id SOAP_TYPE__cb__CbFilterGet */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbFilterGet() : soap(NULL) { } + virtual ~_cb__CbFilterGet() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbFilterGetResponse +#define SOAP_TYPE__cb__CbFilterGetResponse (409) +/* cb:CbFilterGetResponse */ +class SOAP_CMAC _cb__CbFilterGetResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + cb__CircuitBreakerFilterType *Filter; /* required element of type cb:CircuitBreakerFilterType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 409; } /* = unique id SOAP_TYPE__cb__CbFilterGetResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbFilterGetResponse() : Filter(NULL), soap(NULL) { } + virtual ~_cb__CbFilterGetResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbFilterDelete +#define SOAP_TYPE__cb__CbFilterDelete (410) +/* cb:CbFilterDelete */ +class SOAP_CMAC _cb__CbFilterDelete +{ +public: + unsigned int FilterCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 410; } /* = unique id SOAP_TYPE__cb__CbFilterDelete */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbFilterDelete() : soap(NULL) { } + virtual ~_cb__CbFilterDelete() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbFilterDeleteResponse +#define SOAP_TYPE__cb__CbFilterDeleteResponse (411) +/* cb:CbFilterDeleteResponse */ +class SOAP_CMAC _cb__CbFilterDeleteResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 411; } /* = unique id SOAP_TYPE__cb__CbFilterDeleteResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbFilterDeleteResponse() : soap(NULL) { } + virtual ~_cb__CbFilterDeleteResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbFilterEnumerate +#define SOAP_TYPE__cb__CbFilterEnumerate (412) +/* cb:CbFilterEnumerate */ +class SOAP_CMAC _cb__CbFilterEnumerate +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 412; } /* = unique id SOAP_TYPE__cb__CbFilterEnumerate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbFilterEnumerate() : soap(NULL) { } + virtual ~_cb__CbFilterEnumerate() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbFilterEnumerateResponse +#define SOAP_TYPE__cb__CbFilterEnumerateResponse (413) +/* cb:CbFilterEnumerateResponse */ +class SOAP_CMAC _cb__CbFilterEnumerateResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + std::vectorFilters; /* optional element of type cb:CircuitBreakerFilterInfoType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 413; } /* = unique id SOAP_TYPE__cb__CbFilterEnumerateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbFilterEnumerateResponse() : soap(NULL) { } + virtual ~_cb__CbFilterEnumerateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbQueryCapabilities +#define SOAP_TYPE__cb__CbQueryCapabilities (414) +/* cb:CbQueryCapabilities */ +class SOAP_CMAC _cb__CbQueryCapabilities +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 414; } /* = unique id SOAP_TYPE__cb__CbQueryCapabilities */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbQueryCapabilities() : soap(NULL) { } + virtual ~_cb__CbQueryCapabilities() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__CbQueryCapabilitiesResponse +#define SOAP_TYPE__cb__CbQueryCapabilitiesResponse (415) +/* cb:CbQueryCapabilitiesResponse */ +class SOAP_CMAC _cb__CbQueryCapabilitiesResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cb:PT_STATUS */ + unsigned int MaxSupportedPolicies; /* required element of type xsd:unsignedInt */ + unsigned int MaxSupportedFilters; /* required element of type xsd:unsignedInt */ + std::vectorCapabilities; /* required element of type cb:CircuitBreakerCapabilitiesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 415; } /* = unique id SOAP_TYPE__cb__CbQueryCapabilitiesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__CbQueryCapabilitiesResponse() : soap(NULL) { } + virtual ~_cb__CbQueryCapabilitiesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__SetHcbOptions +#define SOAP_TYPE__cb__SetHcbOptions (416) +/* cb:SetHcbOptions */ +class SOAP_CMAC _cb__SetHcbOptions +{ +public: + unsigned int InterfaceHandle; /* required element of type net:InterfaceHandleType */ + cb__HcbOptionsType *HcbOptions; /* optional element of type cb:HcbOptionsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 416; } /* = unique id SOAP_TYPE__cb__SetHcbOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__SetHcbOptions() : HcbOptions(NULL), soap(NULL) { } + virtual ~_cb__SetHcbOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__SetHcbOptionsResponse +#define SOAP_TYPE__cb__SetHcbOptionsResponse (417) +/* cb:SetHcbOptionsResponse */ +class SOAP_CMAC _cb__SetHcbOptionsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 417; } /* = unique id SOAP_TYPE__cb__SetHcbOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__SetHcbOptionsResponse() : soap(NULL) { } + virtual ~_cb__SetHcbOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__GetHcbOptions +#define SOAP_TYPE__cb__GetHcbOptions (418) +/* cb:GetHcbOptions */ +class SOAP_CMAC _cb__GetHcbOptions +{ +public: + unsigned int InterfaceHandle; /* required element of type net:InterfaceHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 418; } /* = unique id SOAP_TYPE__cb__GetHcbOptions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__GetHcbOptions() : soap(NULL) { } + virtual ~_cb__GetHcbOptions() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__GetHcbOptionsResponse +#define SOAP_TYPE__cb__GetHcbOptionsResponse (419) +/* cb:GetHcbOptionsResponse */ +class SOAP_CMAC _cb__GetHcbOptionsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + cb__HcbOptionsType *HcbOptions; /* optional element of type cb:HcbOptionsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 419; } /* = unique id SOAP_TYPE__cb__GetHcbOptionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__GetHcbOptionsResponse() : HcbOptions(NULL), soap(NULL) { } + virtual ~_cb__GetHcbOptionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__ClearHcbState +#define SOAP_TYPE__cb__ClearHcbState (420) +/* cb:ClearHcbState */ +class SOAP_CMAC _cb__ClearHcbState +{ +public: + unsigned int InterfaceHandle; /* required element of type net:InterfaceHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 420; } /* = unique id SOAP_TYPE__cb__ClearHcbState */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__ClearHcbState() : soap(NULL) { } + virtual ~_cb__ClearHcbState() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__ClearHcbStateResponse +#define SOAP_TYPE__cb__ClearHcbStateResponse (421) +/* cb:ClearHcbStateResponse */ +class SOAP_CMAC _cb__ClearHcbStateResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 421; } /* = unique id SOAP_TYPE__cb__ClearHcbStateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__ClearHcbStateResponse() : soap(NULL) { } + virtual ~_cb__ClearHcbStateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__GetHcbState +#define SOAP_TYPE__cb__GetHcbState (422) +/* cb:GetHcbState */ +class SOAP_CMAC _cb__GetHcbState +{ +public: + unsigned int InterfaceHandle; /* required element of type net:InterfaceHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 422; } /* = unique id SOAP_TYPE__cb__GetHcbState */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__GetHcbState() : soap(NULL) { } + virtual ~_cb__GetHcbState() { } +}; +#endif + +#ifndef SOAP_TYPE__cb__GetHcbStateResponse +#define SOAP_TYPE__cb__GetHcbStateResponse (423) +/* cb:GetHcbStateResponse */ +class SOAP_CMAC _cb__GetHcbStateResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + enum cb__HcbStateType HcbState; /* required element of type cb:HcbStateType */ + bool BlockedAll; /* required element of type xsd:boolean */ + unsigned int *TimeStamp; /* optional element of type cb:TimeType */ + enum cb__HcbTriggerReasonType *HcbTriggerReason; /* optional element of type cb:HcbTriggerReasonType */ + cb__BlockedPortInfoType *BlockedPortInfo; /* optional element of type cb:BlockedPortInfoType */ + unsigned int *EnabledCbPolicy; /* optional element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 423; } /* = unique id SOAP_TYPE__cb__GetHcbStateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _cb__GetHcbStateResponse() : TimeStamp(NULL), HcbTriggerReason(NULL), BlockedPortInfo(NULL), EnabledCbPolicy(NULL), soap(NULL) { } + virtual ~_cb__GetHcbStateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__AssetTypeArrayType +#define SOAP_TYPE_hwa__AssetTypeArrayType (424) +/* hwa:AssetTypeArrayType */ +class SOAP_CMAC hwa__AssetTypeArrayType +{ +public: + std::vectorAssetType; /* optional element of type hwa:AssetTypeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 424; } /* = unique id SOAP_TYPE_hwa__AssetTypeArrayType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__AssetTypeArrayType() : soap(NULL) { } + virtual ~hwa__AssetTypeArrayType() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__AssetDataArrayType +#define SOAP_TYPE_hwa__AssetDataArrayType (425) +/* hwa:AssetDataArrayType */ +class SOAP_CMAC hwa__AssetDataArrayType +{ +public: + std::vectorAssetData; /* optional element of type hwa:AssetDataType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 425; } /* = unique id SOAP_TYPE_hwa__AssetDataArrayType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__AssetDataArrayType() : soap(NULL) { } + virtual ~hwa__AssetDataArrayType() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__AssetDataType +#define SOAP_TYPE_hwa__AssetDataType (426) +/* hwa:AssetDataType */ +class SOAP_CMAC hwa__AssetDataType +{ +public: + enum hwa__AssetTypeType AssetType; /* required element of type hwa:AssetTypeType */ + unsigned int AssetSize; /* required element of type xsd:unsignedInt */ + xsd__base64Binary *AssetData; /* optional element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 426; } /* = unique id SOAP_TYPE_hwa__AssetDataType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__AssetDataType() : AssetData(NULL), soap(NULL) { } + virtual ~hwa__AssetDataType() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREBIOS +#define SOAP_TYPE_hwa__PT_USCOREBIOS (427) +/* hwa:PT_BIOS */ +class SOAP_CMAC hwa__PT_USCOREBIOS +{ +public: + unsigned int StructureVersion; /* required element of type xsd:unsignedInt */ + std::vectorVendor; /* sequence of 65 to 65 elements */ + std::vectorVersion; /* sequence of 65 to 65 elements */ + std::vectorReleaseDate; /* sequence of 65 to 65 elements */ + unsigned char padding; /* required element of type xsd:unsignedByte */ + unsigned int Characteristics; /* required element of type hwa:PT_BIOS_CHARACTERISTICS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 427; } /* = unique id SOAP_TYPE_hwa__PT_USCOREBIOS */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__PT_USCOREBIOS() : soap(NULL) { } + virtual ~hwa__PT_USCOREBIOS() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM +#define SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM (428) +/* hwa:PT_COMPUTER_SYSTEM */ +class SOAP_CMAC hwa__PT_USCORECOMPUTER_USCORESYSTEM +{ +public: + unsigned int StructureVersion; /* required element of type xsd:unsignedInt */ + std::vectorManufacturer; /* sequence of 65 to 65 elements */ + std::vectorProduct; /* sequence of 65 to 65 elements */ + std::vectorVersion; /* sequence of 65 to 65 elements */ + std::vectorSerialNumber; /* sequence of 65 to 65 elements */ + class hwa__GUID *UUID; /* required element of type hwa:GUID */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 428; } /* = unique id SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__PT_USCORECOMPUTER_USCORESYSTEM() : UUID(NULL), soap(NULL) { } + virtual ~hwa__PT_USCORECOMPUTER_USCORESYSTEM() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__GUID +#define SOAP_TYPE_hwa__GUID (429) +/* hwa:GUID */ +class SOAP_CMAC hwa__GUID +{ +public: + std::vectorGUIDbyte; /* sequence of 16 to 16 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 429; } /* = unique id SOAP_TYPE_hwa__GUID */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__GUID() : soap(NULL) { } + virtual ~hwa__GUID() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREBASEBOARD +#define SOAP_TYPE_hwa__PT_USCOREBASEBOARD (430) +/* hwa:PT_BASEBOARD */ +class SOAP_CMAC hwa__PT_USCOREBASEBOARD +{ +public: + unsigned int StructureVersion; /* required element of type xsd:unsignedInt */ + std::vectorManufacturer; /* sequence of 65 to 65 elements */ + std::vectorProduct; /* sequence of 65 to 65 elements */ + std::vectorVersion; /* sequence of 65 to 65 elements */ + std::vectorSerialNumber; /* sequence of 65 to 65 elements */ + std::vectorAssetTag; /* sequence of 65 to 65 elements */ + unsigned char Replaceable; /* required element of type xsd:unsignedByte */ + std::vectorPadding; /* sequence of 2 to 2 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 430; } /* = unique id SOAP_TYPE_hwa__PT_USCOREBASEBOARD */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__PT_USCOREBASEBOARD() : soap(NULL) { } + virtual ~hwa__PT_USCOREBASEBOARD() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR (431) +/* hwa:PT_PROCESSOR */ +class SOAP_CMAC hwa__PT_USCOREPROCESSOR +{ +public: + unsigned int StructureVersion; /* required element of type xsd:unsignedInt */ + std::vectorID; /* sequence of 2 to 2 elements */ + unsigned short MaxSocketSpeed; /* required element of type xsd:unsignedShort */ + unsigned short CurrentSpeed; /* required element of type xsd:unsignedShort */ + unsigned char Status; /* required element of type hwa:PT_PROCESSOR_STATUS */ + unsigned char Type; /* required element of type hwa:PT_PROCESSOR_TYPE */ + unsigned char Family; /* required element of type hwa:PT_PROCESSOR_FAMILY */ + unsigned char UpgradeInformation; /* required element of type hwa:PT_PROCESSOR_UPGRADE */ + unsigned char SocketPopluated; /* required element of type xsd:unsignedByte */ + std::vectorSocketDesignation; /* sequence of 65 to 65 elements */ + std::vectorManufacturer; /* sequence of 65 to 65 elements */ + std::vectorVersion; /* sequence of 65 to 65 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 431; } /* = unique id SOAP_TYPE_hwa__PT_USCOREPROCESSOR */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__PT_USCOREPROCESSOR() : soap(NULL) { } + virtual ~hwa__PT_USCOREPROCESSOR() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE +#define SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE (432) +/* hwa:PT_MEMORY_MODULE */ +class SOAP_CMAC hwa__PT_USCOREMEMORY_USCOREMODULE +{ +public: + unsigned int StructureVersion; /* required element of type xsd:unsignedInt */ + unsigned short Size; /* required element of type xsd:unsignedShort */ + unsigned char FormFactor; /* required element of type hwa:PT_MEMORY_FORM_FACTOR */ + unsigned char Type; /* required element of type hwa:PT_MEMORY_TYPE */ + unsigned short TypeDetail; /* required element of type hwa:PT_MEMORY_TYPE_DETAIL */ + unsigned short Speed; /* required element of type xsd:unsignedShort */ + std::vectorManufacturer; /* sequence of 65 to 65 elements */ + std::vectorSerialNumber; /* sequence of 65 to 65 elements */ + std::vectorAssetTag; /* sequence of 65 to 65 elements */ + std::vectorPartNumber; /* sequence of 65 to 65 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 432; } /* = unique id SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__PT_USCOREMEMORY_USCOREMODULE() : soap(NULL) { } + virtual ~hwa__PT_USCOREMEMORY_USCOREMODULE() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREFRU +#define SOAP_TYPE_hwa__PT_USCOREFRU (433) +/* hwa:PT_FRU */ +class SOAP_CMAC hwa__PT_USCOREFRU +{ +public: + unsigned int StructureVersion; /* required element of type xsd:unsignedInt */ + unsigned short VendorID; /* required element of type xsd:unsignedShort */ + unsigned short DeviceID; /* required element of type xsd:unsignedShort */ + unsigned char RevisionID; /* required element of type xsd:unsignedByte */ + unsigned char ProgIf; /* required element of type xsd:unsignedByte */ + unsigned char Subclass; /* required element of type xsd:unsignedByte */ + unsigned char BaseClass; /* required element of type xsd:unsignedByte */ + unsigned short SubvendorID; /* required element of type xsd:unsignedShort */ + unsigned short SubsystemID; /* required element of type xsd:unsignedShort */ + unsigned short DeviceLocation; /* required element of type xsd:unsignedShort */ + std::vectorPadding; /* sequence of 2 to 2 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 433; } /* = unique id SOAP_TYPE_hwa__PT_USCOREFRU */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__PT_USCOREFRU() : soap(NULL) { } + virtual ~hwa__PT_USCOREFRU() { } +}; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE +#define SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE (434) +/* hwa:PT_MEDIA_DEVICE */ +class SOAP_CMAC hwa__PT_USCOREMEDIA_USCOREDEVICE +{ +public: + unsigned int StructureVersion; /* required element of type xsd:unsignedInt */ + std::vectorModelNumber; /* sequence of 40 to 40 elements */ + std::vectorSerialNumber; /* sequence of 20 to 20 elements */ + std::vectorCapabilities; /* sequence of 3 to 3 elements */ + std::vectorMaxMediaSize; /* sequence of 2 to 2 elements */ + std::vectorPadding; /* sequence of 2 to 2 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 434; } /* = unique id SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + hwa__PT_USCOREMEDIA_USCOREDEVICE() : soap(NULL) { } + virtual ~hwa__PT_USCOREMEDIA_USCOREDEVICE() { } +}; +#endif + +#ifndef SOAP_TYPE__hwa__EnumerateAssetTypes +#define SOAP_TYPE__hwa__EnumerateAssetTypes (435) +/* hwa:EnumerateAssetTypes */ +class SOAP_CMAC _hwa__EnumerateAssetTypes +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 435; } /* = unique id SOAP_TYPE__hwa__EnumerateAssetTypes */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _hwa__EnumerateAssetTypes() : soap(NULL) { } + virtual ~_hwa__EnumerateAssetTypes() { } +}; +#endif + +#ifndef SOAP_TYPE__hwa__EnumerateAssetTypesResponse +#define SOAP_TYPE__hwa__EnumerateAssetTypesResponse (436) +/* hwa:EnumerateAssetTypesResponse */ +class SOAP_CMAC _hwa__EnumerateAssetTypesResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type hwa:PT_STATUS */ + unsigned int Count; /* required element of type xsd:unsignedInt */ + hwa__AssetTypeArrayType *AssetTypes; /* required element of type hwa:AssetTypeArrayType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 436; } /* = unique id SOAP_TYPE__hwa__EnumerateAssetTypesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _hwa__EnumerateAssetTypesResponse() : AssetTypes(NULL), soap(NULL) { } + virtual ~_hwa__EnumerateAssetTypesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__hwa__GetAssetData +#define SOAP_TYPE__hwa__GetAssetData (437) +/* hwa:GetAssetData */ +class SOAP_CMAC _hwa__GetAssetData +{ +public: + enum hwa__AssetTypeType AssetType; /* required element of type hwa:AssetTypeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 437; } /* = unique id SOAP_TYPE__hwa__GetAssetData */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _hwa__GetAssetData() : soap(NULL) { } + virtual ~_hwa__GetAssetData() { } +}; +#endif + +#ifndef SOAP_TYPE__hwa__GetAssetDataResponse +#define SOAP_TYPE__hwa__GetAssetDataResponse (438) +/* hwa:GetAssetDataResponse */ +class SOAP_CMAC _hwa__GetAssetDataResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type hwa:PT_STATUS */ + unsigned int Count; /* required element of type xsd:unsignedInt */ + hwa__AssetDataArrayType *AssetData; /* required element of type hwa:AssetDataArrayType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 438; } /* = unique id SOAP_TYPE__hwa__GetAssetDataResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _hwa__GetAssetDataResponse() : AssetData(NULL), soap(NULL) { } + virtual ~_hwa__GetAssetDataResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_apr__GUID +#define SOAP_TYPE_apr__GUID (439) +/* apr:GUID */ +class SOAP_CMAC apr__GUID +{ +public: + std::vectorByte; /* sequence of 16 to 16 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 439; } /* = unique id SOAP_TYPE_apr__GUID */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + apr__GUID() : soap(NULL) { } + virtual ~apr__GUID() { } +}; +#endif + +#ifndef SOAP_TYPE_apr__ConsoleWatchdogEntryType +#define SOAP_TYPE_apr__ConsoleWatchdogEntryType (440) +/* apr:ConsoleWatchdogEntryType */ +class SOAP_CMAC apr__ConsoleWatchdogEntryType +{ +public: + apr__GUID *AgentID; /* required element of type apr:GUID */ + char *AgentDescription; /* optional element of type xsd:anyType */ + unsigned short AgentHeartbeatTime; /* required element of type xsd:unsignedShort */ + unsigned short AgentStartupTime; /* required element of type xsd:unsignedShort */ + unsigned int NumActions; /* required element of type xsd:unsignedInt */ + unsigned char State; /* required element of type apr:WatchdogState */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 440; } /* = unique id SOAP_TYPE_apr__ConsoleWatchdogEntryType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + apr__ConsoleWatchdogEntryType() : AgentID(NULL), AgentDescription(NULL), soap(NULL) { } + virtual ~apr__ConsoleWatchdogEntryType() { } +}; +#endif + +#ifndef SOAP_TYPE_apr__ConsoleWatchdogActionType +#define SOAP_TYPE_apr__ConsoleWatchdogActionType (441) +/* apr:ConsoleWatchdogActionType */ +class SOAP_CMAC apr__ConsoleWatchdogActionType +{ +public: + unsigned char OldState; /* required element of type apr:WatchdogState */ + unsigned char NewState; /* required element of type apr:WatchdogState */ + bool ActionEventOnTransition; /* required element of type xsd:boolean */ + enum apr__CbActionType *ActionCb; /* optional element of type apr:CbActionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 441; } /* = unique id SOAP_TYPE_apr__ConsoleWatchdogActionType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + apr__ConsoleWatchdogActionType() : ActionCb(NULL), soap(NULL) { } + virtual ~apr__ConsoleWatchdogActionType() { } +}; +#endif + +#ifndef SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType +#define SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType (442) +/* apr:CircuitBreakerHardwarePolicyType */ +class SOAP_CMAC apr__CircuitBreakerHardwarePolicyType +{ +public: + unsigned int HardwareID; /* required element of type xsd:unsignedInt */ + unsigned int PolicyCreationHandle; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 442; } /* = unique id SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + apr__CircuitBreakerHardwarePolicyType() : soap(NULL) { } + virtual ~apr__CircuitBreakerHardwarePolicyType() { } +}; +#endif + +#ifndef SOAP_TYPE_apr__AgentPresenceCapabilitiesType +#define SOAP_TYPE_apr__AgentPresenceCapabilitiesType (443) +/* apr:AgentPresenceCapabilitiesType */ +class SOAP_CMAC apr__AgentPresenceCapabilitiesType +{ +public: + unsigned int MaxTotalAgents; /* required element of type xsd:unsignedInt */ + unsigned int MaxTotalActions; /* required element of type xsd:unsignedInt */ + unsigned int MinGuaranteedActionListSize; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 443; } /* = unique id SOAP_TYPE_apr__AgentPresenceCapabilitiesType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + apr__AgentPresenceCapabilitiesType() : soap(NULL) { } + virtual ~apr__AgentPresenceCapabilitiesType() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogCreate +#define SOAP_TYPE__apr__ConsoleWatchdogCreate (444) +/* apr:ConsoleWatchdogCreate */ +class SOAP_CMAC _apr__ConsoleWatchdogCreate +{ +public: + apr__GUID *AgentID; /* required element of type apr:GUID */ + char *AgentDescription; /* optional element of type xsd:anyType */ + unsigned short AgentHeartbeatTime; /* required element of type xsd:unsignedShort */ + unsigned short AgentStartupTime; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 444; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogCreate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogCreate() : AgentID(NULL), AgentDescription(NULL), soap(NULL) { } + virtual ~_apr__ConsoleWatchdogCreate() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogCreateResponse +#define SOAP_TYPE__apr__ConsoleWatchdogCreateResponse (445) +/* apr:ConsoleWatchdogCreateResponse */ +class SOAP_CMAC _apr__ConsoleWatchdogCreateResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apr:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 445; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogCreateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogCreateResponse() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogCreateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogDelete +#define SOAP_TYPE__apr__ConsoleWatchdogDelete (446) +/* apr:ConsoleWatchdogDelete */ +class SOAP_CMAC _apr__ConsoleWatchdogDelete +{ +public: + apr__GUID *AgentID; /* required element of type apr:GUID */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 446; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogDelete */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogDelete() : AgentID(NULL), soap(NULL) { } + virtual ~_apr__ConsoleWatchdogDelete() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse +#define SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse (447) +/* apr:ConsoleWatchdogDeleteResponse */ +class SOAP_CMAC _apr__ConsoleWatchdogDeleteResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apr:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 447; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogDeleteResponse() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogDeleteResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogEnumerate +#define SOAP_TYPE__apr__ConsoleWatchdogEnumerate (448) +/* apr:ConsoleWatchdogEnumerate */ +class SOAP_CMAC _apr__ConsoleWatchdogEnumerate +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 448; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogEnumerate */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogEnumerate() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogEnumerate() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse +#define SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse (449) +/* apr:ConsoleWatchdogEnumerateResponse */ +class SOAP_CMAC _apr__ConsoleWatchdogEnumerateResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apr:PT_STATUS */ + std::vectorConsoleWatchdogEntries; /* optional element of type apr:ConsoleWatchdogEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 449; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogEnumerateResponse() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogEnumerateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogSetActions +#define SOAP_TYPE__apr__ConsoleWatchdogSetActions (450) +/* apr:ConsoleWatchdogSetActions */ +class SOAP_CMAC _apr__ConsoleWatchdogSetActions +{ +public: + apr__GUID *AgentID; /* required element of type apr:GUID */ + std::vectorConsoleWatchdogActions; /* required element of type apr:ConsoleWatchdogActionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 450; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogSetActions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogSetActions() : AgentID(NULL), soap(NULL) { } + virtual ~_apr__ConsoleWatchdogSetActions() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse +#define SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse (451) +/* apr:ConsoleWatchdogSetActionsResponse */ +class SOAP_CMAC _apr__ConsoleWatchdogSetActionsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apr:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 451; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogSetActionsResponse() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogSetActionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogGetActions +#define SOAP_TYPE__apr__ConsoleWatchdogGetActions (452) +/* apr:ConsoleWatchdogGetActions */ +class SOAP_CMAC _apr__ConsoleWatchdogGetActions +{ +public: + apr__GUID *AgentID; /* required element of type apr:GUID */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 452; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogGetActions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogGetActions() : AgentID(NULL), soap(NULL) { } + virtual ~_apr__ConsoleWatchdogGetActions() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse +#define SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse (453) +/* apr:ConsoleWatchdogGetActionsResponse */ +class SOAP_CMAC _apr__ConsoleWatchdogGetActionsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apr:PT_STATUS */ + std::vectorConsoleWatchdogActions; /* optional element of type apr:ConsoleWatchdogActionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 453; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogGetActionsResponse() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogGetActionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy +#define SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy (454) +/* apr:ConsoleWatchdogSetCbPolicy */ +class SOAP_CMAC _apr__ConsoleWatchdogSetCbPolicy +{ +public: + std::vectorHwPolicies; /* optional element of type apr:CircuitBreakerHardwarePolicyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 454; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogSetCbPolicy() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogSetCbPolicy() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse +#define SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse (455) +/* apr:ConsoleWatchdogSetCbPolicyResponse */ +class SOAP_CMAC _apr__ConsoleWatchdogSetCbPolicyResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apr:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 455; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogSetCbPolicyResponse() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogSetCbPolicyResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy +#define SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy (456) +/* apr:ConsoleWatchdogGetCbPolicy */ +class SOAP_CMAC _apr__ConsoleWatchdogGetCbPolicy +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 456; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogGetCbPolicy() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogGetCbPolicy() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse +#define SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse (457) +/* apr:ConsoleWatchdogGetCbPolicyResponse */ +class SOAP_CMAC _apr__ConsoleWatchdogGetCbPolicyResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apr:PT_STATUS */ + std::vectorHwPolicies; /* optional element of type apr:CircuitBreakerHardwarePolicyType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 457; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogGetCbPolicyResponse() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogGetCbPolicyResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities +#define SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities (458) +/* apr:ConsoleWatchdogQueryCapabilities */ +class SOAP_CMAC _apr__ConsoleWatchdogQueryCapabilities +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 458; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogQueryCapabilities() : soap(NULL) { } + virtual ~_apr__ConsoleWatchdogQueryCapabilities() { } +}; +#endif + +#ifndef SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse +#define SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse (459) +/* apr:ConsoleWatchdogQueryCapabilitiesResponse */ +class SOAP_CMAC _apr__ConsoleWatchdogQueryCapabilitiesResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apr:PT_STATUS */ + apr__AgentPresenceCapabilitiesType *Capabilities; /* required element of type apr:AgentPresenceCapabilitiesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 459; } /* = unique id SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apr__ConsoleWatchdogQueryCapabilitiesResponse() : Capabilities(NULL), soap(NULL) { } + virtual ~_apr__ConsoleWatchdogQueryCapabilitiesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_apl__GUID +#define SOAP_TYPE_apl__GUID (460) +/* apl:GUID */ +class SOAP_CMAC apl__GUID +{ +public: + std::vectorByte; /* sequence of 16 to 16 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 460; } /* = unique id SOAP_TYPE_apl__GUID */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + apl__GUID() : soap(NULL) { } + virtual ~apl__GUID() { } +}; +#endif + +#ifndef SOAP_TYPE__apl__AgentWatchdogRegister +#define SOAP_TYPE__apl__AgentWatchdogRegister (461) +/* apl:AgentWatchdogRegister */ +class SOAP_CMAC _apl__AgentWatchdogRegister +{ +public: + apl__GUID *AgentID; /* required element of type apl:GUID */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 461; } /* = unique id SOAP_TYPE__apl__AgentWatchdogRegister */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apl__AgentWatchdogRegister() : AgentID(NULL), soap(NULL) { } + virtual ~_apl__AgentWatchdogRegister() { } +}; +#endif + +#ifndef SOAP_TYPE__apl__AgentWatchdogRegisterResponse +#define SOAP_TYPE__apl__AgentWatchdogRegisterResponse (462) +/* apl:AgentWatchdogRegisterResponse */ +class SOAP_CMAC _apl__AgentWatchdogRegisterResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apl:PT_STATUS */ + unsigned int SessionSequenceNumber; /* required element of type xsd:unsignedInt */ + unsigned short AgentHeartbeatTime; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 462; } /* = unique id SOAP_TYPE__apl__AgentWatchdogRegisterResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apl__AgentWatchdogRegisterResponse() : soap(NULL) { } + virtual ~_apl__AgentWatchdogRegisterResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__apl__AgentWatchdogHeartbeat +#define SOAP_TYPE__apl__AgentWatchdogHeartbeat (463) +/* apl:AgentWatchdogHeartbeat */ +class SOAP_CMAC _apl__AgentWatchdogHeartbeat +{ +public: + apl__GUID *AgentID; /* required element of type apl:GUID */ + unsigned int SessionSequenceNumber; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 463; } /* = unique id SOAP_TYPE__apl__AgentWatchdogHeartbeat */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apl__AgentWatchdogHeartbeat() : AgentID(NULL), soap(NULL) { } + virtual ~_apl__AgentWatchdogHeartbeat() { } +}; +#endif + +#ifndef SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse +#define SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse (464) +/* apl:AgentWatchdogHeartbeatResponse */ +class SOAP_CMAC _apl__AgentWatchdogHeartbeatResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apl:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 464; } /* = unique id SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apl__AgentWatchdogHeartbeatResponse() : soap(NULL) { } + virtual ~_apl__AgentWatchdogHeartbeatResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__apl__AgentWatchdogShutdown +#define SOAP_TYPE__apl__AgentWatchdogShutdown (465) +/* apl:AgentWatchdogShutdown */ +class SOAP_CMAC _apl__AgentWatchdogShutdown +{ +public: + apl__GUID *AgentID; /* required element of type apl:GUID */ + unsigned int SessionSequenceNumber; /* required element of type xsd:unsignedInt */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 465; } /* = unique id SOAP_TYPE__apl__AgentWatchdogShutdown */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apl__AgentWatchdogShutdown() : AgentID(NULL), soap(NULL) { } + virtual ~_apl__AgentWatchdogShutdown() { } +}; +#endif + +#ifndef SOAP_TYPE__apl__AgentWatchdogShutdownResponse +#define SOAP_TYPE__apl__AgentWatchdogShutdownResponse (466) +/* apl:AgentWatchdogShutdownResponse */ +class SOAP_CMAC _apl__AgentWatchdogShutdownResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type apl:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 466; } /* = unique id SOAP_TYPE__apl__AgentWatchdogShutdownResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _apl__AgentWatchdogShutdownResponse() : soap(NULL) { } + virtual ~_apl__AgentWatchdogShutdownResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_idr__IderSessionLogEntryType +#define SOAP_TYPE_idr__IderSessionLogEntryType (467) +/* idr:IderSessionLogEntryType */ +class SOAP_CMAC idr__IderSessionLogEntryType +{ +public: + unsigned int ConsoleAddress; /* required element of type idr:IPv4AddressType */ + unsigned short Port; /* required element of type xsd:unsignedShort */ + unsigned int TimeStamp; /* required element of type idr:TimeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 467; } /* = unique id SOAP_TYPE_idr__IderSessionLogEntryType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + idr__IderSessionLogEntryType() : soap(NULL) { } + virtual ~idr__IderSessionLogEntryType() { } +}; +#endif + +#ifndef SOAP_TYPE_idr__FirmwareVersionType +#define SOAP_TYPE_idr__FirmwareVersionType (468) +/* idr:FirmwareVersionType */ +class SOAP_CMAC idr__FirmwareVersionType +{ +public: + std::string Description; /* required element of type xsd:string */ + std::string Version; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 468; } /* = unique id SOAP_TYPE_idr__FirmwareVersionType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + idr__FirmwareVersionType() : soap(NULL) { } + virtual ~idr__FirmwareVersionType() { } +}; +#endif + +#ifndef SOAP_TYPE__idr__SetRedirectionListenerState +#define SOAP_TYPE__idr__SetRedirectionListenerState (469) +/* idr:SetRedirectionListenerState */ +class SOAP_CMAC _idr__SetRedirectionListenerState +{ +public: + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 469; } /* = unique id SOAP_TYPE__idr__SetRedirectionListenerState */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _idr__SetRedirectionListenerState() : soap(NULL) { } + virtual ~_idr__SetRedirectionListenerState() { } +}; +#endif + +#ifndef SOAP_TYPE__idr__SetRedirectionListenerStateResponse +#define SOAP_TYPE__idr__SetRedirectionListenerStateResponse (470) +/* idr:SetRedirectionListenerStateResponse */ +class SOAP_CMAC _idr__SetRedirectionListenerStateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type idr:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 470; } /* = unique id SOAP_TYPE__idr__SetRedirectionListenerStateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _idr__SetRedirectionListenerStateResponse() : soap(NULL) { } + virtual ~_idr__SetRedirectionListenerStateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__idr__GetRedirectionListenerState +#define SOAP_TYPE__idr__GetRedirectionListenerState (471) +/* idr:GetRedirectionListenerState */ +class SOAP_CMAC _idr__GetRedirectionListenerState +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 471; } /* = unique id SOAP_TYPE__idr__GetRedirectionListenerState */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _idr__GetRedirectionListenerState() : soap(NULL) { } + virtual ~_idr__GetRedirectionListenerState() { } +}; +#endif + +#ifndef SOAP_TYPE__idr__GetRedirectionListenerStateResponse +#define SOAP_TYPE__idr__GetRedirectionListenerStateResponse (472) +/* idr:GetRedirectionListenerStateResponse */ +class SOAP_CMAC _idr__GetRedirectionListenerStateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type idr:PT_STATUS */ + bool Enabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 472; } /* = unique id SOAP_TYPE__idr__GetRedirectionListenerStateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _idr__GetRedirectionListenerStateResponse() : soap(NULL) { } + virtual ~_idr__GetRedirectionListenerStateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__idr__GetIderSessionLog +#define SOAP_TYPE__idr__GetIderSessionLog (473) +/* idr:GetIderSessionLog */ +class SOAP_CMAC _idr__GetIderSessionLog +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 473; } /* = unique id SOAP_TYPE__idr__GetIderSessionLog */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _idr__GetIderSessionLog() : soap(NULL) { } + virtual ~_idr__GetIderSessionLog() { } +}; +#endif + +#ifndef SOAP_TYPE__idr__GetIderSessionLogResponse +#define SOAP_TYPE__idr__GetIderSessionLogResponse (474) +/* idr:GetIderSessionLogResponse */ +class SOAP_CMAC _idr__GetIderSessionLogResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type idr:PT_STATUS */ + std::vectorLogData; /* optional element of type idr:IderSessionLogEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 474; } /* = unique id SOAP_TYPE__idr__GetIderSessionLogResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _idr__GetIderSessionLogResponse() : soap(NULL) { } + virtual ~_idr__GetIderSessionLogResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__tim__GetLowAccuracyTimeSynch +#define SOAP_TYPE__tim__GetLowAccuracyTimeSynch (475) +/* tim:GetLowAccuracyTimeSynch */ +class SOAP_CMAC _tim__GetLowAccuracyTimeSynch +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 475; } /* = unique id SOAP_TYPE__tim__GetLowAccuracyTimeSynch */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _tim__GetLowAccuracyTimeSynch() : soap(NULL) { } + virtual ~_tim__GetLowAccuracyTimeSynch() { } +}; +#endif + +#ifndef SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse +#define SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse (476) +/* tim:GetLowAccuracyTimeSynchResponse */ +class SOAP_CMAC _tim__GetLowAccuracyTimeSynchResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type tim:PT_STATUS */ + unsigned int Ta0; /* required element of type tim:TimeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 476; } /* = unique id SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _tim__GetLowAccuracyTimeSynchResponse() : soap(NULL) { } + virtual ~_tim__GetLowAccuracyTimeSynchResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__tim__SetHighAccuracyTimeSynch +#define SOAP_TYPE__tim__SetHighAccuracyTimeSynch (477) +/* tim:SetHighAccuracyTimeSynch */ +class SOAP_CMAC _tim__SetHighAccuracyTimeSynch +{ +public: + unsigned int Ta0; /* required element of type tim:TimeType */ + unsigned int Tm1; /* required element of type tim:TimeType */ + unsigned int Tm2; /* required element of type tim:TimeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 477; } /* = unique id SOAP_TYPE__tim__SetHighAccuracyTimeSynch */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _tim__SetHighAccuracyTimeSynch() : soap(NULL) { } + virtual ~_tim__SetHighAccuracyTimeSynch() { } +}; +#endif + +#ifndef SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse +#define SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse (478) +/* tim:SetHighAccuracyTimeSynchResponse */ +class SOAP_CMAC _tim__SetHighAccuracyTimeSynchResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type tim:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 478; } /* = unique id SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _tim__SetHighAccuracyTimeSynchResponse() : soap(NULL) { } + virtual ~_tim__SetHighAccuracyTimeSynchResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__str__ExecuteStorageOperation +#define SOAP_TYPE__str__ExecuteStorageOperation (479) +/* str:ExecuteStorageOperation */ +class SOAP_CMAC _str__ExecuteStorageOperation +{ +public: + xsd__base64Binary Request; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 479; } /* = unique id SOAP_TYPE__str__ExecuteStorageOperation */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _str__ExecuteStorageOperation() : soap(NULL) { } + virtual ~_str__ExecuteStorageOperation() { } +}; +#endif + +#ifndef SOAP_TYPE__str__ExecuteStorageOperationResponse +#define SOAP_TYPE__str__ExecuteStorageOperationResponse (480) +/* str:ExecuteStorageOperationResponse */ +class SOAP_CMAC _str__ExecuteStorageOperationResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type str:PT_STATUS */ + xsd__base64Binary Response; /* required element of type xsd:base64Binary */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 480; } /* = unique id SOAP_TYPE__str__ExecuteStorageOperationResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _str__ExecuteStorageOperationResponse() : soap(NULL) { } + virtual ~_str__ExecuteStorageOperationResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_inf__IderSessionLogEntryType +#define SOAP_TYPE_inf__IderSessionLogEntryType (481) +/* inf:IderSessionLogEntryType */ +class SOAP_CMAC inf__IderSessionLogEntryType +{ +public: + unsigned int ConsoleAddress; /* required element of type inf:IPv4AddressType */ + unsigned short Port; /* required element of type xsd:unsignedShort */ + unsigned int TimeStamp; /* required element of type inf:TimeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 481; } /* = unique id SOAP_TYPE_inf__IderSessionLogEntryType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + inf__IderSessionLogEntryType() : soap(NULL) { } + virtual ~inf__IderSessionLogEntryType() { } +}; +#endif + +#ifndef SOAP_TYPE_inf__FirmwareVersionType +#define SOAP_TYPE_inf__FirmwareVersionType (482) +/* inf:FirmwareVersionType */ +class SOAP_CMAC inf__FirmwareVersionType +{ +public: + std::string Description; /* required element of type xsd:string */ + std::string Version; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 482; } /* = unique id SOAP_TYPE_inf__FirmwareVersionType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + inf__FirmwareVersionType() : soap(NULL) { } + virtual ~inf__FirmwareVersionType() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetCoreVersion +#define SOAP_TYPE__inf__GetCoreVersion (483) +/* inf:GetCoreVersion */ +class SOAP_CMAC _inf__GetCoreVersion +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 483; } /* = unique id SOAP_TYPE__inf__GetCoreVersion */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetCoreVersion() : soap(NULL) { } + virtual ~_inf__GetCoreVersion() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetCoreVersionResponse +#define SOAP_TYPE__inf__GetCoreVersionResponse (484) +/* inf:GetCoreVersionResponse */ +class SOAP_CMAC _inf__GetCoreVersionResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + std::string Version; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 484; } /* = unique id SOAP_TYPE__inf__GetCoreVersionResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetCoreVersionResponse() : soap(NULL) { } + virtual ~_inf__GetCoreVersionResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetCodeVersions +#define SOAP_TYPE__inf__GetCodeVersions (485) +/* inf:GetCodeVersions */ +class SOAP_CMAC _inf__GetCodeVersions +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 485; } /* = unique id SOAP_TYPE__inf__GetCodeVersions */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetCodeVersions() : soap(NULL) { } + virtual ~_inf__GetCodeVersions() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetCodeVersionsResponse +#define SOAP_TYPE__inf__GetCodeVersionsResponse (486) +/* inf:GetCodeVersionsResponse */ +class SOAP_CMAC _inf__GetCodeVersionsResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + std::string BiosVersion; /* required element of type xsd:string */ + std::vectorVersions; /* optional element of type inf:FirmwareVersionType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 486; } /* = unique id SOAP_TYPE__inf__GetCodeVersionsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetCodeVersionsResponse() : soap(NULL) { } + virtual ~_inf__GetCodeVersionsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetProvisioningMode +#define SOAP_TYPE__inf__GetProvisioningMode (487) +/* inf:GetProvisioningMode */ +class SOAP_CMAC _inf__GetProvisioningMode +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 487; } /* = unique id SOAP_TYPE__inf__GetProvisioningMode */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetProvisioningMode() : soap(NULL) { } + virtual ~_inf__GetProvisioningMode() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetProvisioningModeResponse +#define SOAP_TYPE__inf__GetProvisioningModeResponse (488) +/* inf:GetProvisioningModeResponse */ +class SOAP_CMAC _inf__GetProvisioningModeResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + enum inf__ProvisioningModeType ProvisioningMode; /* required element of type inf:ProvisioningModeType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 488; } /* = unique id SOAP_TYPE__inf__GetProvisioningModeResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetProvisioningModeResponse() : soap(NULL) { } + virtual ~_inf__GetProvisioningModeResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetProvisioningState +#define SOAP_TYPE__inf__GetProvisioningState (489) +/* inf:GetProvisioningState */ +class SOAP_CMAC _inf__GetProvisioningState +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 489; } /* = unique id SOAP_TYPE__inf__GetProvisioningState */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetProvisioningState() : soap(NULL) { } + virtual ~_inf__GetProvisioningState() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetProvisioningStateResponse +#define SOAP_TYPE__inf__GetProvisioningStateResponse (490) +/* inf:GetProvisioningStateResponse */ +class SOAP_CMAC _inf__GetProvisioningStateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + enum inf__ProvisioningStateType ProvisioningState; /* required element of type inf:ProvisioningStateType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 490; } /* = unique id SOAP_TYPE__inf__GetProvisioningStateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetProvisioningStateResponse() : soap(NULL) { } + virtual ~_inf__GetProvisioningStateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetVlanParameters +#define SOAP_TYPE__inf__GetVlanParameters (491) +/* inf:GetVlanParameters */ +class SOAP_CMAC _inf__GetVlanParameters +{ +public: + unsigned int *InterfaceHandle; /* optional element of type cmn:InterfaceHandleType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 491; } /* = unique id SOAP_TYPE__inf__GetVlanParameters */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetVlanParameters() : InterfaceHandle(NULL), soap(NULL) { } + virtual ~_inf__GetVlanParameters() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetVlanParametersResponse +#define SOAP_TYPE__inf__GetVlanParametersResponse (492) +/* inf:GetVlanParametersResponse */ +class SOAP_CMAC _inf__GetVlanParametersResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + bool VlanMode; /* required element of type xsd:boolean */ + unsigned short VlanTag; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 492; } /* = unique id SOAP_TYPE__inf__GetVlanParametersResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetVlanParametersResponse() : soap(NULL) { } + virtual ~_inf__GetVlanParametersResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetHostName +#define SOAP_TYPE__inf__GetHostName (493) +/* inf:GetHostName */ +class SOAP_CMAC _inf__GetHostName +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 493; } /* = unique id SOAP_TYPE__inf__GetHostName */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetHostName() : soap(NULL) { } + virtual ~_inf__GetHostName() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetHostNameResponse +#define SOAP_TYPE__inf__GetHostNameResponse (494) +/* inf:GetHostNameResponse */ +class SOAP_CMAC _inf__GetHostNameResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + std::string HostName; /* required element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 494; } /* = unique id SOAP_TYPE__inf__GetHostNameResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetHostNameResponse() : soap(NULL) { } + virtual ~_inf__GetHostNameResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetConfigServerInfo +#define SOAP_TYPE__inf__GetConfigServerInfo (495) +/* inf:GetConfigServerInfo */ +class SOAP_CMAC _inf__GetConfigServerInfo +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 495; } /* = unique id SOAP_TYPE__inf__GetConfigServerInfo */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetConfigServerInfo() : soap(NULL) { } + virtual ~_inf__GetConfigServerInfo() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetConfigServerInfoResponse +#define SOAP_TYPE__inf__GetConfigServerInfoResponse (496) +/* inf:GetConfigServerInfoResponse */ +class SOAP_CMAC _inf__GetConfigServerInfoResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + unsigned int Ip; /* required element of type inf:IPv4AddressType */ + unsigned short Port; /* required element of type xsd:unsignedShort */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 496; } /* = unique id SOAP_TYPE__inf__GetConfigServerInfoResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetConfigServerInfoResponse() : soap(NULL) { } + virtual ~_inf__GetConfigServerInfoResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetAdminAclEntryStatus +#define SOAP_TYPE__inf__GetAdminAclEntryStatus (497) +/* inf:GetAdminAclEntryStatus */ +class SOAP_CMAC _inf__GetAdminAclEntryStatus +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 497; } /* = unique id SOAP_TYPE__inf__GetAdminAclEntryStatus */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetAdminAclEntryStatus() : soap(NULL) { } + virtual ~_inf__GetAdminAclEntryStatus() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetAdminAclEntryStatusResponse +#define SOAP_TYPE__inf__GetAdminAclEntryStatusResponse (498) +/* inf:GetAdminAclEntryStatusResponse */ +class SOAP_CMAC _inf__GetAdminAclEntryStatusResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + bool IsDefault; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 498; } /* = unique id SOAP_TYPE__inf__GetAdminAclEntryStatusResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetAdminAclEntryStatusResponse() : soap(NULL) { } + virtual ~_inf__GetAdminAclEntryStatusResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetAdminNetAclEntryStatus +#define SOAP_TYPE__inf__GetAdminNetAclEntryStatus (499) +/* inf:GetAdminNetAclEntryStatus */ +class SOAP_CMAC _inf__GetAdminNetAclEntryStatus +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 499; } /* = unique id SOAP_TYPE__inf__GetAdminNetAclEntryStatus */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetAdminNetAclEntryStatus() : soap(NULL) { } + virtual ~_inf__GetAdminNetAclEntryStatus() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse +#define SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse (500) +/* inf:GetAdminNetAclEntryStatusResponse */ +class SOAP_CMAC _inf__GetAdminNetAclEntryStatusResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + bool IsDefault; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 500; } /* = unique id SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetAdminNetAclEntryStatusResponse() : soap(NULL) { } + virtual ~_inf__GetAdminNetAclEntryStatusResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetPasswordModel +#define SOAP_TYPE__inf__GetPasswordModel (501) +/* inf:GetPasswordModel */ +class SOAP_CMAC _inf__GetPasswordModel +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 501; } /* = unique id SOAP_TYPE__inf__GetPasswordModel */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetPasswordModel() : soap(NULL) { } + virtual ~_inf__GetPasswordModel() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetPasswordModelResponse +#define SOAP_TYPE__inf__GetPasswordModelResponse (502) +/* inf:GetPasswordModelResponse */ +class SOAP_CMAC _inf__GetPasswordModelResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + enum inf__PasswordModelType PasswordModel; /* required element of type inf:PasswordModelType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 502; } /* = unique id SOAP_TYPE__inf__GetPasswordModelResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetPasswordModelResponse() : soap(NULL) { } + virtual ~_inf__GetPasswordModelResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetEnabledInterfaces +#define SOAP_TYPE__inf__GetEnabledInterfaces (503) +/* inf:GetEnabledInterfaces */ +class SOAP_CMAC _inf__GetEnabledInterfaces +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 503; } /* = unique id SOAP_TYPE__inf__GetEnabledInterfaces */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetEnabledInterfaces() : soap(NULL) { } + virtual ~_inf__GetEnabledInterfaces() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetEnabledInterfacesResponse +#define SOAP_TYPE__inf__GetEnabledInterfacesResponse (504) +/* inf:GetEnabledInterfacesResponse */ +class SOAP_CMAC _inf__GetEnabledInterfacesResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + std::vectorEnabledInterfaces; /* optional element of type inf:EnabledInterfacesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 504; } /* = unique id SOAP_TYPE__inf__GetEnabledInterfacesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetEnabledInterfacesResponse() : soap(NULL) { } + virtual ~_inf__GetEnabledInterfacesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetNetworkState +#define SOAP_TYPE__inf__GetNetworkState (505) +/* inf:GetNetworkState */ +class SOAP_CMAC _inf__GetNetworkState +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 505; } /* = unique id SOAP_TYPE__inf__GetNetworkState */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetNetworkState() : soap(NULL) { } + virtual ~_inf__GetNetworkState() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetNetworkStateResponse +#define SOAP_TYPE__inf__GetNetworkStateResponse (506) +/* inf:GetNetworkStateResponse */ +class SOAP_CMAC _inf__GetNetworkStateResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + bool IsEnabled; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 506; } /* = unique id SOAP_TYPE__inf__GetNetworkStateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetNetworkStateResponse() : soap(NULL) { } + virtual ~_inf__GetNetworkStateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetSecurityParameters +#define SOAP_TYPE__inf__GetSecurityParameters (507) +/* inf:GetSecurityParameters */ +class SOAP_CMAC _inf__GetSecurityParameters +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 507; } /* = unique id SOAP_TYPE__inf__GetSecurityParameters */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetSecurityParameters() : soap(NULL) { } + virtual ~_inf__GetSecurityParameters() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetSecurityParametersResponse +#define SOAP_TYPE__inf__GetSecurityParametersResponse (508) +/* inf:GetSecurityParametersResponse */ +class SOAP_CMAC _inf__GetSecurityParametersResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + bool EnterpriseMode; /* required element of type xsd:boolean */ + bool TlsEnabled; /* required element of type xsd:boolean */ + bool HwCryptoEnabled; /* required element of type xsd:boolean */ + enum inf__ProvisioningStateType ProvisioningState; /* required element of type inf:ProvisioningStateType */ + bool NetworkInterfaceEnabled; /* required element of type xsd:boolean */ + bool SOLEnabled; /* required element of type xsd:boolean */ + bool IDEREnabled; /* required element of type xsd:boolean */ + bool FWUpdateEnabled; /* required element of type xsd:boolean */ + bool LinkIsUp; /* required element of type xsd:boolean */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 508; } /* = unique id SOAP_TYPE__inf__GetSecurityParametersResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetSecurityParametersResponse() : soap(NULL) { } + virtual ~_inf__GetSecurityParametersResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetIderSessionLog +#define SOAP_TYPE__inf__GetIderSessionLog (509) +/* inf:GetIderSessionLog */ +class SOAP_CMAC _inf__GetIderSessionLog +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 509; } /* = unique id SOAP_TYPE__inf__GetIderSessionLog */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetIderSessionLog() : soap(NULL) { } + virtual ~_inf__GetIderSessionLog() { } +}; +#endif + +#ifndef SOAP_TYPE__inf__GetIderSessionLogResponse +#define SOAP_TYPE__inf__GetIderSessionLogResponse (510) +/* inf:GetIderSessionLogResponse */ +class SOAP_CMAC _inf__GetIderSessionLogResponse +{ +public: + unsigned int StatusCode; /* RPC return element */ /* required element of type inf:PT_STATUS */ + std::vectorLogData; /* optional element of type inf:IderSessionLogEntryType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 510; } /* = unique id SOAP_TYPE__inf__GetIderSessionLogResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _inf__GetIderSessionLogResponse() : soap(NULL) { } + virtual ~_inf__GetIderSessionLogResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__rci__GetRemoteControlCapabilities +#define SOAP_TYPE__rci__GetRemoteControlCapabilities (511) +/* rci:GetRemoteControlCapabilities */ +class SOAP_CMAC _rci__GetRemoteControlCapabilities +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 511; } /* = unique id SOAP_TYPE__rci__GetRemoteControlCapabilities */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _rci__GetRemoteControlCapabilities() : soap(NULL) { } + virtual ~_rci__GetRemoteControlCapabilities() { } +}; +#endif + +#ifndef SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse +#define SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse (512) +/* rci:GetRemoteControlCapabilitiesResponse */ +class SOAP_CMAC _rci__GetRemoteControlCapabilitiesResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type rci:PT_STATUS */ + unsigned int IanaOemNumber; /* required element of type xsd:unsignedInt */ + unsigned int OemDefinedCapabilities; /* required element of type rci:OemDefinedCapabilitiesType */ + unsigned short SpecialCommandsSupported; /* required element of type rci:SpecialCommandsSupportedType */ + unsigned char SystemCapabilitiesSupported; /* required element of type rci:SystemCapabilitiesSupportedType */ + unsigned int SystemFirmwareCapabilities; /* required element of type rci:SystemFirmwareCapabilitiesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 512; } /* = unique id SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _rci__GetRemoteControlCapabilitiesResponse() : soap(NULL) { } + virtual ~_rci__GetRemoteControlCapabilitiesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__rci__RemoteControl +#define SOAP_TYPE__rci__RemoteControl (513) +/* rci:RemoteControl */ +class SOAP_CMAC _rci__RemoteControl +{ +public: + enum rci__RemoteControlCommandType Command; /* required element of type rci:RemoteControlCommandType */ + unsigned int IanaOemNumber; /* required element of type xsd:unsignedInt */ + enum rci__SpecialCommandType *SpecialCommand; /* optional element of type rci:SpecialCommandType */ + unsigned short *SpecialCommandParameter; /* optional element of type rci:SpecialCommandParameterType */ + unsigned short *BootOptions; /* optional element of type rci:BootOptionsType */ + unsigned short *OEMparameters; /* optional element of type rci:OemParametersType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 513; } /* = unique id SOAP_TYPE__rci__RemoteControl */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _rci__RemoteControl() : SpecialCommand(NULL), SpecialCommandParameter(NULL), BootOptions(NULL), OEMparameters(NULL), soap(NULL) { } + virtual ~_rci__RemoteControl() { } +}; +#endif + +#ifndef SOAP_TYPE__rci__RemoteControlResponse +#define SOAP_TYPE__rci__RemoteControlResponse (514) +/* rci:RemoteControlResponse */ +class SOAP_CMAC _rci__RemoteControlResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type rci:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 514; } /* = unique id SOAP_TYPE__rci__RemoteControlResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _rci__RemoteControlResponse() : soap(NULL) { } + virtual ~_rci__RemoteControlResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__rci__GetSystemPowerState +#define SOAP_TYPE__rci__GetSystemPowerState (515) +/* rci:GetSystemPowerState */ +class SOAP_CMAC _rci__GetSystemPowerState +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 515; } /* = unique id SOAP_TYPE__rci__GetSystemPowerState */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _rci__GetSystemPowerState() : soap(NULL) { } + virtual ~_rci__GetSystemPowerState() { } +}; +#endif + +#ifndef SOAP_TYPE__rci__GetSystemPowerStateResponse +#define SOAP_TYPE__rci__GetSystemPowerStateResponse (516) +/* rci:GetSystemPowerStateResponse */ +class SOAP_CMAC _rci__GetSystemPowerStateResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type rci:PT_STATUS */ + unsigned int SystemPowerState; /* required element of type rci:SystemPowerStateType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 516; } /* = unique id SOAP_TYPE__rci__GetSystemPowerStateResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _rci__GetSystemPowerStateResponse() : soap(NULL) { } + virtual ~_rci__GetSystemPowerStateResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__union_WEP64Type +#define SOAP_TYPE__wcxs__union_WEP64Type (840) +/* xsd:choice */ +union _wcxs__union_WEP64Type +{ +#define SOAP_UNION__wcxs__union_WEP64Type_PassPhrase (1) + std::string *PassPhrase; +#define SOAP_UNION__wcxs__union_WEP64Type_RawKey (2) + xsd__base64Binary *RawKey; +}; +#endif + +#ifndef SOAP_TYPE_wcxs__WEP64Type +#define SOAP_TYPE_wcxs__WEP64Type (517) +/* wcxs:WEP64Type */ +class SOAP_CMAC wcxs__WEP64Type +{ +public: + int __union_WEP64Type; /* union discriminant (of union defined below) */ + union _wcxs__union_WEP64Type union_WEP64Type; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 517; } /* = unique id SOAP_TYPE_wcxs__WEP64Type */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__WEP64Type() : soap(NULL) { } + virtual ~wcxs__WEP64Type() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__union_WEP128Type +#define SOAP_TYPE__wcxs__union_WEP128Type (843) +/* xsd:choice */ +union _wcxs__union_WEP128Type +{ +#define SOAP_UNION__wcxs__union_WEP128Type_PassPhrase (1) + std::string *PassPhrase; +#define SOAP_UNION__wcxs__union_WEP128Type_RawKey (2) + xsd__base64Binary *RawKey; +}; +#endif + +#ifndef SOAP_TYPE_wcxs__WEP128Type +#define SOAP_TYPE_wcxs__WEP128Type (518) +/* wcxs:WEP128Type */ +class SOAP_CMAC wcxs__WEP128Type +{ +public: + int __union_WEP128Type; /* union discriminant (of union defined below) */ + union _wcxs__union_WEP128Type union_WEP128Type; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 518; } /* = unique id SOAP_TYPE_wcxs__WEP128Type */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__WEP128Type() : soap(NULL) { } + virtual ~wcxs__WEP128Type() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__union_DataEncryptionWEPXType +#define SOAP_TYPE__wcxs__union_DataEncryptionWEPXType (846) +/* xsd:choice */ +union _wcxs__union_DataEncryptionWEPXType +{ +#define SOAP_UNION__wcxs__union_DataEncryptionWEPXType_WEP64 (1) + wcxs__WEP64Type *WEP64; +#define SOAP_UNION__wcxs__union_DataEncryptionWEPXType_WEP128 (2) + wcxs__WEP128Type *WEP128; +}; +#endif + +#ifndef SOAP_TYPE_wcxs__DataEncryptionWEPXType +#define SOAP_TYPE_wcxs__DataEncryptionWEPXType (519) +/* wcxs:DataEncryptionWEPXType */ +class SOAP_CMAC wcxs__DataEncryptionWEPXType +{ +public: + enum wcxs__KeyIndexType KeyIndex; /* required element of type wcxs:KeyIndexType */ + int __union_DataEncryptionWEPXType; /* union discriminant (of union defined below) */ + union _wcxs__union_DataEncryptionWEPXType union_DataEncryptionWEPXType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 519; } /* = unique id SOAP_TYPE_wcxs__DataEncryptionWEPXType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__DataEncryptionWEPXType() : soap(NULL) { } + virtual ~wcxs__DataEncryptionWEPXType() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__union_DataEncryptionWEPType +#define SOAP_TYPE__wcxs__union_DataEncryptionWEPType (848) +/* xsd:choice */ +union _wcxs__union_DataEncryptionWEPType +{ +#define SOAP_UNION__wcxs__union_DataEncryptionWEPType_PassPhrase (1) + std::string *PassPhrase; +#define SOAP_UNION__wcxs__union_DataEncryptionWEPType_RawKey (2) + xsd__base64Binary *RawKey; +#define SOAP_UNION__wcxs__union_DataEncryptionWEPType_XProfile (3) + xcfg__XProfileType *XProfile; +}; +#endif + +#ifndef SOAP_TYPE_wcxs__DataEncryptionWEPType +#define SOAP_TYPE_wcxs__DataEncryptionWEPType (520) +/* wcxs:DataEncryptionWEPType */ +class SOAP_CMAC wcxs__DataEncryptionWEPType +{ +public: + int __union_DataEncryptionWEPType; /* union discriminant (of union defined below) */ + union _wcxs__union_DataEncryptionWEPType union_DataEncryptionWEPType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 520; } /* = unique id SOAP_TYPE_wcxs__DataEncryptionWEPType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__DataEncryptionWEPType() : soap(NULL) { } + virtual ~wcxs__DataEncryptionWEPType() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__union_DataEncryptionTKIPType +#define SOAP_TYPE__wcxs__union_DataEncryptionTKIPType (850) +/* xsd:choice */ +union _wcxs__union_DataEncryptionTKIPType +{ +#define SOAP_UNION__wcxs__union_DataEncryptionTKIPType_PassPhrase (1) + std::string *PassPhrase; +#define SOAP_UNION__wcxs__union_DataEncryptionTKIPType_RawKey (2) + xsd__base64Binary *RawKey; +#define SOAP_UNION__wcxs__union_DataEncryptionTKIPType_XProfile (3) + xcfg__XProfileType *XProfile; +}; +#endif + +#ifndef SOAP_TYPE_wcxs__DataEncryptionTKIPType +#define SOAP_TYPE_wcxs__DataEncryptionTKIPType (521) +/* wcxs:DataEncryptionTKIPType */ +class SOAP_CMAC wcxs__DataEncryptionTKIPType +{ +public: + int __union_DataEncryptionTKIPType; /* union discriminant (of union defined below) */ + union _wcxs__union_DataEncryptionTKIPType union_DataEncryptionTKIPType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 521; } /* = unique id SOAP_TYPE_wcxs__DataEncryptionTKIPType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__DataEncryptionTKIPType() : soap(NULL) { } + virtual ~wcxs__DataEncryptionTKIPType() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__union_DataEncryptionCCMPType +#define SOAP_TYPE__wcxs__union_DataEncryptionCCMPType (851) +/* xsd:choice */ +union _wcxs__union_DataEncryptionCCMPType +{ +#define SOAP_UNION__wcxs__union_DataEncryptionCCMPType_PassPhrase (1) + std::string *PassPhrase; +#define SOAP_UNION__wcxs__union_DataEncryptionCCMPType_RawKey (2) + xsd__base64Binary *RawKey; +#define SOAP_UNION__wcxs__union_DataEncryptionCCMPType_XProfile (3) + xcfg__XProfileType *XProfile; +}; +#endif + +#ifndef SOAP_TYPE_wcxs__DataEncryptionCCMPType +#define SOAP_TYPE_wcxs__DataEncryptionCCMPType (522) +/* wcxs:DataEncryptionCCMPType */ +class SOAP_CMAC wcxs__DataEncryptionCCMPType +{ +public: + int __union_DataEncryptionCCMPType; /* union discriminant (of union defined below) */ + union _wcxs__union_DataEncryptionCCMPType union_DataEncryptionCCMPType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 522; } /* = unique id SOAP_TYPE_wcxs__DataEncryptionCCMPType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__DataEncryptionCCMPType() : soap(NULL) { } + virtual ~wcxs__DataEncryptionCCMPType() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__union_ProfileSecuritySettingWPAType +#define SOAP_TYPE__wcxs__union_ProfileSecuritySettingWPAType (854) +/* xsd:choice */ +union _wcxs__union_ProfileSecuritySettingWPAType +{ +#define SOAP_UNION__wcxs__union_ProfileSecuritySettingWPAType_DataEncryptionTKIP (1) + wcxs__DataEncryptionTKIPType *DataEncryptionTKIP; +#define SOAP_UNION__wcxs__union_ProfileSecuritySettingWPAType_DataEncryptionCCMP (2) + wcxs__DataEncryptionCCMPType *DataEncryptionCCMP; +}; +#endif + +#ifndef SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType +#define SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType (523) +/* wcxs:ProfileSecuritySettingWPAType */ +class SOAP_CMAC wcxs__ProfileSecuritySettingWPAType +{ +public: + int __union_ProfileSecuritySettingWPAType; /* union discriminant (of union defined below) */ + union _wcxs__union_ProfileSecuritySettingWPAType union_ProfileSecuritySettingWPAType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 523; } /* = unique id SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__ProfileSecuritySettingWPAType() : soap(NULL) { } + virtual ~wcxs__ProfileSecuritySettingWPAType() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__union_ProfileSecuritySettingRSNType +#define SOAP_TYPE__wcxs__union_ProfileSecuritySettingRSNType (855) +/* xsd:choice */ +union _wcxs__union_ProfileSecuritySettingRSNType +{ +#define SOAP_UNION__wcxs__union_ProfileSecuritySettingRSNType_DataEncryptionTKIP (1) + wcxs__DataEncryptionTKIPType *DataEncryptionTKIP; +#define SOAP_UNION__wcxs__union_ProfileSecuritySettingRSNType_DataEncryptionCCMP (2) + wcxs__DataEncryptionCCMPType *DataEncryptionCCMP; +}; +#endif + +#ifndef SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType +#define SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType (524) +/* wcxs:ProfileSecuritySettingRSNType */ +class SOAP_CMAC wcxs__ProfileSecuritySettingRSNType +{ +public: + int __union_ProfileSecuritySettingRSNType; /* union discriminant (of union defined below) */ + union _wcxs__union_ProfileSecuritySettingRSNType union_ProfileSecuritySettingRSNType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 524; } /* = unique id SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__ProfileSecuritySettingRSNType() : soap(NULL) { } + virtual ~wcxs__ProfileSecuritySettingRSNType() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__union_ProfileSecuritySettingsType +#define SOAP_TYPE__wcxs__union_ProfileSecuritySettingsType (858) +/* xsd:choice */ +union _wcxs__union_ProfileSecuritySettingsType +{ +#define SOAP_UNION__wcxs__union_ProfileSecuritySettingsType_WPA (1) + wcxs__ProfileSecuritySettingWPAType *WPA; +#define SOAP_UNION__wcxs__union_ProfileSecuritySettingsType_RSN (2) + wcxs__ProfileSecuritySettingRSNType *RSN; +}; +#endif + +#ifndef SOAP_TYPE_wcxs__ProfileSecuritySettingsType +#define SOAP_TYPE_wcxs__ProfileSecuritySettingsType (525) +/* wcxs:ProfileSecuritySettingsType */ +class SOAP_CMAC wcxs__ProfileSecuritySettingsType +{ +public: + int __union_ProfileSecuritySettingsType; /* union discriminant (of union defined below) */ + union _wcxs__union_ProfileSecuritySettingsType union_ProfileSecuritySettingsType; /* required element of type xsd:choice */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 525; } /* = unique id SOAP_TYPE_wcxs__ProfileSecuritySettingsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__ProfileSecuritySettingsType() : soap(NULL) { } + virtual ~wcxs__ProfileSecuritySettingsType() { } +}; +#endif + +#ifndef SOAP_TYPE_wcxs__ProfileType +#define SOAP_TYPE_wcxs__ProfileType (526) +/* wcxs:ProfileType */ +class SOAP_CMAC wcxs__ProfileType +{ +public: + std::string ProfileName; /* required element of type wcxs:ProfileNameType */ + unsigned char Priority; /* required element of type wcxs:ProfilePriorityType */ + xsd__base64Binary *SSID; /* optional element of type xsd:base64Binary */ + wcxs__ProfileSecuritySettingsType *Security; /* required element of type wcxs:ProfileSecuritySettingsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 526; } /* = unique id SOAP_TYPE_wcxs__ProfileType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__ProfileType() : SSID(NULL), Security(NULL), soap(NULL) { } + virtual ~wcxs__ProfileType() { } +}; +#endif + +#ifndef SOAP_TYPE_wcxs__WirelessCapabilitiesType +#define SOAP_TYPE_wcxs__WirelessCapabilitiesType (527) +/* wcxs:WirelessCapabilitiesType */ +class SOAP_CMAC wcxs__WirelessCapabilitiesType +{ +public: + std::vectorSupportedFeatures; /* sequence of 1 to 4 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 527; } /* = unique id SOAP_TYPE_wcxs__WirelessCapabilitiesType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__WirelessCapabilitiesType() : soap(NULL) { } + virtual ~wcxs__WirelessCapabilitiesType() { } +}; +#endif + +#ifndef SOAP_TYPE_wcxs__WirelessSettingsType +#define SOAP_TYPE_wcxs__WirelessSettingsType (528) +/* wcxs:WirelessSettingsType */ +class SOAP_CMAC wcxs__WirelessSettingsType +{ +public: + bool RadioOn; /* required element of type xsd:boolean */ + std::string *ActiveProfile; /* optional element of type xsd:string */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 528; } /* = unique id SOAP_TYPE_wcxs__WirelessSettingsType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + wcxs__WirelessSettingsType() : ActiveProfile(NULL), soap(NULL) { } + virtual ~wcxs__WirelessSettingsType() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__AddWirelessProfileRequest +#define SOAP_TYPE__wcxs__AddWirelessProfileRequest (529) +/* wcxs:AddWirelessProfileRequest */ +class SOAP_CMAC _wcxs__AddWirelessProfileRequest +{ +public: + wcxs__ProfileType *Profile; /* required element of type wcxs:ProfileType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 529; } /* = unique id SOAP_TYPE__wcxs__AddWirelessProfileRequest */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__AddWirelessProfileRequest() : Profile(NULL), soap(NULL) { } + virtual ~_wcxs__AddWirelessProfileRequest() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__AddWirelessProfileResponse +#define SOAP_TYPE__wcxs__AddWirelessProfileResponse (530) +/* wcxs:AddWirelessProfileResponse */ +class SOAP_CMAC _wcxs__AddWirelessProfileResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 530; } /* = unique id SOAP_TYPE__wcxs__AddWirelessProfileResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__AddWirelessProfileResponse() : soap(NULL) { } + virtual ~_wcxs__AddWirelessProfileResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__GetWirelessProfileRequest +#define SOAP_TYPE__wcxs__GetWirelessProfileRequest (531) +/* wcxs:GetWirelessProfileRequest */ +class SOAP_CMAC _wcxs__GetWirelessProfileRequest +{ +public: + std::string ProfileName; /* required element of type wcxs:ProfileNameType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 531; } /* = unique id SOAP_TYPE__wcxs__GetWirelessProfileRequest */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__GetWirelessProfileRequest() : soap(NULL) { } + virtual ~_wcxs__GetWirelessProfileRequest() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__GetWirelessProfileResponse +#define SOAP_TYPE__wcxs__GetWirelessProfileResponse (532) +/* wcxs:GetWirelessProfileResponse */ +class SOAP_CMAC _wcxs__GetWirelessProfileResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + wcxs__ProfileType *Profile; /* required element of type wcxs:ProfileType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 532; } /* = unique id SOAP_TYPE__wcxs__GetWirelessProfileResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__GetWirelessProfileResponse() : Profile(NULL), soap(NULL) { } + virtual ~_wcxs__GetWirelessProfileResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__RemoveWirelessProfileRequest +#define SOAP_TYPE__wcxs__RemoveWirelessProfileRequest (533) +/* wcxs:RemoveWirelessProfileRequest */ +class SOAP_CMAC _wcxs__RemoveWirelessProfileRequest +{ +public: + std::string ProfileName; /* required element of type wcxs:ProfileNameType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 533; } /* = unique id SOAP_TYPE__wcxs__RemoveWirelessProfileRequest */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__RemoveWirelessProfileRequest() : soap(NULL) { } + virtual ~_wcxs__RemoveWirelessProfileRequest() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__RemoveWirelessProfileResponse +#define SOAP_TYPE__wcxs__RemoveWirelessProfileResponse (534) +/* wcxs:RemoveWirelessProfileResponse */ +class SOAP_CMAC _wcxs__RemoveWirelessProfileResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 534; } /* = unique id SOAP_TYPE__wcxs__RemoveWirelessProfileResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__RemoveWirelessProfileResponse() : soap(NULL) { } + virtual ~_wcxs__RemoveWirelessProfileResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__UpdateWirelessProfileRequest +#define SOAP_TYPE__wcxs__UpdateWirelessProfileRequest (535) +/* wcxs:UpdateWirelessProfileRequest */ +class SOAP_CMAC _wcxs__UpdateWirelessProfileRequest +{ +public: + wcxs__ProfileType *Profile; /* required element of type wcxs:ProfileType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 535; } /* = unique id SOAP_TYPE__wcxs__UpdateWirelessProfileRequest */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__UpdateWirelessProfileRequest() : Profile(NULL), soap(NULL) { } + virtual ~_wcxs__UpdateWirelessProfileRequest() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__UpdateWirelessProfileResponse +#define SOAP_TYPE__wcxs__UpdateWirelessProfileResponse (536) +/* wcxs:UpdateWirelessProfileResponse */ +class SOAP_CMAC _wcxs__UpdateWirelessProfileResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 536; } /* = unique id SOAP_TYPE__wcxs__UpdateWirelessProfileResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__UpdateWirelessProfileResponse() : soap(NULL) { } + virtual ~_wcxs__UpdateWirelessProfileResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest +#define SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest (537) +/* wcxs:EnumerateWirelessProfilesRequest */ +class SOAP_CMAC _wcxs__EnumerateWirelessProfilesRequest +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 537; } /* = unique id SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__EnumerateWirelessProfilesRequest() : soap(NULL) { } + virtual ~_wcxs__EnumerateWirelessProfilesRequest() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse +#define SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse (538) +/* wcxs:EnumerateWirelessProfilesResponse */ +class SOAP_CMAC _wcxs__EnumerateWirelessProfilesResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + std::vectorProfilesNames; /* sequence of 0 to 64 elements */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 538; } /* = unique id SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__EnumerateWirelessProfilesResponse() : soap(NULL) { } + virtual ~_wcxs__EnumerateWirelessProfilesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest +#define SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest (539) +/* wcxs:GetWirelessCapabilitiesRequest */ +class SOAP_CMAC _wcxs__GetWirelessCapabilitiesRequest +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 539; } /* = unique id SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__GetWirelessCapabilitiesRequest() : soap(NULL) { } + virtual ~_wcxs__GetWirelessCapabilitiesRequest() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse +#define SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse (540) +/* wcxs:GetWirelessCapabilitiesResponse */ +class SOAP_CMAC _wcxs__GetWirelessCapabilitiesResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + wcxs__WirelessCapabilitiesType *WirelessCapabilities; /* required element of type wcxs:WirelessCapabilitiesType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 540; } /* = unique id SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__GetWirelessCapabilitiesResponse() : WirelessCapabilities(NULL), soap(NULL) { } + virtual ~_wcxs__GetWirelessCapabilitiesResponse() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__GetWirelessSettingsRequest +#define SOAP_TYPE__wcxs__GetWirelessSettingsRequest (541) +/* wcxs:GetWirelessSettingsRequest */ +class SOAP_CMAC _wcxs__GetWirelessSettingsRequest +{ +public: + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 541; } /* = unique id SOAP_TYPE__wcxs__GetWirelessSettingsRequest */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__GetWirelessSettingsRequest() : soap(NULL) { } + virtual ~_wcxs__GetWirelessSettingsRequest() { } +}; +#endif + +#ifndef SOAP_TYPE__wcxs__GetWirelessSettingsResponse +#define SOAP_TYPE__wcxs__GetWirelessSettingsResponse (542) +/* wcxs:GetWirelessSettingsResponse */ +class SOAP_CMAC _wcxs__GetWirelessSettingsResponse +{ +public: + unsigned int Status; /* RPC return element */ /* required element of type cmn:PT_STATUS */ + wcxs__WirelessSettingsType *WirelessSettings; /* required element of type wcxs:WirelessSettingsType */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 542; } /* = unique id SOAP_TYPE__wcxs__GetWirelessSettingsResponse */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + _wcxs__GetWirelessSettingsResponse() : WirelessSettings(NULL), soap(NULL) { } + virtual ~_wcxs__GetWirelessSettingsResponse() { } +}; +#endif + +#ifndef SOAP_TYPE_cmn__URLType +#define SOAP_TYPE_cmn__URLType (15) +/* Primitive cmn:URLType schema type: */ +class SOAP_CMAC cmn__URLType +{ +public: + std::string __item; + char *__anyAttribute; /* optional attribute */ + struct soap *soap; /* transient */ +public: + virtual int soap_type() const { return 15; } /* = unique id SOAP_TYPE_cmn__URLType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cmn__URLType() : __anyAttribute(NULL), soap(NULL) { } + virtual ~cmn__URLType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerDefaultFilterType +#define SOAP_TYPE_cb__CircuitBreakerDefaultFilterType (365) +/* cb:CircuitBreakerDefaultFilterType */ +class SOAP_CMAC cb__CircuitBreakerDefaultFilterType : public cb__CircuitBreakerAntiSpoofingFilterType +{ +public: + bool ActionDrop; /* required element of type xsd:boolean */ +public: + virtual int soap_type() const { return 365; } /* = unique id SOAP_TYPE_cb__CircuitBreakerDefaultFilterType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerDefaultFilterType() { } + virtual ~cb__CircuitBreakerDefaultFilterType() { } +}; +#endif + +#ifndef SOAP_TYPE_cb__CircuitBreakerPacketTCPType +#define SOAP_TYPE_cb__CircuitBreakerPacketTCPType (378) +/* cb:CircuitBreakerPacketTCPType */ +class SOAP_CMAC cb__CircuitBreakerPacketTCPType : public cb__CircuitBreakerPacketUDPType +{ +public: + cb__CircuitBreakerIPLayeredTCPFlagsType *TCPFlags; /* optional element of type cb:CircuitBreakerIPLayeredTCPFlagsType */ +public: + virtual int soap_type() const { return 378; } /* = unique id SOAP_TYPE_cb__CircuitBreakerPacketTCPType */ + virtual void soap_default(struct soap*); + virtual void soap_serialize(struct soap*) const; + virtual int soap_put(struct soap*, const char*, const char*) const; + virtual int soap_out(struct soap*, const char*, int, const char*) const; + virtual void *soap_get(struct soap*, const char*, const char*); + virtual void *soap_in(struct soap*, const char*, const char*); + cb__CircuitBreakerPacketTCPType() : TCPFlags(NULL) { } + virtual ~cb__CircuitBreakerPacketTCPType() { } +}; +#endif + +#ifndef SOAP_TYPE___apl__AgentWatchdogShutdown +#define SOAP_TYPE___apl__AgentWatchdogShutdown (869) +/* Operation wrapper: */ +struct __apl__AgentWatchdogShutdown +{ +public: + _apl__AgentWatchdogShutdown *apl__AgentWatchdogShutdown; /* optional element of type apl:AgentWatchdogShutdown */ +}; +#endif + +#ifndef SOAP_TYPE___apl__AgentWatchdogHeartbeat +#define SOAP_TYPE___apl__AgentWatchdogHeartbeat (873) +/* Operation wrapper: */ +struct __apl__AgentWatchdogHeartbeat +{ +public: + _apl__AgentWatchdogHeartbeat *apl__AgentWatchdogHeartbeat; /* optional element of type apl:AgentWatchdogHeartbeat */ +}; +#endif + +#ifndef SOAP_TYPE___apl__AgentWatchdogRegister +#define SOAP_TYPE___apl__AgentWatchdogRegister (877) +/* Operation wrapper: */ +struct __apl__AgentWatchdogRegister +{ +public: + _apl__AgentWatchdogRegister *apl__AgentWatchdogRegister; /* optional element of type apl:AgentWatchdogRegister */ +}; +#endif + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogCreate +#define SOAP_TYPE___apr__ConsoleWatchdogCreate (881) +/* Operation wrapper: */ +struct __apr__ConsoleWatchdogCreate +{ +public: + _apr__ConsoleWatchdogCreate *apr__ConsoleWatchdogCreate; /* optional element of type apr:ConsoleWatchdogCreate */ +}; +#endif + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogDelete +#define SOAP_TYPE___apr__ConsoleWatchdogDelete (885) +/* Operation wrapper: */ +struct __apr__ConsoleWatchdogDelete +{ +public: + _apr__ConsoleWatchdogDelete *apr__ConsoleWatchdogDelete; /* optional element of type apr:ConsoleWatchdogDelete */ +}; +#endif + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogEnumerate +#define SOAP_TYPE___apr__ConsoleWatchdogEnumerate (889) +/* Operation wrapper: */ +struct __apr__ConsoleWatchdogEnumerate +{ +public: + _apr__ConsoleWatchdogEnumerate *apr__ConsoleWatchdogEnumerate; /* optional element of type apr:ConsoleWatchdogEnumerate */ +}; +#endif + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogSetActions +#define SOAP_TYPE___apr__ConsoleWatchdogSetActions (893) +/* Operation wrapper: */ +struct __apr__ConsoleWatchdogSetActions +{ +public: + _apr__ConsoleWatchdogSetActions *apr__ConsoleWatchdogSetActions; /* optional element of type apr:ConsoleWatchdogSetActions */ +}; +#endif + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogGetActions +#define SOAP_TYPE___apr__ConsoleWatchdogGetActions (897) +/* Operation wrapper: */ +struct __apr__ConsoleWatchdogGetActions +{ +public: + _apr__ConsoleWatchdogGetActions *apr__ConsoleWatchdogGetActions; /* optional element of type apr:ConsoleWatchdogGetActions */ +}; +#endif + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogSetCbPolicy +#define SOAP_TYPE___apr__ConsoleWatchdogSetCbPolicy (901) +/* Operation wrapper: */ +struct __apr__ConsoleWatchdogSetCbPolicy +{ +public: + _apr__ConsoleWatchdogSetCbPolicy *apr__ConsoleWatchdogSetCbPolicy; /* optional element of type apr:ConsoleWatchdogSetCbPolicy */ +}; +#endif + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogGetCbPolicy +#define SOAP_TYPE___apr__ConsoleWatchdogGetCbPolicy (905) +/* Operation wrapper: */ +struct __apr__ConsoleWatchdogGetCbPolicy +{ +public: + _apr__ConsoleWatchdogGetCbPolicy *apr__ConsoleWatchdogGetCbPolicy; /* optional element of type apr:ConsoleWatchdogGetCbPolicy */ +}; +#endif + +#ifndef SOAP_TYPE___apr__ConsoleWatchdogQueryCapabilities +#define SOAP_TYPE___apr__ConsoleWatchdogQueryCapabilities (909) +/* Operation wrapper: */ +struct __apr__ConsoleWatchdogQueryCapabilities +{ +public: + _apr__ConsoleWatchdogQueryCapabilities *apr__ConsoleWatchdogQueryCapabilities; /* optional element of type apr:ConsoleWatchdogQueryCapabilities */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbPolicyCreate +#define SOAP_TYPE___cb__CbPolicyCreate (913) +/* Operation wrapper: */ +struct __cb__CbPolicyCreate +{ +public: + _cb__CbPolicyCreate *cb__CbPolicyCreate; /* optional element of type cb:CbPolicyCreate */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbPolicyGet +#define SOAP_TYPE___cb__CbPolicyGet (917) +/* Operation wrapper: */ +struct __cb__CbPolicyGet +{ +public: + _cb__CbPolicyGet *cb__CbPolicyGet; /* optional element of type cb:CbPolicyGet */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbPolicyDelete +#define SOAP_TYPE___cb__CbPolicyDelete (921) +/* Operation wrapper: */ +struct __cb__CbPolicyDelete +{ +public: + _cb__CbPolicyDelete *cb__CbPolicyDelete; /* optional element of type cb:CbPolicyDelete */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbPolicyEnumerate +#define SOAP_TYPE___cb__CbPolicyEnumerate (925) +/* Operation wrapper: */ +struct __cb__CbPolicyEnumerate +{ +public: + _cb__CbPolicyEnumerate *cb__CbPolicyEnumerate; /* optional element of type cb:CbPolicyEnumerate */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbPolicyEnable +#define SOAP_TYPE___cb__CbPolicyEnable (929) +/* Operation wrapper: */ +struct __cb__CbPolicyEnable +{ +public: + _cb__CbPolicyEnable *cb__CbPolicyEnable; /* optional element of type cb:CbPolicyEnable */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbPolicyDisable +#define SOAP_TYPE___cb__CbPolicyDisable (933) +/* Operation wrapper: */ +struct __cb__CbPolicyDisable +{ +public: + _cb__CbPolicyDisable *cb__CbPolicyDisable; /* optional element of type cb:CbPolicyDisable */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbPolicyGetEnabled +#define SOAP_TYPE___cb__CbPolicyGetEnabled (937) +/* Operation wrapper: */ +struct __cb__CbPolicyGetEnabled +{ +public: + _cb__CbPolicyGetEnabled *cb__CbPolicyGetEnabled; /* optional element of type cb:CbPolicyGetEnabled */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbPolicyGetActiveStatistics +#define SOAP_TYPE___cb__CbPolicyGetActiveStatistics (941) +/* Operation wrapper: */ +struct __cb__CbPolicyGetActiveStatistics +{ +public: + _cb__CbPolicyGetActiveStatistics *cb__CbPolicyGetActiveStatistics; /* optional element of type cb:CbPolicyGetActiveStatistics */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbFilterCreate +#define SOAP_TYPE___cb__CbFilterCreate (945) +/* Operation wrapper: */ +struct __cb__CbFilterCreate +{ +public: + _cb__CbFilterCreate *cb__CbFilterCreate; /* optional element of type cb:CbFilterCreate */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbFilterGet +#define SOAP_TYPE___cb__CbFilterGet (949) +/* Operation wrapper: */ +struct __cb__CbFilterGet +{ +public: + _cb__CbFilterGet *cb__CbFilterGet; /* optional element of type cb:CbFilterGet */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbFilterDelete +#define SOAP_TYPE___cb__CbFilterDelete (953) +/* Operation wrapper: */ +struct __cb__CbFilterDelete +{ +public: + _cb__CbFilterDelete *cb__CbFilterDelete; /* optional element of type cb:CbFilterDelete */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbFilterEnumerate +#define SOAP_TYPE___cb__CbFilterEnumerate (957) +/* Operation wrapper: */ +struct __cb__CbFilterEnumerate +{ +public: + _cb__CbFilterEnumerate *cb__CbFilterEnumerate; /* optional element of type cb:CbFilterEnumerate */ +}; +#endif + +#ifndef SOAP_TYPE___cb__CbQueryCapabilities +#define SOAP_TYPE___cb__CbQueryCapabilities (961) +/* Operation wrapper: */ +struct __cb__CbQueryCapabilities +{ +public: + _cb__CbQueryCapabilities *cb__CbQueryCapabilities; /* optional element of type cb:CbQueryCapabilities */ +}; +#endif + +#ifndef SOAP_TYPE___cb__SetHcbOptions +#define SOAP_TYPE___cb__SetHcbOptions (965) +/* Operation wrapper: */ +struct __cb__SetHcbOptions +{ +public: + _cb__SetHcbOptions *cb__SetHcbOptions; /* optional element of type cb:SetHcbOptions */ +}; +#endif + +#ifndef SOAP_TYPE___cb__GetHcbOptions +#define SOAP_TYPE___cb__GetHcbOptions (969) +/* Operation wrapper: */ +struct __cb__GetHcbOptions +{ +public: + _cb__GetHcbOptions *cb__GetHcbOptions; /* optional element of type cb:GetHcbOptions */ +}; +#endif + +#ifndef SOAP_TYPE___cb__ClearHcbState +#define SOAP_TYPE___cb__ClearHcbState (973) +/* Operation wrapper: */ +struct __cb__ClearHcbState +{ +public: + _cb__ClearHcbState *cb__ClearHcbState; /* optional element of type cb:ClearHcbState */ +}; +#endif + +#ifndef SOAP_TYPE___cb__GetHcbState +#define SOAP_TYPE___cb__GetHcbState (977) +/* Operation wrapper: */ +struct __cb__GetHcbState +{ +public: + _cb__GetHcbState *cb__GetHcbState; /* optional element of type cb:GetHcbState */ +}; +#endif + +#ifndef SOAP_TYPE___emi__EnumerateEventFilters +#define SOAP_TYPE___emi__EnumerateEventFilters (981) +/* Operation wrapper: */ +struct __emi__EnumerateEventFilters +{ +public: + _emi__EnumerateEventFilters *emi__EnumerateEventFilters; /* optional element of type emi:EnumerateEventFilters */ +}; +#endif + +#ifndef SOAP_TYPE___emi__GetAlertSubscription +#define SOAP_TYPE___emi__GetAlertSubscription (985) +/* Operation wrapper: */ +struct __emi__GetAlertSubscription +{ +public: + _emi__GetAlertSubscription *emi__GetAlertSubscription; /* optional element of type emi:GetAlertSubscription */ +}; +#endif + +#ifndef SOAP_TYPE___emi__SetAlertCommunityString +#define SOAP_TYPE___emi__SetAlertCommunityString (989) +/* Operation wrapper: */ +struct __emi__SetAlertCommunityString +{ +public: + _emi__SetAlertCommunityString *emi__SetAlertCommunityString; /* optional element of type emi:SetAlertCommunityString */ +}; +#endif + +#ifndef SOAP_TYPE___emi__GetAlertCommunityString +#define SOAP_TYPE___emi__GetAlertCommunityString (993) +/* Operation wrapper: */ +struct __emi__GetAlertCommunityString +{ +public: + _emi__GetAlertCommunityString *emi__GetAlertCommunityString; /* optional element of type emi:GetAlertCommunityString */ +}; +#endif + +#ifndef SOAP_TYPE___emi__AddEventFilter +#define SOAP_TYPE___emi__AddEventFilter (997) +/* Operation wrapper: */ +struct __emi__AddEventFilter +{ +public: + _emi__AddEventFilter *emi__AddEventFilter; /* optional element of type emi:AddEventFilter */ +}; +#endif + +#ifndef SOAP_TYPE___emi__SubscribeForAlert +#define SOAP_TYPE___emi__SubscribeForAlert (1001) +/* Operation wrapper: */ +struct __emi__SubscribeForAlert +{ +public: + _emi__SubscribeForAlert *emi__SubscribeForAlert; /* optional element of type emi:SubscribeForAlert */ +}; +#endif + +#ifndef SOAP_TYPE___emi__EnumerateAlertSubscriptions +#define SOAP_TYPE___emi__EnumerateAlertSubscriptions (1005) +/* Operation wrapper: */ +struct __emi__EnumerateAlertSubscriptions +{ +public: + _emi__EnumerateAlertSubscriptions *emi__EnumerateAlertSubscriptions; /* optional element of type emi:EnumerateAlertSubscriptions */ +}; +#endif + +#ifndef SOAP_TYPE___emi__EnumerateAlertPolicies +#define SOAP_TYPE___emi__EnumerateAlertPolicies (1009) +/* Operation wrapper: */ +struct __emi__EnumerateAlertPolicies +{ +public: + _emi__EnumerateAlertPolicies *emi__EnumerateAlertPolicies; /* optional element of type emi:EnumerateAlertPolicies */ +}; +#endif + +#ifndef SOAP_TYPE___emi__CancelAlertSubscription +#define SOAP_TYPE___emi__CancelAlertSubscription (1013) +/* Operation wrapper: */ +struct __emi__CancelAlertSubscription +{ +public: + _emi__CancelAlertSubscription *emi__CancelAlertSubscription; /* optional element of type emi:CancelAlertSubscription */ +}; +#endif + +#ifndef SOAP_TYPE___emi__GetEventFilter +#define SOAP_TYPE___emi__GetEventFilter (1017) +/* Operation wrapper: */ +struct __emi__GetEventFilter +{ +public: + _emi__GetEventFilter *emi__GetEventFilter; /* optional element of type emi:GetEventFilter */ +}; +#endif + +#ifndef SOAP_TYPE___emi__UpdateEventFilter +#define SOAP_TYPE___emi__UpdateEventFilter (1021) +/* Operation wrapper: */ +struct __emi__UpdateEventFilter +{ +public: + _emi__UpdateEventFilter *emi__UpdateEventFilter; /* optional element of type emi:UpdateEventFilter */ +}; +#endif + +#ifndef SOAP_TYPE___emi__RemoveEventFilter +#define SOAP_TYPE___emi__RemoveEventFilter (1025) +/* Operation wrapper: */ +struct __emi__RemoveEventFilter +{ +public: + _emi__RemoveEventFilter *emi__RemoveEventFilter; /* optional element of type emi:RemoveEventFilter */ +}; +#endif + +#ifndef SOAP_TYPE___emi__GetEventLogStatus +#define SOAP_TYPE___emi__GetEventLogStatus (1029) +/* Operation wrapper: */ +struct __emi__GetEventLogStatus +{ +public: + _emi__GetEventLogStatus *emi__GetEventLogStatus; /* optional element of type emi:GetEventLogStatus */ +}; +#endif + +#ifndef SOAP_TYPE___emi__ReadEventLogRecords +#define SOAP_TYPE___emi__ReadEventLogRecords (1033) +/* Operation wrapper: */ +struct __emi__ReadEventLogRecords +{ +public: + _emi__ReadEventLogRecords *emi__ReadEventLogRecords; /* optional element of type emi:ReadEventLogRecords */ +}; +#endif + +#ifndef SOAP_TYPE___emi__ClearEventLog +#define SOAP_TYPE___emi__ClearEventLog (1037) +/* Operation wrapper: */ +struct __emi__ClearEventLog +{ +public: + _emi__ClearEventLog *emi__ClearEventLog; /* optional element of type emi:ClearEventLog */ +}; +#endif + +#ifndef SOAP_TYPE___emi__FreezeEventLog +#define SOAP_TYPE___emi__FreezeEventLog (1041) +/* Operation wrapper: */ +struct __emi__FreezeEventLog +{ +public: + _emi__FreezeEventLog *emi__FreezeEventLog; /* optional element of type emi:FreezeEventLog */ +}; +#endif + +#ifndef SOAP_TYPE___emi__SetEventLogTimestampClock +#define SOAP_TYPE___emi__SetEventLogTimestampClock (1045) +/* Operation wrapper: */ +struct __emi__SetEventLogTimestampClock +{ +public: + _emi__SetEventLogTimestampClock *emi__SetEventLogTimestampClock; /* optional element of type emi:SetEventLogTimestampClock */ +}; +#endif + +#ifndef SOAP_TYPE___emi__GetEventLogTimestampClock +#define SOAP_TYPE___emi__GetEventLogTimestampClock (1049) +/* Operation wrapper: */ +struct __emi__GetEventLogTimestampClock +{ +public: + _emi__GetEventLogTimestampClock *emi__GetEventLogTimestampClock; /* optional element of type emi:GetEventLogTimestampClock */ +}; +#endif + +#ifndef SOAP_TYPE___emi__EnumerateSensors +#define SOAP_TYPE___emi__EnumerateSensors (1053) +/* Operation wrapper: */ +struct __emi__EnumerateSensors +{ +public: + _emi__EnumerateSensors *emi__EnumerateSensors; /* optional element of type emi:EnumerateSensors */ +}; +#endif + +#ifndef SOAP_TYPE___emi__GetSensorAttributes +#define SOAP_TYPE___emi__GetSensorAttributes (1057) +/* Operation wrapper: */ +struct __emi__GetSensorAttributes +{ +public: + _emi__GetSensorAttributes *emi__GetSensorAttributes; /* optional element of type emi:GetSensorAttributes */ +}; +#endif + +#ifndef SOAP_TYPE___emi__SubscribeForGeneralAlert +#define SOAP_TYPE___emi__SubscribeForGeneralAlert (1061) +/* Operation wrapper: */ +struct __emi__SubscribeForGeneralAlert +{ +public: + _emi__SubscribeForGeneralAlert *emi__SubscribeForGeneralAlert; /* optional element of type emi:SubscribeForGeneralAlert */ +}; +#endif + +#ifndef SOAP_TYPE___emi__EnumerateGeneralAlertSubscriptions +#define SOAP_TYPE___emi__EnumerateGeneralAlertSubscriptions (1065) +/* Operation wrapper: */ +struct __emi__EnumerateGeneralAlertSubscriptions +{ +public: + _emi__EnumerateGeneralAlertSubscriptions *emi__EnumerateGeneralAlertSubscriptions; /* optional element of type emi:EnumerateGeneralAlertSubscriptions */ +}; +#endif + +#ifndef SOAP_TYPE___emi__GetGeneralAlertSubscription +#define SOAP_TYPE___emi__GetGeneralAlertSubscription (1069) +/* Operation wrapper: */ +struct __emi__GetGeneralAlertSubscription +{ +public: + _emi__GetGeneralAlertSubscription *emi__GetGeneralAlertSubscription; /* optional element of type emi:GetGeneralAlertSubscription */ +}; +#endif + +#ifndef SOAP_TYPE___hwa__EnumerateAssetTypes +#define SOAP_TYPE___hwa__EnumerateAssetTypes (1073) +/* Operation wrapper: */ +struct __hwa__EnumerateAssetTypes +{ +public: + _hwa__EnumerateAssetTypes *hwa__EnumerateAssetTypes; /* optional element of type hwa:EnumerateAssetTypes */ +}; +#endif + +#ifndef SOAP_TYPE___hwa__GetAssetData +#define SOAP_TYPE___hwa__GetAssetData (1077) +/* Operation wrapper: */ +struct __hwa__GetAssetData +{ +public: + _hwa__GetAssetData *hwa__GetAssetData; /* optional element of type hwa:GetAssetData */ +}; +#endif + +#ifndef SOAP_TYPE___idr__SetRedirectionListenerState +#define SOAP_TYPE___idr__SetRedirectionListenerState (1081) +/* Operation wrapper: */ +struct __idr__SetRedirectionListenerState +{ +public: + _idr__SetRedirectionListenerState *idr__SetRedirectionListenerState; /* optional element of type idr:SetRedirectionListenerState */ +}; +#endif + +#ifndef SOAP_TYPE___idr__GetRedirectionListenerState +#define SOAP_TYPE___idr__GetRedirectionListenerState (1085) +/* Operation wrapper: */ +struct __idr__GetRedirectionListenerState +{ +public: + _idr__GetRedirectionListenerState *idr__GetRedirectionListenerState; /* optional element of type idr:GetRedirectionListenerState */ +}; +#endif + +#ifndef SOAP_TYPE___idr__GetIderSessionLog +#define SOAP_TYPE___idr__GetIderSessionLog (1089) +/* Operation wrapper: */ +struct __idr__GetIderSessionLog +{ +public: + _idr__GetIderSessionLog *idr__GetIderSessionLog; /* optional element of type idr:GetIderSessionLog */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetCoreVersion +#define SOAP_TYPE___inf__GetCoreVersion (1093) +/* Operation wrapper: */ +struct __inf__GetCoreVersion +{ +public: + _inf__GetCoreVersion *inf__GetCoreVersion; /* optional element of type inf:GetCoreVersion */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetCodeVersions +#define SOAP_TYPE___inf__GetCodeVersions (1097) +/* Operation wrapper: */ +struct __inf__GetCodeVersions +{ +public: + _inf__GetCodeVersions *inf__GetCodeVersions; /* optional element of type inf:GetCodeVersions */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetProvisioningMode +#define SOAP_TYPE___inf__GetProvisioningMode (1101) +/* Operation wrapper: */ +struct __inf__GetProvisioningMode +{ +public: + _inf__GetProvisioningMode *inf__GetProvisioningMode; /* optional element of type inf:GetProvisioningMode */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetProvisioningState +#define SOAP_TYPE___inf__GetProvisioningState (1105) +/* Operation wrapper: */ +struct __inf__GetProvisioningState +{ +public: + _inf__GetProvisioningState *inf__GetProvisioningState; /* optional element of type inf:GetProvisioningState */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetVlanParameters +#define SOAP_TYPE___inf__GetVlanParameters (1109) +/* Operation wrapper: */ +struct __inf__GetVlanParameters +{ +public: + _inf__GetVlanParameters *inf__GetVlanParameters; /* optional element of type inf:GetVlanParameters */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetHostName +#define SOAP_TYPE___inf__GetHostName (1113) +/* Operation wrapper: */ +struct __inf__GetHostName +{ +public: + _inf__GetHostName *inf__GetHostName; /* optional element of type inf:GetHostName */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetConfigServerInfo +#define SOAP_TYPE___inf__GetConfigServerInfo (1117) +/* Operation wrapper: */ +struct __inf__GetConfigServerInfo +{ +public: + _inf__GetConfigServerInfo *inf__GetConfigServerInfo; /* optional element of type inf:GetConfigServerInfo */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetAdminAclEntryStatus +#define SOAP_TYPE___inf__GetAdminAclEntryStatus (1121) +/* Operation wrapper: */ +struct __inf__GetAdminAclEntryStatus +{ +public: + _inf__GetAdminAclEntryStatus *inf__GetAdminAclEntryStatus; /* optional element of type inf:GetAdminAclEntryStatus */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetAdminNetAclEntryStatus +#define SOAP_TYPE___inf__GetAdminNetAclEntryStatus (1125) +/* Operation wrapper: */ +struct __inf__GetAdminNetAclEntryStatus +{ +public: + _inf__GetAdminNetAclEntryStatus *inf__GetAdminNetAclEntryStatus; /* optional element of type inf:GetAdminNetAclEntryStatus */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetPasswordModel +#define SOAP_TYPE___inf__GetPasswordModel (1129) +/* Operation wrapper: */ +struct __inf__GetPasswordModel +{ +public: + _inf__GetPasswordModel *inf__GetPasswordModel; /* optional element of type inf:GetPasswordModel */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetEnabledInterfaces +#define SOAP_TYPE___inf__GetEnabledInterfaces (1133) +/* Operation wrapper: */ +struct __inf__GetEnabledInterfaces +{ +public: + _inf__GetEnabledInterfaces *inf__GetEnabledInterfaces; /* optional element of type inf:GetEnabledInterfaces */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetNetworkState +#define SOAP_TYPE___inf__GetNetworkState (1137) +/* Operation wrapper: */ +struct __inf__GetNetworkState +{ +public: + _inf__GetNetworkState *inf__GetNetworkState; /* optional element of type inf:GetNetworkState */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetSecurityParameters +#define SOAP_TYPE___inf__GetSecurityParameters (1141) +/* Operation wrapper: */ +struct __inf__GetSecurityParameters +{ +public: + _inf__GetSecurityParameters *inf__GetSecurityParameters; /* optional element of type inf:GetSecurityParameters */ +}; +#endif + +#ifndef SOAP_TYPE___inf__GetIderSessionLog +#define SOAP_TYPE___inf__GetIderSessionLog (1145) +/* Operation wrapper: */ +struct __inf__GetIderSessionLog +{ +public: + _inf__GetIderSessionLog *inf__GetIderSessionLog; /* optional element of type inf:GetIderSessionLog */ +}; +#endif + +#ifndef SOAP_TYPE___net__SetHostName +#define SOAP_TYPE___net__SetHostName (1149) +/* Operation wrapper: */ +struct __net__SetHostName +{ +public: + _net__SetHostName *net__SetHostName; /* optional element of type net:SetHostName */ +}; +#endif + +#ifndef SOAP_TYPE___net__GetHostName +#define SOAP_TYPE___net__GetHostName (1153) +/* Operation wrapper: */ +struct __net__GetHostName +{ +public: + _net__GetHostName *net__GetHostName; /* optional element of type net:GetHostName */ +}; +#endif + +#ifndef SOAP_TYPE___net__SetDomainName +#define SOAP_TYPE___net__SetDomainName (1157) +/* Operation wrapper: */ +struct __net__SetDomainName +{ +public: + _net__SetDomainName *net__SetDomainName; /* optional element of type net:SetDomainName */ +}; +#endif + +#ifndef SOAP_TYPE___net__GetDomainName +#define SOAP_TYPE___net__GetDomainName (1161) +/* Operation wrapper: */ +struct __net__GetDomainName +{ +public: + _net__GetDomainName *net__GetDomainName; /* optional element of type net:GetDomainName */ +}; +#endif + +#ifndef SOAP_TYPE___net__SetTcpIpParameters +#define SOAP_TYPE___net__SetTcpIpParameters (1165) +/* Operation wrapper: */ +struct __net__SetTcpIpParameters +{ +public: + _net__SetTcpIpParameters *net__SetTcpIpParameters; /* optional element of type net:SetTcpIpParameters */ +}; +#endif + +#ifndef SOAP_TYPE___net__GetTcpIpParameters +#define SOAP_TYPE___net__GetTcpIpParameters (1169) +/* Operation wrapper: */ +struct __net__GetTcpIpParameters +{ +public: + _net__GetTcpIpParameters *net__GetTcpIpParameters; /* optional element of type net:GetTcpIpParameters */ +}; +#endif + +#ifndef SOAP_TYPE___net__SetVlanParameters +#define SOAP_TYPE___net__SetVlanParameters (1173) +/* Operation wrapper: */ +struct __net__SetVlanParameters +{ +public: + _net__SetVlanParameters *net__SetVlanParameters; /* optional element of type net:SetVlanParameters */ +}; +#endif + +#ifndef SOAP_TYPE___net__GetVlanParameters +#define SOAP_TYPE___net__GetVlanParameters (1177) +/* Operation wrapper: */ +struct __net__GetVlanParameters +{ +public: + _net__GetVlanParameters *net__GetVlanParameters; /* optional element of type net:GetVlanParameters */ +}; +#endif + +#ifndef SOAP_TYPE___net__SetPingResponse +#define SOAP_TYPE___net__SetPingResponse (1181) +/* Operation wrapper: */ +struct __net__SetPingResponse +{ +public: + _net__SetPingResponse *net__SetPingResponse; /* optional element of type net:SetPingResponse */ +}; +#endif + +#ifndef SOAP_TYPE___net__GetPingResponse +#define SOAP_TYPE___net__GetPingResponse (1185) +/* Operation wrapper: */ +struct __net__GetPingResponse +{ +public: + _net__GetPingResponse *net__GetPingResponse; /* optional element of type net:GetPingResponse */ +}; +#endif + +#ifndef SOAP_TYPE___net__EnumerateInterfaces +#define SOAP_TYPE___net__EnumerateInterfaces (1189) +/* Operation wrapper: */ +struct __net__EnumerateInterfaces +{ +public: + _net__EnumerateInterfaces *net__EnumerateInterfaces; /* optional element of type net:EnumerateInterfaces */ +}; +#endif + +#ifndef SOAP_TYPE___net__GetInterfaceSettings +#define SOAP_TYPE___net__GetInterfaceSettings (1193) +/* Operation wrapper: */ +struct __net__GetInterfaceSettings +{ +public: + _net__GetInterfaceSettings *net__GetInterfaceSettings; /* optional element of type net:GetInterfaceSettings */ +}; +#endif + +#ifndef SOAP_TYPE___net__SetInterfaceSettings +#define SOAP_TYPE___net__SetInterfaceSettings (1197) +/* Operation wrapper: */ +struct __net__SetInterfaceSettings +{ +public: + _net__SetInterfaceSettings *net__SetInterfaceSettings; /* optional element of type net:SetInterfaceSettings */ +}; +#endif + +#ifndef SOAP_TYPE___net__Set8021XWiredProfile +#define SOAP_TYPE___net__Set8021XWiredProfile (1201) +/* Operation wrapper: */ +struct __net__Set8021XWiredProfile +{ +public: + _net__Set8021XWiredProfile *net__Set8021XWiredProfile; /* optional element of type net:Set8021XWiredProfile */ +}; +#endif + +#ifndef SOAP_TYPE___net__Get8021XWiredProfile +#define SOAP_TYPE___net__Get8021XWiredProfile (1205) +/* Operation wrapper: */ +struct __net__Get8021XWiredProfile +{ +public: + _net__Get8021XWiredProfile *net__Get8021XWiredProfile; /* optional element of type net:Get8021XWiredProfile */ +}; +#endif + +#ifndef SOAP_TYPE___net__Set8021XActiveS0 +#define SOAP_TYPE___net__Set8021XActiveS0 (1209) +/* Operation wrapper: */ +struct __net__Set8021XActiveS0 +{ +public: + _net__Set8021XActiveS0 *net__Set8021XActiveS0; /* optional element of type net:Set8021XActiveS0 */ +}; +#endif + +#ifndef SOAP_TYPE___net__Get8021XActiveS0 +#define SOAP_TYPE___net__Get8021XActiveS0 (1213) +/* Operation wrapper: */ +struct __net__Get8021XActiveS0 +{ +public: + _net__Get8021XActiveS0 *net__Get8021XActiveS0; /* optional element of type net:Get8021XActiveS0 */ +}; +#endif + +#ifndef SOAP_TYPE___net__Set8021XPxeTimeout +#define SOAP_TYPE___net__Set8021XPxeTimeout (1217) +/* Operation wrapper: */ +struct __net__Set8021XPxeTimeout +{ +public: + _net__Set8021XPxeTimeout *net__Set8021XPxeTimeout; /* optional element of type net:Set8021XPxeTimeout */ +}; +#endif + +#ifndef SOAP_TYPE___net__Get8021XPxeTimeout +#define SOAP_TYPE___net__Get8021XPxeTimeout (1221) +/* Operation wrapper: */ +struct __net__Get8021XPxeTimeout +{ +public: + _net__Get8021XPxeTimeout *net__Get8021XPxeTimeout; /* optional element of type net:Get8021XPxeTimeout */ +}; +#endif + +#ifndef SOAP_TYPE___rci__GetRemoteControlCapabilities +#define SOAP_TYPE___rci__GetRemoteControlCapabilities (1225) +/* Operation wrapper: */ +struct __rci__GetRemoteControlCapabilities +{ +public: + _rci__GetRemoteControlCapabilities *rci__GetRemoteControlCapabilities; /* optional element of type rci:GetRemoteControlCapabilities */ +}; +#endif + +#ifndef SOAP_TYPE___rci__RemoteControl +#define SOAP_TYPE___rci__RemoteControl (1229) +/* Operation wrapper: */ +struct __rci__RemoteControl +{ +public: + _rci__RemoteControl *rci__RemoteControl; /* optional element of type rci:RemoteControl */ +}; +#endif + +#ifndef SOAP_TYPE___rci__GetSystemPowerState +#define SOAP_TYPE___rci__GetSystemPowerState (1233) +/* Operation wrapper: */ +struct __rci__GetSystemPowerState +{ +public: + _rci__GetSystemPowerState *rci__GetSystemPowerState; /* optional element of type rci:GetSystemPowerState */ +}; +#endif + +#ifndef SOAP_TYPE___sai__ResetFlashWearOutProtection +#define SOAP_TYPE___sai__ResetFlashWearOutProtection (1237) +/* Operation wrapper: */ +struct __sai__ResetFlashWearOutProtection +{ +public: + _sai__ResetFlashWearOutProtection *sai__ResetFlashWearOutProtection; /* optional element of type sai:ResetFlashWearOutProtection */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetAdminAclEntry +#define SOAP_TYPE___sai__GetAdminAclEntry (1241) +/* Operation wrapper: */ +struct __sai__GetAdminAclEntry +{ +public: + _sai__GetAdminAclEntry *sai__GetAdminAclEntry; /* optional element of type sai:GetAdminAclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetAdminAclEntry +#define SOAP_TYPE___sai__SetAdminAclEntry (1245) +/* Operation wrapper: */ +struct __sai__SetAdminAclEntry +{ +public: + _sai__SetAdminAclEntry *sai__SetAdminAclEntry; /* optional element of type sai:SetAdminAclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__AddUserAclEntry +#define SOAP_TYPE___sai__AddUserAclEntry (1249) +/* Operation wrapper: */ +struct __sai__AddUserAclEntry +{ +public: + _sai__AddUserAclEntry *sai__AddUserAclEntry; /* optional element of type sai:AddUserAclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__EnumerateUserAclEntries +#define SOAP_TYPE___sai__EnumerateUserAclEntries (1253) +/* Operation wrapper: */ +struct __sai__EnumerateUserAclEntries +{ +public: + _sai__EnumerateUserAclEntries *sai__EnumerateUserAclEntries; /* optional element of type sai:EnumerateUserAclEntries */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetUserAclEntry +#define SOAP_TYPE___sai__GetUserAclEntry (1257) +/* Operation wrapper: */ +struct __sai__GetUserAclEntry +{ +public: + _sai__GetUserAclEntry *sai__GetUserAclEntry; /* optional element of type sai:GetUserAclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__UpdateUserAclEntry +#define SOAP_TYPE___sai__UpdateUserAclEntry (1261) +/* Operation wrapper: */ +struct __sai__UpdateUserAclEntry +{ +public: + _sai__UpdateUserAclEntry *sai__UpdateUserAclEntry; /* optional element of type sai:UpdateUserAclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__RemoveUserAclEntry +#define SOAP_TYPE___sai__RemoveUserAclEntry (1265) +/* Operation wrapper: */ +struct __sai__RemoveUserAclEntry +{ +public: + _sai__RemoveUserAclEntry *sai__RemoveUserAclEntry; /* optional element of type sai:RemoveUserAclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetTlsEnabled +#define SOAP_TYPE___sai__SetTlsEnabled (1269) +/* Operation wrapper: */ +struct __sai__SetTlsEnabled +{ +public: + _sai__SetTlsEnabled *sai__SetTlsEnabled; /* optional element of type sai:SetTlsEnabled */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetRngKey +#define SOAP_TYPE___sai__SetRngKey (1273) +/* Operation wrapper: */ +struct __sai__SetRngKey +{ +public: + _sai__SetRngKey *sai__SetRngKey; /* optional element of type sai:SetRngKey */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetTLSKeyAndCertificate +#define SOAP_TYPE___sai__SetTLSKeyAndCertificate (1277) +/* Operation wrapper: */ +struct __sai__SetTLSKeyAndCertificate +{ +public: + _sai__SetTLSKeyAndCertificate *sai__SetTLSKeyAndCertificate; /* optional element of type sai:SetTLSKeyAndCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetTLSCertificate +#define SOAP_TYPE___sai__SetTLSCertificate (1281) +/* Operation wrapper: */ +struct __sai__SetTLSCertificate +{ +public: + _sai__SetTLSCertificate *sai__SetTLSCertificate; /* optional element of type sai:SetTLSCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetTLSCertificate +#define SOAP_TYPE___sai__GetTLSCertificate (1285) +/* Operation wrapper: */ +struct __sai__GetTLSCertificate +{ +public: + _sai__GetTLSCertificate *sai__GetTLSCertificate; /* optional element of type sai:GetTLSCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__UpdateCoreFromUrl +#define SOAP_TYPE___sai__UpdateCoreFromUrl (1289) +/* Operation wrapper: */ +struct __sai__UpdateCoreFromUrl +{ +public: + _sai__UpdateCoreFromUrl *sai__UpdateCoreFromUrl; /* optional element of type sai:UpdateCoreFromUrl */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetProvisioningMode +#define SOAP_TYPE___sai__GetProvisioningMode (1293) +/* Operation wrapper: */ +struct __sai__GetProvisioningMode +{ +public: + _sai__GetProvisioningMode *sai__GetProvisioningMode; /* optional element of type sai:GetProvisioningMode */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetProvisioningMode +#define SOAP_TYPE___sai__SetProvisioningMode (1297) +/* Operation wrapper: */ +struct __sai__SetProvisioningMode +{ +public: + _sai__SetProvisioningMode *sai__SetProvisioningMode; /* optional element of type sai:SetProvisioningMode */ +}; +#endif + +#ifndef SOAP_TYPE___sai__Unprovision +#define SOAP_TYPE___sai__Unprovision (1301) +/* Operation wrapper: */ +struct __sai__Unprovision +{ +public: + _sai__Unprovision *sai__Unprovision; /* optional element of type sai:Unprovision */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CommitChanges +#define SOAP_TYPE___sai__CommitChanges (1305) +/* Operation wrapper: */ +struct __sai__CommitChanges +{ +public: + _sai__CommitChanges *sai__CommitChanges; /* optional element of type sai:CommitChanges */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetCoreVersion +#define SOAP_TYPE___sai__GetCoreVersion (1309) +/* Operation wrapper: */ +struct __sai__GetCoreVersion +{ +public: + _sai__GetCoreVersion *sai__GetCoreVersion; /* optional element of type sai:GetCoreVersion */ +}; +#endif + +#ifndef SOAP_TYPE___sai__AddUserAclEntryEx +#define SOAP_TYPE___sai__AddUserAclEntryEx (1313) +/* Operation wrapper: */ +struct __sai__AddUserAclEntryEx +{ +public: + _sai__AddUserAclEntryEx *sai__AddUserAclEntryEx; /* optional element of type sai:AddUserAclEntryEx */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetUserAclEntryEx +#define SOAP_TYPE___sai__GetUserAclEntryEx (1317) +/* Operation wrapper: */ +struct __sai__GetUserAclEntryEx +{ +public: + _sai__GetUserAclEntryEx *sai__GetUserAclEntryEx; /* optional element of type sai:GetUserAclEntryEx */ +}; +#endif + +#ifndef SOAP_TYPE___sai__UpdateUserAclEntryEx +#define SOAP_TYPE___sai__UpdateUserAclEntryEx (1321) +/* Operation wrapper: */ +struct __sai__UpdateUserAclEntryEx +{ +public: + _sai__UpdateUserAclEntryEx *sai__UpdateUserAclEntryEx; /* optional element of type sai:UpdateUserAclEntryEx */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetAdminAclEntryEx +#define SOAP_TYPE___sai__SetAdminAclEntryEx (1325) +/* Operation wrapper: */ +struct __sai__SetAdminAclEntryEx +{ +public: + _sai__SetAdminAclEntryEx *sai__SetAdminAclEntryEx; /* optional element of type sai:SetAdminAclEntryEx */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetDigestRealm +#define SOAP_TYPE___sai__GetDigestRealm (1329) +/* Operation wrapper: */ +struct __sai__GetDigestRealm +{ +public: + _sai__GetDigestRealm *sai__GetDigestRealm; /* optional element of type sai:GetDigestRealm */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetKerberosOptions +#define SOAP_TYPE___sai__SetKerberosOptions (1333) +/* Operation wrapper: */ +struct __sai__SetKerberosOptions +{ +public: + _sai__SetKerberosOptions *sai__SetKerberosOptions; /* optional element of type sai:SetKerberosOptions */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetKerberosOptions +#define SOAP_TYPE___sai__GetKerberosOptions (1337) +/* Operation wrapper: */ +struct __sai__GetKerberosOptions +{ +public: + _sai__GetKerberosOptions *sai__GetKerberosOptions; /* optional element of type sai:GetKerberosOptions */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetEnabledInterfaces +#define SOAP_TYPE___sai__SetEnabledInterfaces (1341) +/* Operation wrapper: */ +struct __sai__SetEnabledInterfaces +{ +public: + _sai__SetEnabledInterfaces *sai__SetEnabledInterfaces; /* optional element of type sai:SetEnabledInterfaces */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetEnabledInterfaces +#define SOAP_TYPE___sai__GetEnabledInterfaces (1345) +/* Operation wrapper: */ +struct __sai__GetEnabledInterfaces +{ +public: + _sai__GetEnabledInterfaces *sai__GetEnabledInterfaces; /* optional element of type sai:GetEnabledInterfaces */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetTlsOptions +#define SOAP_TYPE___sai__SetTlsOptions (1349) +/* Operation wrapper: */ +struct __sai__SetTlsOptions +{ +public: + _sai__SetTlsOptions *sai__SetTlsOptions; /* optional element of type sai:SetTlsOptions */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetTlsOptions +#define SOAP_TYPE___sai__GetTlsOptions (1353) +/* Operation wrapper: */ +struct __sai__GetTlsOptions +{ +public: + _sai__GetTlsOptions *sai__GetTlsOptions; /* optional element of type sai:GetTlsOptions */ +}; +#endif + +#ifndef SOAP_TYPE___sai__AddTrustedRootCertificate +#define SOAP_TYPE___sai__AddTrustedRootCertificate (1357) +/* Operation wrapper: */ +struct __sai__AddTrustedRootCertificate +{ +public: + _sai__AddTrustedRootCertificate *sai__AddTrustedRootCertificate; /* optional element of type sai:AddTrustedRootCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetTrustedRootCertificate +#define SOAP_TYPE___sai__GetTrustedRootCertificate (1361) +/* Operation wrapper: */ +struct __sai__GetTrustedRootCertificate +{ +public: + _sai__GetTrustedRootCertificate *sai__GetTrustedRootCertificate; /* optional element of type sai:GetTrustedRootCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__DeleteTrustedRootCertificate +#define SOAP_TYPE___sai__DeleteTrustedRootCertificate (1365) +/* Operation wrapper: */ +struct __sai__DeleteTrustedRootCertificate +{ +public: + _sai__DeleteTrustedRootCertificate *sai__DeleteTrustedRootCertificate; /* optional element of type sai:DeleteTrustedRootCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__EnumerateTrustedRootCertificates +#define SOAP_TYPE___sai__EnumerateTrustedRootCertificates (1369) +/* Operation wrapper: */ +struct __sai__EnumerateTrustedRootCertificates +{ +public: + _sai__EnumerateTrustedRootCertificates *sai__EnumerateTrustedRootCertificates; /* optional element of type sai:EnumerateTrustedRootCertificates */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetTrustedFqdnCN +#define SOAP_TYPE___sai__SetTrustedFqdnCN (1373) +/* Operation wrapper: */ +struct __sai__SetTrustedFqdnCN +{ +public: + _sai__SetTrustedFqdnCN *sai__SetTrustedFqdnCN; /* optional element of type sai:SetTrustedFqdnCN */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetTrustedFqdnCN +#define SOAP_TYPE___sai__GetTrustedFqdnCN (1377) +/* Operation wrapper: */ +struct __sai__GetTrustedFqdnCN +{ +public: + _sai__GetTrustedFqdnCN *sai__GetTrustedFqdnCN; /* optional element of type sai:GetTrustedFqdnCN */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetCRL +#define SOAP_TYPE___sai__SetCRL (1381) +/* Operation wrapper: */ +struct __sai__SetCRL +{ +public: + _sai__SetCRL *sai__SetCRL; /* optional element of type sai:SetCRL */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetCRL +#define SOAP_TYPE___sai__GetCRL (1385) +/* Operation wrapper: */ +struct __sai__GetCRL +{ +public: + _sai__GetCRL *sai__GetCRL; /* optional element of type sai:GetCRL */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetServerCertificateReq +#define SOAP_TYPE___sai__GetServerCertificateReq (1389) +/* Operation wrapper: */ +struct __sai__GetServerCertificateReq +{ +public: + _sai__GetServerCertificateReq *sai__GetServerCertificateReq; /* optional element of type sai:GetServerCertificateReq */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetPkiCapabilities +#define SOAP_TYPE___sai__GetPkiCapabilities (1393) +/* Operation wrapper: */ +struct __sai__GetPkiCapabilities +{ +public: + _sai__GetPkiCapabilities *sai__GetPkiCapabilities; /* optional element of type sai:GetPkiCapabilities */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetPowerSavingOptions +#define SOAP_TYPE___sai__SetPowerSavingOptions (1397) +/* Operation wrapper: */ +struct __sai__SetPowerSavingOptions +{ +public: + _sai__SetPowerSavingOptions *sai__SetPowerSavingOptions; /* optional element of type sai:SetPowerSavingOptions */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetPowerSavingOptions +#define SOAP_TYPE___sai__GetPowerSavingOptions (1401) +/* Operation wrapper: */ +struct __sai__GetPowerSavingOptions +{ +public: + _sai__GetPowerSavingOptions *sai__GetPowerSavingOptions; /* optional element of type sai:GetPowerSavingOptions */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetTLSPSK +#define SOAP_TYPE___sai__SetTLSPSK (1405) +/* Operation wrapper: */ +struct __sai__SetTLSPSK +{ +public: + _sai__SetTLSPSK *sai__SetTLSPSK; /* optional element of type sai:SetTLSPSK */ +}; +#endif + +#ifndef SOAP_TYPE___sai__PartialUnprovision +#define SOAP_TYPE___sai__PartialUnprovision (1409) +/* Operation wrapper: */ +struct __sai__PartialUnprovision +{ +public: + _sai__PartialUnprovision *sai__PartialUnprovision; /* optional element of type sai:PartialUnprovision */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetMEBxPassword +#define SOAP_TYPE___sai__SetMEBxPassword (1413) +/* Operation wrapper: */ +struct __sai__SetMEBxPassword +{ +public: + _sai__SetMEBxPassword *sai__SetMEBxPassword; /* optional element of type sai:SetMEBxPassword */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetProvisioningServerOTP +#define SOAP_TYPE___sai__SetProvisioningServerOTP (1417) +/* Operation wrapper: */ +struct __sai__SetProvisioningServerOTP +{ +public: + _sai__SetProvisioningServerOTP *sai__SetProvisioningServerOTP; /* optional element of type sai:SetProvisioningServerOTP */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetProvisioningServerOTP +#define SOAP_TYPE___sai__GetProvisioningServerOTP (1421) +/* Operation wrapper: */ +struct __sai__GetProvisioningServerOTP +{ +public: + _sai__GetProvisioningServerOTP *sai__GetProvisioningServerOTP; /* optional element of type sai:GetProvisioningServerOTP */ +}; +#endif + +#ifndef SOAP_TYPE___sai__EnumerateCertificateHashEntries +#define SOAP_TYPE___sai__EnumerateCertificateHashEntries (1425) +/* Operation wrapper: */ +struct __sai__EnumerateCertificateHashEntries +{ +public: + _sai__EnumerateCertificateHashEntries *sai__EnumerateCertificateHashEntries; /* optional element of type sai:EnumerateCertificateHashEntries */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetCertificateHashEntry +#define SOAP_TYPE___sai__GetCertificateHashEntry (1429) +/* Operation wrapper: */ +struct __sai__GetCertificateHashEntry +{ +public: + _sai__GetCertificateHashEntry *sai__GetCertificateHashEntry; /* optional element of type sai:GetCertificateHashEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__AddCertificateHashEntry +#define SOAP_TYPE___sai__AddCertificateHashEntry (1433) +/* Operation wrapper: */ +struct __sai__AddCertificateHashEntry +{ +public: + _sai__AddCertificateHashEntry *sai__AddCertificateHashEntry; /* optional element of type sai:AddCertificateHashEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__DeleteCertificateHashEntry +#define SOAP_TYPE___sai__DeleteCertificateHashEntry (1437) +/* Operation wrapper: */ +struct __sai__DeleteCertificateHashEntry +{ +public: + _sai__DeleteCertificateHashEntry *sai__DeleteCertificateHashEntry; /* optional element of type sai:DeleteCertificateHashEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__EnableCertificateHashEntry +#define SOAP_TYPE___sai__EnableCertificateHashEntry (1441) +/* Operation wrapper: */ +struct __sai__EnableCertificateHashEntry +{ +public: + _sai__EnableCertificateHashEntry *sai__EnableCertificateHashEntry; /* optional element of type sai:EnableCertificateHashEntry */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetZeroTouchConfigurationMode +#define SOAP_TYPE___sai__GetZeroTouchConfigurationMode (1445) +/* Operation wrapper: */ +struct __sai__GetZeroTouchConfigurationMode +{ +public: + _sai__GetZeroTouchConfigurationMode *sai__GetZeroTouchConfigurationMode; /* optional element of type sai:GetZeroTouchConfigurationMode */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetZeroTouchConfigurationMode +#define SOAP_TYPE___sai__SetZeroTouchConfigurationMode (1449) +/* Operation wrapper: */ +struct __sai__SetZeroTouchConfigurationMode +{ +public: + _sai__SetZeroTouchConfigurationMode *sai__SetZeroTouchConfigurationMode; /* optional element of type sai:SetZeroTouchConfigurationMode */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetProvisioningAuditRecord +#define SOAP_TYPE___sai__GetProvisioningAuditRecord (1453) +/* Operation wrapper: */ +struct __sai__GetProvisioningAuditRecord +{ +public: + _sai__GetProvisioningAuditRecord *sai__GetProvisioningAuditRecord; /* optional element of type sai:GetProvisioningAuditRecord */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetProvisioningPID +#define SOAP_TYPE___sai__GetProvisioningPID (1457) +/* Operation wrapper: */ +struct __sai__GetProvisioningPID +{ +public: + _sai__GetProvisioningPID *sai__GetProvisioningPID; /* optional element of type sai:GetProvisioningPID */ +}; +#endif + +#ifndef SOAP_TYPE___sai__ExtendProvisioningPeriod +#define SOAP_TYPE___sai__ExtendProvisioningPeriod (1461) +/* Operation wrapper: */ +struct __sai__ExtendProvisioningPeriod +{ +public: + _sai__ExtendProvisioningPeriod *sai__ExtendProvisioningPeriod; /* optional element of type sai:ExtendProvisioningPeriod */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetRealmAuthOptions +#define SOAP_TYPE___sai__GetRealmAuthOptions (1465) +/* Operation wrapper: */ +struct __sai__GetRealmAuthOptions +{ +public: + _sai__GetRealmAuthOptions *sai__GetRealmAuthOptions; /* optional element of type sai:GetRealmAuthOptions */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetRealmAuthOptions +#define SOAP_TYPE___sai__SetRealmAuthOptions (1469) +/* Operation wrapper: */ +struct __sai__SetRealmAuthOptions +{ +public: + _sai__SetRealmAuthOptions *sai__SetRealmAuthOptions; /* optional element of type sai:SetRealmAuthOptions */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetEnvironmentDetection +#define SOAP_TYPE___sai__SetEnvironmentDetection (1473) +/* Operation wrapper: */ +struct __sai__SetEnvironmentDetection +{ +public: + _sai__SetEnvironmentDetection *sai__SetEnvironmentDetection; /* optional element of type sai:SetEnvironmentDetection */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetEnvironmentDetection +#define SOAP_TYPE___sai__GetEnvironmentDetection (1477) +/* Operation wrapper: */ +struct __sai__GetEnvironmentDetection +{ +public: + _sai__GetEnvironmentDetection *sai__GetEnvironmentDetection; /* optional element of type sai:GetEnvironmentDetection */ +}; +#endif + +#ifndef SOAP_TYPE___sai__EnumeratePowerPackages +#define SOAP_TYPE___sai__EnumeratePowerPackages (1481) +/* Operation wrapper: */ +struct __sai__EnumeratePowerPackages +{ +public: + _sai__EnumeratePowerPackages *sai__EnumeratePowerPackages; /* optional element of type sai:EnumeratePowerPackages */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetPowerPackage +#define SOAP_TYPE___sai__GetPowerPackage (1485) +/* Operation wrapper: */ +struct __sai__GetPowerPackage +{ +public: + _sai__GetPowerPackage *sai__GetPowerPackage; /* optional element of type sai:GetPowerPackage */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetActivePowerPackage +#define SOAP_TYPE___sai__GetActivePowerPackage (1489) +/* Operation wrapper: */ +struct __sai__GetActivePowerPackage +{ +public: + _sai__GetActivePowerPackage *sai__GetActivePowerPackage; /* optional element of type sai:GetActivePowerPackage */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetActivePowerPackage +#define SOAP_TYPE___sai__SetActivePowerPackage (1493) +/* Operation wrapper: */ +struct __sai__SetActivePowerPackage +{ +public: + _sai__SetActivePowerPackage *sai__SetActivePowerPackage; /* optional element of type sai:SetActivePowerPackage */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetGlobalPowerPolicy +#define SOAP_TYPE___sai__SetGlobalPowerPolicy (1497) +/* Operation wrapper: */ +struct __sai__SetGlobalPowerPolicy +{ +public: + _sai__SetGlobalPowerPolicy *sai__SetGlobalPowerPolicy; /* optional element of type sai:SetGlobalPowerPolicy */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetGlobalPowerPolicy +#define SOAP_TYPE___sai__GetGlobalPowerPolicy (1501) +/* Operation wrapper: */ +struct __sai__GetGlobalPowerPolicy +{ +public: + _sai__GetGlobalPowerPolicy *sai__GetGlobalPowerPolicy; /* optional element of type sai:GetGlobalPowerPolicy */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreAddKey +#define SOAP_TYPE___sai__CertStoreAddKey (1505) +/* Operation wrapper: */ +struct __sai__CertStoreAddKey +{ +public: + _sai__CertStoreAddKey *sai__CertStoreAddKey; /* optional element of type sai:CertStoreAddKey */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreEnumerateKeys +#define SOAP_TYPE___sai__CertStoreEnumerateKeys (1509) +/* Operation wrapper: */ +struct __sai__CertStoreEnumerateKeys +{ +public: + _sai__CertStoreEnumerateKeys *sai__CertStoreEnumerateKeys; /* optional element of type sai:CertStoreEnumerateKeys */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreGetKey +#define SOAP_TYPE___sai__CertStoreGetKey (1513) +/* Operation wrapper: */ +struct __sai__CertStoreGetKey +{ +public: + _sai__CertStoreGetKey *sai__CertStoreGetKey; /* optional element of type sai:CertStoreGetKey */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreRemoveKey +#define SOAP_TYPE___sai__CertStoreRemoveKey (1517) +/* Operation wrapper: */ +struct __sai__CertStoreRemoveKey +{ +public: + _sai__CertStoreRemoveKey *sai__CertStoreRemoveKey; /* optional element of type sai:CertStoreRemoveKey */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreAddCertificate +#define SOAP_TYPE___sai__CertStoreAddCertificate (1521) +/* Operation wrapper: */ +struct __sai__CertStoreAddCertificate +{ +public: + _sai__CertStoreAddCertificate *sai__CertStoreAddCertificate; /* optional element of type sai:CertStoreAddCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreGetCertificate +#define SOAP_TYPE___sai__CertStoreGetCertificate (1525) +/* Operation wrapper: */ +struct __sai__CertStoreGetCertificate +{ +public: + _sai__CertStoreGetCertificate *sai__CertStoreGetCertificate; /* optional element of type sai:CertStoreGetCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreEnumerateCertificates +#define SOAP_TYPE___sai__CertStoreEnumerateCertificates (1529) +/* Operation wrapper: */ +struct __sai__CertStoreEnumerateCertificates +{ +public: + _sai__CertStoreEnumerateCertificates *sai__CertStoreEnumerateCertificates; /* optional element of type sai:CertStoreEnumerateCertificates */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreRemoveCertificate +#define SOAP_TYPE___sai__CertStoreRemoveCertificate (1533) +/* Operation wrapper: */ +struct __sai__CertStoreRemoveCertificate +{ +public: + _sai__CertStoreRemoveCertificate *sai__CertStoreRemoveCertificate; /* optional element of type sai:CertStoreRemoveCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreGetPKCS10Request +#define SOAP_TYPE___sai__CertStoreGetPKCS10Request (1537) +/* Operation wrapper: */ +struct __sai__CertStoreGetPKCS10Request +{ +public: + _sai__CertStoreGetPKCS10Request *sai__CertStoreGetPKCS10Request; /* optional element of type sai:CertStoreGetPKCS10Request */ +}; +#endif + +#ifndef SOAP_TYPE___sai__CertStoreUpdateCertificate +#define SOAP_TYPE___sai__CertStoreUpdateCertificate (1541) +/* Operation wrapper: */ +struct __sai__CertStoreUpdateCertificate +{ +public: + _sai__CertStoreUpdateCertificate *sai__CertStoreUpdateCertificate; /* optional element of type sai:CertStoreUpdateCertificate */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetTLSCredentials +#define SOAP_TYPE___sai__SetTLSCredentials (1545) +/* Operation wrapper: */ +struct __sai__SetTLSCredentials +{ +public: + _sai__SetTLSCredentials *sai__SetTLSCredentials; /* optional element of type sai:SetTLSCredentials */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetTLSCredentials +#define SOAP_TYPE___sai__GetTLSCredentials (1549) +/* Operation wrapper: */ +struct __sai__GetTLSCredentials +{ +public: + _sai__GetTLSCredentials *sai__GetTLSCredentials; /* optional element of type sai:GetTLSCredentials */ +}; +#endif + +#ifndef SOAP_TYPE___sai__EnableVpnRouting +#define SOAP_TYPE___sai__EnableVpnRouting (1553) +/* Operation wrapper: */ +struct __sai__EnableVpnRouting +{ +public: + _sai__EnableVpnRouting *sai__EnableVpnRouting; /* optional element of type sai:EnableVpnRouting */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetConfigurationServerFQDN +#define SOAP_TYPE___sai__GetConfigurationServerFQDN (1557) +/* Operation wrapper: */ +struct __sai__GetConfigurationServerFQDN +{ +public: + _sai__GetConfigurationServerFQDN *sai__GetConfigurationServerFQDN; /* optional element of type sai:GetConfigurationServerFQDN */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetConfigurationServerFQDN +#define SOAP_TYPE___sai__SetConfigurationServerFQDN (1561) +/* Operation wrapper: */ +struct __sai__SetConfigurationServerFQDN +{ +public: + _sai__SetConfigurationServerFQDN *sai__SetConfigurationServerFQDN; /* optional element of type sai:SetConfigurationServerFQDN */ +}; +#endif + +#ifndef SOAP_TYPE___sai__SetAclEnabledState +#define SOAP_TYPE___sai__SetAclEnabledState (1565) +/* Operation wrapper: */ +struct __sai__SetAclEnabledState +{ +public: + _sai__SetAclEnabledState *sai__SetAclEnabledState; /* optional element of type sai:SetAclEnabledState */ +}; +#endif + +#ifndef SOAP_TYPE___sai__GetAclEnabledState +#define SOAP_TYPE___sai__GetAclEnabledState (1569) +/* Operation wrapper: */ +struct __sai__GetAclEnabledState +{ +public: + _sai__GetAclEnabledState *sai__GetAclEnabledState; /* optional element of type sai:GetAclEnabledState */ +}; +#endif + +#ifndef SOAP_TYPE___str__ExecuteStorageOperation +#define SOAP_TYPE___str__ExecuteStorageOperation (1573) +/* Operation wrapper: */ +struct __str__ExecuteStorageOperation +{ +public: + _str__ExecuteStorageOperation *str__ExecuteStorageOperation; /* optional element of type str:ExecuteStorageOperation */ +}; +#endif + +#ifndef SOAP_TYPE___stra__GetGlobalStorageAttributes +#define SOAP_TYPE___stra__GetGlobalStorageAttributes (1577) +/* Operation wrapper: */ +struct __stra__GetGlobalStorageAttributes +{ +public: + _stra__GetGlobalStorageAttributes *stra__GetGlobalStorageAttributes; /* optional element of type stra:GetGlobalStorageAttributes */ +}; +#endif + +#ifndef SOAP_TYPE___stra__SetGlobalStorageAttributes +#define SOAP_TYPE___stra__SetGlobalStorageAttributes (1581) +/* Operation wrapper: */ +struct __stra__SetGlobalStorageAttributes +{ +public: + _stra__SetGlobalStorageAttributes *stra__SetGlobalStorageAttributes; /* optional element of type stra:SetGlobalStorageAttributes */ +}; +#endif + +#ifndef SOAP_TYPE___stra__AdminGetRegisteredApplications +#define SOAP_TYPE___stra__AdminGetRegisteredApplications (1585) +/* Operation wrapper: */ +struct __stra__AdminGetRegisteredApplications +{ +public: + _stra__AdminGetRegisteredApplications *stra__AdminGetRegisteredApplications; /* optional element of type stra:AdminGetRegisteredApplications */ +}; +#endif + +#ifndef SOAP_TYPE___stra__AdminGetApplicationAttributes +#define SOAP_TYPE___stra__AdminGetApplicationAttributes (1589) +/* Operation wrapper: */ +struct __stra__AdminGetApplicationAttributes +{ +public: + _stra__AdminGetApplicationAttributes *stra__AdminGetApplicationAttributes; /* optional element of type stra:AdminGetApplicationAttributes */ +}; +#endif + +#ifndef SOAP_TYPE___stra__AdminRemoveApplication +#define SOAP_TYPE___stra__AdminRemoveApplication (1593) +/* Operation wrapper: */ +struct __stra__AdminRemoveApplication +{ +public: + _stra__AdminRemoveApplication *stra__AdminRemoveApplication; /* optional element of type stra:AdminRemoveApplication */ +}; +#endif + +#ifndef SOAP_TYPE___stra__AddStorageEaclEntry +#define SOAP_TYPE___stra__AddStorageEaclEntry (1597) +/* Operation wrapper: */ +struct __stra__AddStorageEaclEntry +{ +public: + _stra__AddStorageEaclEntry *stra__AddStorageEaclEntry; /* optional element of type stra:AddStorageEaclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___stra__EnumerateStorageEaclEntries +#define SOAP_TYPE___stra__EnumerateStorageEaclEntries (1601) +/* Operation wrapper: */ +struct __stra__EnumerateStorageEaclEntries +{ +public: + _stra__EnumerateStorageEaclEntries *stra__EnumerateStorageEaclEntries; /* optional element of type stra:EnumerateStorageEaclEntries */ +}; +#endif + +#ifndef SOAP_TYPE___stra__GetStorageEaclEntry +#define SOAP_TYPE___stra__GetStorageEaclEntry (1605) +/* Operation wrapper: */ +struct __stra__GetStorageEaclEntry +{ +public: + _stra__GetStorageEaclEntry *stra__GetStorageEaclEntry; /* optional element of type stra:GetStorageEaclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___stra__RemoveStorageEaclEntry +#define SOAP_TYPE___stra__RemoveStorageEaclEntry (1609) +/* Operation wrapper: */ +struct __stra__RemoveStorageEaclEntry +{ +public: + _stra__RemoveStorageEaclEntry *stra__RemoveStorageEaclEntry; /* optional element of type stra:RemoveStorageEaclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___stra__AddStorageFpaclEntry +#define SOAP_TYPE___stra__AddStorageFpaclEntry (1613) +/* Operation wrapper: */ +struct __stra__AddStorageFpaclEntry +{ +public: + _stra__AddStorageFpaclEntry *stra__AddStorageFpaclEntry; /* optional element of type stra:AddStorageFpaclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___stra__EnumerateStorageAllocEntries +#define SOAP_TYPE___stra__EnumerateStorageAllocEntries (1617) +/* Operation wrapper: */ +struct __stra__EnumerateStorageAllocEntries +{ +public: + _stra__EnumerateStorageAllocEntries *stra__EnumerateStorageAllocEntries; /* optional element of type stra:EnumerateStorageAllocEntries */ +}; +#endif + +#ifndef SOAP_TYPE___stra__GetStorageAllocEntry +#define SOAP_TYPE___stra__GetStorageAllocEntry (1621) +/* Operation wrapper: */ +struct __stra__GetStorageAllocEntry +{ +public: + _stra__GetStorageAllocEntry *stra__GetStorageAllocEntry; /* optional element of type stra:GetStorageAllocEntry */ +}; +#endif + +#ifndef SOAP_TYPE___stra__UpdateStorageFpaclEntry +#define SOAP_TYPE___stra__UpdateStorageFpaclEntry (1625) +/* Operation wrapper: */ +struct __stra__UpdateStorageFpaclEntry +{ +public: + _stra__UpdateStorageFpaclEntry *stra__UpdateStorageFpaclEntry; /* optional element of type stra:UpdateStorageFpaclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___stra__RemoveStorageFpaclEntry +#define SOAP_TYPE___stra__RemoveStorageFpaclEntry (1629) +/* Operation wrapper: */ +struct __stra__RemoveStorageFpaclEntry +{ +public: + _stra__RemoveStorageFpaclEntry *stra__RemoveStorageFpaclEntry; /* optional element of type stra:RemoveStorageFpaclEntry */ +}; +#endif + +#ifndef SOAP_TYPE___tim__GetLowAccuracyTimeSynch +#define SOAP_TYPE___tim__GetLowAccuracyTimeSynch (1633) +/* Operation wrapper: */ +struct __tim__GetLowAccuracyTimeSynch +{ +public: + _tim__GetLowAccuracyTimeSynch *tim__GetLowAccuracyTimeSynch; /* optional element of type tim:GetLowAccuracyTimeSynch */ +}; +#endif + +#ifndef SOAP_TYPE___tim__SetHighAccuracyTimeSynch +#define SOAP_TYPE___tim__SetHighAccuracyTimeSynch (1637) +/* Operation wrapper: */ +struct __tim__SetHighAccuracyTimeSynch +{ +public: + _tim__SetHighAccuracyTimeSynch *tim__SetHighAccuracyTimeSynch; /* optional element of type tim:SetHighAccuracyTimeSynch */ +}; +#endif + +#ifndef SOAP_TYPE___wcxs__AddWirelessProfile +#define SOAP_TYPE___wcxs__AddWirelessProfile (1641) +/* Operation wrapper: */ +struct __wcxs__AddWirelessProfile +{ +public: + _wcxs__AddWirelessProfileRequest *wcxs__AddWirelessProfileRequest; /* optional element of type wcxs:AddWirelessProfileRequest */ +}; +#endif + +#ifndef SOAP_TYPE___wcxs__GetWirelessProfile +#define SOAP_TYPE___wcxs__GetWirelessProfile (1645) +/* Operation wrapper: */ +struct __wcxs__GetWirelessProfile +{ +public: + _wcxs__GetWirelessProfileRequest *wcxs__GetWirelessProfileRequest; /* optional element of type wcxs:GetWirelessProfileRequest */ +}; +#endif + +#ifndef SOAP_TYPE___wcxs__RemoveWirelessProfile +#define SOAP_TYPE___wcxs__RemoveWirelessProfile (1649) +/* Operation wrapper: */ +struct __wcxs__RemoveWirelessProfile +{ +public: + _wcxs__RemoveWirelessProfileRequest *wcxs__RemoveWirelessProfileRequest; /* optional element of type wcxs:RemoveWirelessProfileRequest */ +}; +#endif + +#ifndef SOAP_TYPE___wcxs__UpdateWirelessProfile +#define SOAP_TYPE___wcxs__UpdateWirelessProfile (1653) +/* Operation wrapper: */ +struct __wcxs__UpdateWirelessProfile +{ +public: + _wcxs__UpdateWirelessProfileRequest *wcxs__UpdateWirelessProfileRequest; /* optional element of type wcxs:UpdateWirelessProfileRequest */ +}; +#endif + +#ifndef SOAP_TYPE___wcxs__EnumerateWirelessProfiles +#define SOAP_TYPE___wcxs__EnumerateWirelessProfiles (1657) +/* Operation wrapper: */ +struct __wcxs__EnumerateWirelessProfiles +{ +public: + _wcxs__EnumerateWirelessProfilesRequest *wcxs__EnumerateWirelessProfilesRequest; /* optional element of type wcxs:EnumerateWirelessProfilesRequest */ +}; +#endif + +#ifndef SOAP_TYPE___wcxs__GetWirelessCapabilities +#define SOAP_TYPE___wcxs__GetWirelessCapabilities (1661) +/* Operation wrapper: */ +struct __wcxs__GetWirelessCapabilities +{ +public: + _wcxs__GetWirelessCapabilitiesRequest *wcxs__GetWirelessCapabilitiesRequest; /* optional element of type wcxs:GetWirelessCapabilitiesRequest */ +}; +#endif + +#ifndef SOAP_TYPE___wcxs__GetWirelessSettings +#define SOAP_TYPE___wcxs__GetWirelessSettings (1665) +/* Operation wrapper: */ +struct __wcxs__GetWirelessSettings +{ +public: + _wcxs__GetWirelessSettingsRequest *wcxs__GetWirelessSettingsRequest; /* optional element of type wcxs:GetWirelessSettingsRequest */ +}; +#endif + +#ifndef SOAP_TYPE_SOAP_ENV__Header +#define SOAP_TYPE_SOAP_ENV__Header (1668) +/* SOAP Header: */ +struct SOAP_ENV__Header +{ +public: + void *dummy; /* transient */ +}; +#endif + +#ifndef SOAP_TYPE_SOAP_ENV__Code +#define SOAP_TYPE_SOAP_ENV__Code (1669) +/* SOAP Fault Code: */ +struct SOAP_ENV__Code +{ +public: + char *SOAP_ENV__Value; /* optional element of type QName */ + struct SOAP_ENV__Code *SOAP_ENV__Subcode; /* optional element of type SOAP-ENV:Code */ +}; +#endif + +#ifndef SOAP_TYPE_SOAP_ENV__Detail +#define SOAP_TYPE_SOAP_ENV__Detail (1671) +/* SOAP-ENV:Detail */ +struct SOAP_ENV__Detail +{ +public: + int __type; /* any type of element (defined below) */ + void *fault; /* transient */ + char *__any; +}; +#endif + +#ifndef SOAP_TYPE_SOAP_ENV__Reason +#define SOAP_TYPE_SOAP_ENV__Reason (1672) +/* SOAP-ENV:Reason */ +struct SOAP_ENV__Reason +{ +public: + char *SOAP_ENV__Text; /* optional element of type xsd:string */ +}; +#endif + +#ifndef SOAP_TYPE_SOAP_ENV__Fault +#define SOAP_TYPE_SOAP_ENV__Fault (1673) +/* SOAP Fault: */ +struct SOAP_ENV__Fault +{ +public: + char *faultcode; /* optional element of type QName */ + char *faultstring; /* optional element of type xsd:string */ + char *faultactor; /* optional element of type xsd:string */ + struct SOAP_ENV__Detail *detail; /* optional element of type SOAP-ENV:Detail */ + struct SOAP_ENV__Code *SOAP_ENV__Code; /* optional element of type SOAP-ENV:Code */ + struct SOAP_ENV__Reason *SOAP_ENV__Reason; /* optional element of type SOAP-ENV:Reason */ + char *SOAP_ENV__Node; /* optional element of type xsd:string */ + char *SOAP_ENV__Role; /* optional element of type xsd:string */ + struct SOAP_ENV__Detail *SOAP_ENV__Detail; /* optional element of type SOAP-ENV:Detail */ +}; +#endif + +/******************************************************************************\ + * * + * Types with Custom Serializers * + * * +\******************************************************************************/ + + +/******************************************************************************\ + * * + * Typedefs * + * * +\******************************************************************************/ + +#ifndef SOAP_TYPE__XML +#define SOAP_TYPE__XML (4) +typedef char *_XML; +#endif + +#ifndef SOAP_TYPE__QName +#define SOAP_TYPE__QName (5) +typedef char *_QName; +#endif + +#ifndef SOAP_TYPE_xsd__anyURI +#define SOAP_TYPE_xsd__anyURI (8) +typedef std::string xsd__anyURI; +#endif + +#ifndef SOAP_TYPE_cmn__PT_USCORESTATUS +#define SOAP_TYPE_cmn__PT_USCORESTATUS (543) +typedef unsigned int cmn__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_cmn__HostNameType +#define SOAP_TYPE_cmn__HostNameType (544) +typedef std::string cmn__HostNameType; +#endif + +#ifndef SOAP_TYPE_cmn__IPv4AddressType +#define SOAP_TYPE_cmn__IPv4AddressType (545) +typedef unsigned int cmn__IPv4AddressType; +#endif + +#ifndef SOAP_TYPE_cmn__IPv4AddressStringType +#define SOAP_TYPE_cmn__IPv4AddressStringType (546) +typedef std::string cmn__IPv4AddressStringType; +#endif + +#ifndef SOAP_TYPE_cmn__IPv6AddressStringType +#define SOAP_TYPE_cmn__IPv6AddressStringType (547) +typedef std::string cmn__IPv6AddressStringType; +#endif + +#ifndef SOAP_TYPE_cmn__InterfaceHandleType +#define SOAP_TYPE_cmn__InterfaceHandleType (548) +typedef unsigned int cmn__InterfaceHandleType; +#endif + +#ifndef SOAP_TYPE_cmn__GuidBuf +#define SOAP_TYPE_cmn__GuidBuf (549) +typedef xsd__base64Binary cmn__GuidBuf; +#endif + +#ifndef SOAP_TYPE_cstr__KeyPairHandleType +#define SOAP_TYPE_cstr__KeyPairHandleType (550) +typedef unsigned int cstr__KeyPairHandleType; +#endif + +#ifndef SOAP_TYPE_sai__PT_USCORESTATUS +#define SOAP_TYPE_sai__PT_USCORESTATUS (551) +typedef unsigned int sai__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_sai__UserAclEntryHandleType +#define SOAP_TYPE_sai__UserAclEntryHandleType (553) +typedef unsigned int sai__UserAclEntryHandleType; +#endif + +#ifndef SOAP_TYPE_sai__AclStringType +#define SOAP_TYPE_sai__AclStringType (554) +typedef std::string sai__AclStringType; +#endif + +#ifndef SOAP_TYPE_sai__AclPasswordStringType +#define SOAP_TYPE_sai__AclPasswordStringType (555) +typedef std::string sai__AclPasswordStringType; +#endif + +#ifndef SOAP_TYPE_sai__IPv4AddressType +#define SOAP_TYPE_sai__IPv4AddressType (556) +typedef unsigned int sai__IPv4AddressType; +#endif + +#ifndef SOAP_TYPE_sai__CertificateHandleType +#define SOAP_TYPE_sai__CertificateHandleType (568) +typedef unsigned int sai__CertificateHandleType; +#endif + +#ifndef SOAP_TYPE_sai__MEBxPasswordType +#define SOAP_TYPE_sai__MEBxPasswordType (570) +typedef std::string sai__MEBxPasswordType; +#endif + +#ifndef SOAP_TYPE_sai__ProvisioningOTPType +#define SOAP_TYPE_sai__ProvisioningOTPType (571) +typedef xsd__base64Binary sai__ProvisioningOTPType; +#endif + +#ifndef SOAP_TYPE_sai__FriendlyNameType +#define SOAP_TYPE_sai__FriendlyNameType (572) +typedef std::string sai__FriendlyNameType; +#endif + +#ifndef SOAP_TYPE__sai__SpnString +#define SOAP_TYPE__sai__SpnString (575) +typedef std::string _sai__SpnString; +#endif + +#ifndef SOAP_TYPE__sai__KerberosRealmName +#define SOAP_TYPE__sai__KerberosRealmName (576) +typedef std::string _sai__KerberosRealmName; +#endif + +#ifndef SOAP_TYPE_net__PT_USCORESTATUS +#define SOAP_TYPE_net__PT_USCORESTATUS (578) +typedef unsigned int net__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_net__IPv4AddressType +#define SOAP_TYPE_net__IPv4AddressType (579) +typedef unsigned int net__IPv4AddressType; +#endif + +#ifndef SOAP_TYPE_net__MACAddressType +#define SOAP_TYPE_net__MACAddressType (581) +typedef std::string net__MACAddressType; +#endif + +#ifndef SOAP_TYPE_net__LinkPolicyType +#define SOAP_TYPE_net__LinkPolicyType (583) +typedef unsigned char net__LinkPolicyType; +#endif + +#ifndef SOAP_TYPE_net__InterfaceHandleType +#define SOAP_TYPE_net__InterfaceHandleType (584) +typedef unsigned int net__InterfaceHandleType; +#endif + +#ifndef SOAP_TYPE_stra__PT_USCORESTATUS +#define SOAP_TYPE_stra__PT_USCORESTATUS (585) +typedef unsigned int stra__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_stra__StorageApplicationHandleType +#define SOAP_TYPE_stra__StorageApplicationHandleType (586) +typedef unsigned int stra__StorageApplicationHandleType; +#endif + +#ifndef SOAP_TYPE_stra__StorageEaclEntryHandleType +#define SOAP_TYPE_stra__StorageEaclEntryHandleType (588) +typedef unsigned int stra__StorageEaclEntryHandleType; +#endif + +#ifndef SOAP_TYPE_stra__StorageAllocEntryHandleType +#define SOAP_TYPE_stra__StorageAllocEntryHandleType (589) +typedef unsigned int stra__StorageAllocEntryHandleType; +#endif + +#ifndef SOAP_TYPE_emi__TimeType +#define SOAP_TYPE_emi__TimeType (590) +typedef unsigned int emi__TimeType; +#endif + +#ifndef SOAP_TYPE_emi__AlertSubscriptionPolicyIDType +#define SOAP_TYPE_emi__AlertSubscriptionPolicyIDType (591) +typedef unsigned char emi__AlertSubscriptionPolicyIDType; +#endif + +#ifndef SOAP_TYPE_emi__AlertSubscriptionHandleType +#define SOAP_TYPE_emi__AlertSubscriptionHandleType (592) +typedef unsigned int emi__AlertSubscriptionHandleType; +#endif + +#ifndef SOAP_TYPE_emi__EventFilterHandleType +#define SOAP_TYPE_emi__EventFilterHandleType (593) +typedef unsigned int emi__EventFilterHandleType; +#endif + +#ifndef SOAP_TYPE_emi__PT_USCORESTATUS +#define SOAP_TYPE_emi__PT_USCORESTATUS (595) +typedef unsigned int emi__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_emi__IPv4AddressType +#define SOAP_TYPE_emi__IPv4AddressType (596) +typedef unsigned int emi__IPv4AddressType; +#endif + +#ifndef SOAP_TYPE_emi__SensorHandleType +#define SOAP_TYPE_emi__SensorHandleType (597) +typedef unsigned int emi__SensorHandleType; +#endif + +#ifndef SOAP_TYPE_emi__CommunityStringType +#define SOAP_TYPE_emi__CommunityStringType (599) +typedef std::string emi__CommunityStringType; +#endif + +#ifndef SOAP_TYPE_cb__PT_USCORESTATUS +#define SOAP_TYPE_cb__PT_USCORESTATUS (600) +typedef unsigned int cb__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_cb__TimeType +#define SOAP_TYPE_cb__TimeType (601) +typedef unsigned int cb__TimeType; +#endif + +#ifndef SOAP_TYPE_cb__IPv4AddressStringType +#define SOAP_TYPE_cb__IPv4AddressStringType (602) +typedef std::string cb__IPv4AddressStringType; +#endif + +#ifndef SOAP_TYPE_cb__IPv6AddressStringType +#define SOAP_TYPE_cb__IPv6AddressStringType (603) +typedef std::string cb__IPv6AddressStringType; +#endif + +#ifndef SOAP_TYPE__cb__FilterName +#define SOAP_TYPE__cb__FilterName (610) +typedef std::string _cb__FilterName; +#endif + +#ifndef SOAP_TYPE__cb__PolicyName +#define SOAP_TYPE__cb__PolicyName (611) +typedef std::string _cb__PolicyName; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCORESTATUS +#define SOAP_TYPE_hwa__PT_USCORESTATUS (612) +typedef unsigned int hwa__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS +#define SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS (614) +typedef unsigned int hwa__PT_USCOREBIOS_USCORECHARACTERISTICS; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE (615) +typedef unsigned char hwa__PT_USCOREPROCESSOR_USCORETYPE; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY (616) +typedef unsigned char hwa__PT_USCOREPROCESSOR_USCOREFAMILY; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS (617) +typedef unsigned char hwa__PT_USCOREPROCESSOR_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE +#define SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE (618) +typedef unsigned char hwa__PT_USCOREPROCESSOR_USCOREUPGRADE; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR +#define SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR (619) +typedef unsigned char hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE +#define SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE (620) +typedef unsigned char hwa__PT_USCOREMEMORY_USCORETYPE; +#endif + +#ifndef SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL +#define SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL (623) +typedef unsigned short hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL; +#endif + +#ifndef SOAP_TYPE_apr__PT_USCORESTATUS +#define SOAP_TYPE_apr__PT_USCORESTATUS (624) +typedef unsigned int apr__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_apr__WatchdogState +#define SOAP_TYPE_apr__WatchdogState (625) +typedef unsigned char apr__WatchdogState; +#endif + +#ifndef SOAP_TYPE__apr__AgentDescription +#define SOAP_TYPE__apr__AgentDescription (627) +typedef std::string _apr__AgentDescription; +#endif + +#ifndef SOAP_TYPE_apl__PT_USCORESTATUS +#define SOAP_TYPE_apl__PT_USCORESTATUS (628) +typedef unsigned int apl__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_idr__PT_USCORESTATUS +#define SOAP_TYPE_idr__PT_USCORESTATUS (629) +typedef unsigned int idr__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_idr__TimeType +#define SOAP_TYPE_idr__TimeType (630) +typedef unsigned int idr__TimeType; +#endif + +#ifndef SOAP_TYPE_idr__IPv4AddressType +#define SOAP_TYPE_idr__IPv4AddressType (631) +typedef unsigned int idr__IPv4AddressType; +#endif + +#ifndef SOAP_TYPE_tim__PT_USCORESTATUS +#define SOAP_TYPE_tim__PT_USCORESTATUS (632) +typedef unsigned int tim__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_tim__TimeType +#define SOAP_TYPE_tim__TimeType (633) +typedef unsigned int tim__TimeType; +#endif + +#ifndef SOAP_TYPE_str__PT_USCORESTATUS +#define SOAP_TYPE_str__PT_USCORESTATUS (634) +typedef unsigned int str__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_inf__PT_USCORESTATUS +#define SOAP_TYPE_inf__PT_USCORESTATUS (635) +typedef unsigned int inf__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_inf__TimeType +#define SOAP_TYPE_inf__TimeType (636) +typedef unsigned int inf__TimeType; +#endif + +#ifndef SOAP_TYPE_inf__IPv4AddressType +#define SOAP_TYPE_inf__IPv4AddressType (637) +typedef unsigned int inf__IPv4AddressType; +#endif + +#ifndef SOAP_TYPE_rci__SystemPowerStateType +#define SOAP_TYPE_rci__SystemPowerStateType (642) +typedef unsigned int rci__SystemPowerStateType; +#endif + +#ifndef SOAP_TYPE_rci__PT_USCORESTATUS +#define SOAP_TYPE_rci__PT_USCORESTATUS (643) +typedef unsigned int rci__PT_USCORESTATUS; +#endif + +#ifndef SOAP_TYPE_rci__SystemCapabilitiesSupportedType +#define SOAP_TYPE_rci__SystemCapabilitiesSupportedType (644) +typedef unsigned char rci__SystemCapabilitiesSupportedType; +#endif + +#ifndef SOAP_TYPE_rci__SpecialCommandsSupportedType +#define SOAP_TYPE_rci__SpecialCommandsSupportedType (645) +typedef unsigned short rci__SpecialCommandsSupportedType; +#endif + +#ifndef SOAP_TYPE_rci__SystemFirmwareCapabilitiesType +#define SOAP_TYPE_rci__SystemFirmwareCapabilitiesType (646) +typedef unsigned int rci__SystemFirmwareCapabilitiesType; +#endif + +#ifndef SOAP_TYPE_rci__OemDefinedCapabilitiesType +#define SOAP_TYPE_rci__OemDefinedCapabilitiesType (647) +typedef unsigned int rci__OemDefinedCapabilitiesType; +#endif + +#ifndef SOAP_TYPE_rci__BootOptionsType +#define SOAP_TYPE_rci__BootOptionsType (650) +typedef unsigned short rci__BootOptionsType; +#endif + +#ifndef SOAP_TYPE_rci__SpecialCommandParameterType +#define SOAP_TYPE_rci__SpecialCommandParameterType (651) +typedef unsigned short rci__SpecialCommandParameterType; +#endif + +#ifndef SOAP_TYPE_rci__OemParametersType +#define SOAP_TYPE_rci__OemParametersType (652) +typedef unsigned short rci__OemParametersType; +#endif + +#ifndef SOAP_TYPE_wcxs__ProfileNameType +#define SOAP_TYPE_wcxs__ProfileNameType (653) +typedef std::string wcxs__ProfileNameType; +#endif + +#ifndef SOAP_TYPE_wcxs__ProfilePriorityType +#define SOAP_TYPE_wcxs__ProfilePriorityType (654) +typedef unsigned char wcxs__ProfilePriorityType; +#endif + +#ifndef SOAP_TYPE_wcxs__RawKey64Type +#define SOAP_TYPE_wcxs__RawKey64Type (656) +typedef xsd__base64Binary wcxs__RawKey64Type; +#endif + +#ifndef SOAP_TYPE_wcxs__RawKey128Type +#define SOAP_TYPE_wcxs__RawKey128Type (657) +typedef xsd__base64Binary wcxs__RawKey128Type; +#endif + +#ifndef SOAP_TYPE_wcxs__RawKey256Type +#define SOAP_TYPE_wcxs__RawKey256Type (658) +typedef xsd__base64Binary wcxs__RawKey256Type; +#endif + +#ifndef SOAP_TYPE_wcxs__PassPhrase5Type +#define SOAP_TYPE_wcxs__PassPhrase5Type (659) +typedef std::string wcxs__PassPhrase5Type; +#endif + +#ifndef SOAP_TYPE_wcxs__PassPhraseWEP128Type +#define SOAP_TYPE_wcxs__PassPhraseWEP128Type (660) +typedef std::string wcxs__PassPhraseWEP128Type; +#endif + +#ifndef SOAP_TYPE_wcxs__PassPhrase63Type +#define SOAP_TYPE_wcxs__PassPhrase63Type (661) +typedef std::string wcxs__PassPhrase63Type; +#endif + + +/******************************************************************************\ + * * + * Typedef Synonyms * + * * +\******************************************************************************/ + +typedef enum sai__UserAclRealmType sai__UserAclRealmType; +typedef enum sai__RsaKeyEncodingType sai__RsaKeyEncodingType; +typedef enum sai__RsaCertificateEncodingType sai__RsaCertificateEncodingType; +typedef enum sai__RngKeyEncodingType sai__RngKeyEncodingType; +typedef enum sai__ProvisioningModeType sai__ProvisioningModeType; +typedef enum sai__AccessPermissionType sai__AccessPermissionType; +typedef enum sai__KerberosSpnProtocolType sai__KerberosSpnProtocolType; +typedef enum sai__KerberosEncryptionType sai__KerberosEncryptionType; +typedef enum sai__PowerStateType sai__PowerStateType; +typedef enum sai__EnabledInterfacesType sai__EnabledInterfacesType; +typedef enum sai__InterfaceType sai__InterfaceType; +typedef enum sai__TlsAthenticationType sai__TlsAthenticationType; +typedef enum sai__ProvisioningTLSModeType sai__ProvisioningTLSModeType; +typedef enum sai__HashTypeType sai__HashTypeType; +typedef enum sai__HTTPAuthOptionType sai__HTTPAuthOptionType; +typedef enum xcfg__CertNameOptionsType xcfg__CertNameOptionsType; +typedef enum net__DhcpModeType net__DhcpModeType; +typedef enum net__InterfaceModeType net__InterfaceModeType; +typedef enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE; +typedef enum emi__EventSeverityType emi__EventSeverityType; +typedef enum emi__AlertAuthOptionsType emi__AlertAuthOptionsType; +typedef enum cb__CircuitBreakerFilterDirectionType cb__CircuitBreakerFilterDirectionType; +typedef enum cb__CircuitBreakerFilterIPAddressDirectionType cb__CircuitBreakerFilterIPAddressDirectionType; +typedef enum cb__CircuitBreakerProfileType cb__CircuitBreakerProfileType; +typedef enum cb__CircuitBreakerApplicationType cb__CircuitBreakerApplicationType; +typedef enum cb__HcbStateType cb__HcbStateType; +typedef enum cb__HcbTriggerReasonType cb__HcbTriggerReasonType; +typedef enum hwa__AssetTypeType hwa__AssetTypeType; +typedef enum apr__CbActionType apr__CbActionType; +typedef enum inf__ProvisioningModeType inf__ProvisioningModeType; +typedef enum inf__ProvisioningStateType inf__ProvisioningStateType; +typedef enum inf__PasswordModelType inf__PasswordModelType; +typedef enum inf__EnabledInterfacesType inf__EnabledInterfacesType; +typedef enum rci__RemoteControlCommandType rci__RemoteControlCommandType; +typedef enum rci__SpecialCommandType rci__SpecialCommandType; +typedef enum wcxs__KeyIndexType wcxs__KeyIndexType; +typedef enum wcxs__FeatureType wcxs__FeatureType; + +/******************************************************************************\ + * * + * Externals * + * * +\******************************************************************************/ + + +/******************************************************************************\ + * * + * Stubs * + * * +\******************************************************************************/ + + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apl__AgentWatchdogShutdown(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apl__AgentWatchdogShutdown *apl__AgentWatchdogShutdown, _apl__AgentWatchdogShutdownResponse *apl__AgentWatchdogShutdownResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apl__AgentWatchdogHeartbeat(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apl__AgentWatchdogHeartbeat *apl__AgentWatchdogHeartbeat, _apl__AgentWatchdogHeartbeatResponse *apl__AgentWatchdogHeartbeatResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apl__AgentWatchdogRegister(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apl__AgentWatchdogRegister *apl__AgentWatchdogRegister, _apl__AgentWatchdogRegisterResponse *apl__AgentWatchdogRegisterResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogCreate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogCreate *apr__ConsoleWatchdogCreate, _apr__ConsoleWatchdogCreateResponse *apr__ConsoleWatchdogCreateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogDelete(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogDelete *apr__ConsoleWatchdogDelete, _apr__ConsoleWatchdogDeleteResponse *apr__ConsoleWatchdogDeleteResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogEnumerate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogEnumerate *apr__ConsoleWatchdogEnumerate, _apr__ConsoleWatchdogEnumerateResponse *apr__ConsoleWatchdogEnumerateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogSetActions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogSetActions *apr__ConsoleWatchdogSetActions, _apr__ConsoleWatchdogSetActionsResponse *apr__ConsoleWatchdogSetActionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogGetActions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogGetActions *apr__ConsoleWatchdogGetActions, _apr__ConsoleWatchdogGetActionsResponse *apr__ConsoleWatchdogGetActionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogSetCbPolicy *apr__ConsoleWatchdogSetCbPolicy, _apr__ConsoleWatchdogSetCbPolicyResponse *apr__ConsoleWatchdogSetCbPolicyResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogGetCbPolicy *apr__ConsoleWatchdogGetCbPolicy, _apr__ConsoleWatchdogGetCbPolicyResponse *apr__ConsoleWatchdogGetCbPolicyResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogQueryCapabilities *apr__ConsoleWatchdogQueryCapabilities, _apr__ConsoleWatchdogQueryCapabilitiesResponse *apr__ConsoleWatchdogQueryCapabilitiesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyCreate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyCreate *cb__CbPolicyCreate, _cb__CbPolicyCreateResponse *cb__CbPolicyCreateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyGet(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyGet *cb__CbPolicyGet, _cb__CbPolicyGetResponse *cb__CbPolicyGetResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyDelete(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyDelete *cb__CbPolicyDelete, _cb__CbPolicyDeleteResponse *cb__CbPolicyDeleteResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyEnumerate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyEnumerate *cb__CbPolicyEnumerate, _cb__CbPolicyEnumerateResponse *cb__CbPolicyEnumerateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyEnable(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyEnable *cb__CbPolicyEnable, _cb__CbPolicyEnableResponse *cb__CbPolicyEnableResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyDisable(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyDisable *cb__CbPolicyDisable, _cb__CbPolicyDisableResponse *cb__CbPolicyDisableResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyGetEnabled(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyGetEnabled *cb__CbPolicyGetEnabled, _cb__CbPolicyGetEnabledResponse *cb__CbPolicyGetEnabledResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyGetActiveStatistics(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyGetActiveStatistics *cb__CbPolicyGetActiveStatistics, _cb__CbPolicyGetActiveStatisticsResponse *cb__CbPolicyGetActiveStatisticsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbFilterCreate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbFilterCreate *cb__CbFilterCreate, _cb__CbFilterCreateResponse *cb__CbFilterCreateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbFilterGet(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbFilterGet *cb__CbFilterGet, _cb__CbFilterGetResponse *cb__CbFilterGetResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbFilterDelete(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbFilterDelete *cb__CbFilterDelete, _cb__CbFilterDeleteResponse *cb__CbFilterDeleteResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbFilterEnumerate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbFilterEnumerate *cb__CbFilterEnumerate, _cb__CbFilterEnumerateResponse *cb__CbFilterEnumerateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbQueryCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbQueryCapabilities *cb__CbQueryCapabilities, _cb__CbQueryCapabilitiesResponse *cb__CbQueryCapabilitiesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__SetHcbOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__SetHcbOptions *cb__SetHcbOptions, _cb__SetHcbOptionsResponse *cb__SetHcbOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__GetHcbOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__GetHcbOptions *cb__GetHcbOptions, _cb__GetHcbOptionsResponse *cb__GetHcbOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__ClearHcbState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__ClearHcbState *cb__ClearHcbState, _cb__ClearHcbStateResponse *cb__ClearHcbStateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__GetHcbState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__GetHcbState *cb__GetHcbState, _cb__GetHcbStateResponse *cb__GetHcbStateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateEventFilters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateEventFilters *emi__EnumerateEventFilters, _emi__EnumerateEventFiltersResponse *emi__EnumerateEventFiltersResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetAlertSubscription(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetAlertSubscription *emi__GetAlertSubscription, _emi__GetAlertSubscriptionResponse *emi__GetAlertSubscriptionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__SetAlertCommunityString(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__SetAlertCommunityString *emi__SetAlertCommunityString, _emi__SetAlertCommunityStringResponse *emi__SetAlertCommunityStringResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetAlertCommunityString(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetAlertCommunityString *emi__GetAlertCommunityString, _emi__GetAlertCommunityStringResponse *emi__GetAlertCommunityStringResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__AddEventFilter(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__AddEventFilter *emi__AddEventFilter, _emi__AddEventFilterResponse *emi__AddEventFilterResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__SubscribeForAlert(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__SubscribeForAlert *emi__SubscribeForAlert, _emi__SubscribeForAlertResponse *emi__SubscribeForAlertResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateAlertSubscriptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateAlertSubscriptions *emi__EnumerateAlertSubscriptions, _emi__EnumerateAlertSubscriptionsResponse *emi__EnumerateAlertSubscriptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateAlertPolicies(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateAlertPolicies *emi__EnumerateAlertPolicies, _emi__EnumerateAlertPoliciesResponse *emi__EnumerateAlertPoliciesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__CancelAlertSubscription(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__CancelAlertSubscription *emi__CancelAlertSubscription, _emi__CancelAlertSubscriptionResponse *emi__CancelAlertSubscriptionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetEventFilter(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetEventFilter *emi__GetEventFilter, _emi__GetEventFilterResponse *emi__GetEventFilterResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__UpdateEventFilter(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__UpdateEventFilter *emi__UpdateEventFilter, _emi__UpdateEventFilterResponse *emi__UpdateEventFilterResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__RemoveEventFilter(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__RemoveEventFilter *emi__RemoveEventFilter, _emi__RemoveEventFilterResponse *emi__RemoveEventFilterResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetEventLogStatus(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetEventLogStatus *emi__GetEventLogStatus, _emi__GetEventLogStatusResponse *emi__GetEventLogStatusResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__ReadEventLogRecords(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__ReadEventLogRecords *emi__ReadEventLogRecords, _emi__ReadEventLogRecordsResponse *emi__ReadEventLogRecordsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__ClearEventLog(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__ClearEventLog *emi__ClearEventLog, _emi__ClearEventLogResponse *emi__ClearEventLogResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__FreezeEventLog(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__FreezeEventLog *emi__FreezeEventLog, _emi__FreezeEventLogResponse *emi__FreezeEventLogResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__SetEventLogTimestampClock(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__SetEventLogTimestampClock *emi__SetEventLogTimestampClock, _emi__SetEventLogTimestampClockResponse *emi__SetEventLogTimestampClockResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetEventLogTimestampClock(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetEventLogTimestampClock *emi__GetEventLogTimestampClock, _emi__GetEventLogTimestampClockResponse *emi__GetEventLogTimestampClockResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateSensors(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateSensors *emi__EnumerateSensors, _emi__EnumerateSensorsResponse *emi__EnumerateSensorsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetSensorAttributes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetSensorAttributes *emi__GetSensorAttributes, _emi__GetSensorAttributesResponse *emi__GetSensorAttributesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__SubscribeForGeneralAlert(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__SubscribeForGeneralAlert *emi__SubscribeForGeneralAlert, _emi__SubscribeForGeneralAlertResponse *emi__SubscribeForGeneralAlertResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateGeneralAlertSubscriptions *emi__EnumerateGeneralAlertSubscriptions, _emi__EnumerateGeneralAlertSubscriptionsResponse *emi__EnumerateGeneralAlertSubscriptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetGeneralAlertSubscription(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetGeneralAlertSubscription *emi__GetGeneralAlertSubscription, _emi__GetGeneralAlertSubscriptionResponse *emi__GetGeneralAlertSubscriptionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___hwa__EnumerateAssetTypes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _hwa__EnumerateAssetTypes *hwa__EnumerateAssetTypes, _hwa__EnumerateAssetTypesResponse *hwa__EnumerateAssetTypesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___hwa__GetAssetData(struct soap *soap, const char *soap_endpoint, const char *soap_action, _hwa__GetAssetData *hwa__GetAssetData, _hwa__GetAssetDataResponse *hwa__GetAssetDataResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___idr__SetRedirectionListenerState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _idr__SetRedirectionListenerState *idr__SetRedirectionListenerState, _idr__SetRedirectionListenerStateResponse *idr__SetRedirectionListenerStateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___idr__GetRedirectionListenerState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _idr__GetRedirectionListenerState *idr__GetRedirectionListenerState, _idr__GetRedirectionListenerStateResponse *idr__GetRedirectionListenerStateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___idr__GetIderSessionLog(struct soap *soap, const char *soap_endpoint, const char *soap_action, _idr__GetIderSessionLog *idr__GetIderSessionLog, _idr__GetIderSessionLogResponse *idr__GetIderSessionLogResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetCoreVersion(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetCoreVersion *inf__GetCoreVersion, _inf__GetCoreVersionResponse *inf__GetCoreVersionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetCodeVersions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetCodeVersions *inf__GetCodeVersions, _inf__GetCodeVersionsResponse *inf__GetCodeVersionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetProvisioningMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetProvisioningMode *inf__GetProvisioningMode, _inf__GetProvisioningModeResponse *inf__GetProvisioningModeResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetProvisioningState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetProvisioningState *inf__GetProvisioningState, _inf__GetProvisioningStateResponse *inf__GetProvisioningStateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetVlanParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetVlanParameters *inf__GetVlanParameters, _inf__GetVlanParametersResponse *inf__GetVlanParametersResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetHostName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetHostName *inf__GetHostName, _inf__GetHostNameResponse *inf__GetHostNameResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetConfigServerInfo(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetConfigServerInfo *inf__GetConfigServerInfo, _inf__GetConfigServerInfoResponse *inf__GetConfigServerInfoResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetAdminAclEntryStatus(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetAdminAclEntryStatus *inf__GetAdminAclEntryStatus, _inf__GetAdminAclEntryStatusResponse *inf__GetAdminAclEntryStatusResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetAdminNetAclEntryStatus(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetAdminNetAclEntryStatus *inf__GetAdminNetAclEntryStatus, _inf__GetAdminNetAclEntryStatusResponse *inf__GetAdminNetAclEntryStatusResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetPasswordModel(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetPasswordModel *inf__GetPasswordModel, _inf__GetPasswordModelResponse *inf__GetPasswordModelResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetEnabledInterfaces(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetEnabledInterfaces *inf__GetEnabledInterfaces, _inf__GetEnabledInterfacesResponse *inf__GetEnabledInterfacesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetNetworkState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetNetworkState *inf__GetNetworkState, _inf__GetNetworkStateResponse *inf__GetNetworkStateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetSecurityParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetSecurityParameters *inf__GetSecurityParameters, _inf__GetSecurityParametersResponse *inf__GetSecurityParametersResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetIderSessionLog(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetIderSessionLog *inf__GetIderSessionLog, _inf__GetIderSessionLogResponse *inf__GetIderSessionLogResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetHostName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetHostName *net__SetHostName, _net__SetHostNameResponse *net__SetHostNameResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetHostName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetHostName *net__GetHostName, _net__GetHostNameResponse *net__GetHostNameResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetDomainName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetDomainName *net__SetDomainName, _net__SetDomainNameResponse *net__SetDomainNameResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetDomainName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetDomainName *net__GetDomainName, _net__GetDomainNameResponse *net__GetDomainNameResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetTcpIpParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetTcpIpParameters *net__SetTcpIpParameters, _net__SetTcpIpParametersResponse *net__SetTcpIpParametersResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetTcpIpParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetTcpIpParameters *net__GetTcpIpParameters, _net__GetTcpIpParametersResponse *net__GetTcpIpParametersResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetVlanParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetVlanParameters *net__SetVlanParameters, _net__SetVlanParametersResponse *net__SetVlanParametersResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetVlanParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetVlanParameters *net__GetVlanParameters, _net__GetVlanParametersResponse *net__GetVlanParametersResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetPingResponse(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetPingResponse *net__SetPingResponse, _net__SetPingResponseResponse *net__SetPingResponseResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetPingResponse(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetPingResponse *net__GetPingResponse, _net__GetPingResponseResponse *net__GetPingResponseResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__EnumerateInterfaces(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__EnumerateInterfaces *net__EnumerateInterfaces, _net__EnumerateInterfacesResponse *net__EnumerateInterfacesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetInterfaceSettings(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetInterfaceSettings *net__GetInterfaceSettings, _net__GetInterfaceSettingsResponse *net__GetInterfaceSettingsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetInterfaceSettings(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetInterfaceSettings *net__SetInterfaceSettings, _net__SetInterfaceSettingsResponse *net__SetInterfaceSettingsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Set8021XWiredProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Set8021XWiredProfile *net__Set8021XWiredProfile, _net__Set8021XWiredProfileResponse *net__Set8021XWiredProfileResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Get8021XWiredProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Get8021XWiredProfile *net__Get8021XWiredProfile, _net__Get8021XWiredProfileResponse *net__Get8021XWiredProfileResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Set8021XActiveS0(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Set8021XActiveS0 *net__Set8021XActiveS0, _net__Set8021XActiveS0Response *net__Set8021XActiveS0Response); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Get8021XActiveS0(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Get8021XActiveS0 *net__Get8021XActiveS0, _net__Get8021XActiveS0Response *net__Get8021XActiveS0Response); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Set8021XPxeTimeout(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Set8021XPxeTimeout *net__Set8021XPxeTimeout, _net__Set8021XPxeTimeoutResponse *net__Set8021XPxeTimeoutResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Get8021XPxeTimeout(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Get8021XPxeTimeout *net__Get8021XPxeTimeout, _net__Get8021XPxeTimeoutResponse *net__Get8021XPxeTimeoutResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___rci__GetRemoteControlCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _rci__GetRemoteControlCapabilities *rci__GetRemoteControlCapabilities, _rci__GetRemoteControlCapabilitiesResponse *rci__GetRemoteControlCapabilitiesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___rci__RemoteControl(struct soap *soap, const char *soap_endpoint, const char *soap_action, _rci__RemoteControl *rci__RemoteControl, _rci__RemoteControlResponse *rci__RemoteControlResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___rci__GetSystemPowerState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _rci__GetSystemPowerState *rci__GetSystemPowerState, _rci__GetSystemPowerStateResponse *rci__GetSystemPowerStateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__ResetFlashWearOutProtection(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__ResetFlashWearOutProtection *sai__ResetFlashWearOutProtection, _sai__ResetFlashWearOutProtectionResponse *sai__ResetFlashWearOutProtectionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetAdminAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetAdminAclEntry *sai__GetAdminAclEntry, _sai__GetAdminAclEntryResponse *sai__GetAdminAclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetAdminAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetAdminAclEntry *sai__SetAdminAclEntry, _sai__SetAdminAclEntryResponse *sai__SetAdminAclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__AddUserAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__AddUserAclEntry *sai__AddUserAclEntry, _sai__AddUserAclEntryResponse *sai__AddUserAclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnumerateUserAclEntries(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnumerateUserAclEntries *sai__EnumerateUserAclEntries, _sai__EnumerateUserAclEntriesResponse *sai__EnumerateUserAclEntriesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetUserAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetUserAclEntry *sai__GetUserAclEntry, _sai__GetUserAclEntryResponse *sai__GetUserAclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__UpdateUserAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__UpdateUserAclEntry *sai__UpdateUserAclEntry, _sai__UpdateUserAclEntryResponse *sai__UpdateUserAclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__RemoveUserAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__RemoveUserAclEntry *sai__RemoveUserAclEntry, _sai__RemoveUserAclEntryResponse *sai__RemoveUserAclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTlsEnabled(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTlsEnabled *sai__SetTlsEnabled, _sai__SetTlsEnabledResponse *sai__SetTlsEnabledResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetRngKey(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetRngKey *sai__SetRngKey, _sai__SetRngKeyResponse *sai__SetRngKeyResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTLSKeyAndCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTLSKeyAndCertificate *sai__SetTLSKeyAndCertificate, _sai__SetTLSKeyAndCertificateResponse *sai__SetTLSKeyAndCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTLSCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTLSCertificate *sai__SetTLSCertificate, _sai__SetTLSCertificateResponse *sai__SetTLSCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTLSCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTLSCertificate *sai__GetTLSCertificate, _sai__GetTLSCertificateResponse *sai__GetTLSCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__UpdateCoreFromUrl(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__UpdateCoreFromUrl *sai__UpdateCoreFromUrl, _sai__UpdateCoreFromUrlResponse *sai__UpdateCoreFromUrlResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetProvisioningMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetProvisioningMode *sai__GetProvisioningMode, _sai__GetProvisioningModeResponse *sai__GetProvisioningModeResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetProvisioningMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetProvisioningMode *sai__SetProvisioningMode, _sai__SetProvisioningModeResponse *sai__SetProvisioningModeResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__Unprovision(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__Unprovision *sai__Unprovision, _sai__UnprovisionResponse *sai__UnprovisionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CommitChanges(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CommitChanges *sai__CommitChanges, _sai__CommitChangesResponse *sai__CommitChangesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetCoreVersion(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetCoreVersion *sai__GetCoreVersion, _sai__GetCoreVersionResponse *sai__GetCoreVersionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__AddUserAclEntryEx(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__AddUserAclEntryEx *sai__AddUserAclEntryEx, _sai__AddUserAclEntryExResponse *sai__AddUserAclEntryExResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetUserAclEntryEx(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetUserAclEntryEx *sai__GetUserAclEntryEx, _sai__GetUserAclEntryExResponse *sai__GetUserAclEntryExResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__UpdateUserAclEntryEx(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__UpdateUserAclEntryEx *sai__UpdateUserAclEntryEx, _sai__UpdateUserAclEntryExResponse *sai__UpdateUserAclEntryExResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetAdminAclEntryEx(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetAdminAclEntryEx *sai__SetAdminAclEntryEx, _sai__SetAdminAclEntryExResponse *sai__SetAdminAclEntryExResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetDigestRealm(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetDigestRealm *sai__GetDigestRealm, _sai__GetDigestRealmResponse *sai__GetDigestRealmResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetKerberosOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetKerberosOptions *sai__SetKerberosOptions, _sai__SetKerberosOptionsResponse *sai__SetKerberosOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetKerberosOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetKerberosOptions *sai__GetKerberosOptions, _sai__GetKerberosOptionsResponse *sai__GetKerberosOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetEnabledInterfaces(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetEnabledInterfaces *sai__SetEnabledInterfaces, _sai__SetEnabledInterfacesResponse *sai__SetEnabledInterfacesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetEnabledInterfaces(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetEnabledInterfaces *sai__GetEnabledInterfaces, _sai__GetEnabledInterfacesResponse *sai__GetEnabledInterfacesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTlsOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTlsOptions *sai__SetTlsOptions, _sai__SetTlsOptionsResponse *sai__SetTlsOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTlsOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTlsOptions *sai__GetTlsOptions, _sai__GetTlsOptionsResponse *sai__GetTlsOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__AddTrustedRootCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__AddTrustedRootCertificate *sai__AddTrustedRootCertificate, _sai__AddTrustedRootCertificateResponse *sai__AddTrustedRootCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTrustedRootCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTrustedRootCertificate *sai__GetTrustedRootCertificate, _sai__GetTrustedRootCertificateResponse *sai__GetTrustedRootCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__DeleteTrustedRootCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__DeleteTrustedRootCertificate *sai__DeleteTrustedRootCertificate, _sai__DeleteTrustedRootCertificateResponse *sai__DeleteTrustedRootCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnumerateTrustedRootCertificates(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnumerateTrustedRootCertificates *sai__EnumerateTrustedRootCertificates, _sai__EnumerateTrustedRootCertificatesResponse *sai__EnumerateTrustedRootCertificatesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTrustedFqdnCN(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTrustedFqdnCN *sai__SetTrustedFqdnCN, _sai__SetTrustedFqdnCNResponse *sai__SetTrustedFqdnCNResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTrustedFqdnCN(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTrustedFqdnCN *sai__GetTrustedFqdnCN, _sai__GetTrustedFqdnCNResponse *sai__GetTrustedFqdnCNResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetCRL(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetCRL *sai__SetCRL, _sai__SetCRLResponse *sai__SetCRLResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetCRL(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetCRL *sai__GetCRL, _sai__GetCRLResponse *sai__GetCRLResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetServerCertificateReq(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetServerCertificateReq *sai__GetServerCertificateReq, _sai__GetServerCertificateReqResponse *sai__GetServerCertificateReqResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetPkiCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetPkiCapabilities *sai__GetPkiCapabilities, _sai__GetPkiCapabilitiesResponse *sai__GetPkiCapabilitiesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetPowerSavingOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetPowerSavingOptions *sai__SetPowerSavingOptions, _sai__SetPowerSavingOptionsResponse *sai__SetPowerSavingOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetPowerSavingOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetPowerSavingOptions *sai__GetPowerSavingOptions, _sai__GetPowerSavingOptionsResponse *sai__GetPowerSavingOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTLSPSK(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTLSPSK *sai__SetTLSPSK, _sai__SetTLSPSKResponse *sai__SetTLSPSKResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__PartialUnprovision(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__PartialUnprovision *sai__PartialUnprovision, _sai__PartialUnprovisionResponse *sai__PartialUnprovisionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetMEBxPassword(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetMEBxPassword *sai__SetMEBxPassword, _sai__SetMEBxPasswordResponse *sai__SetMEBxPasswordResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetProvisioningServerOTP(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetProvisioningServerOTP *sai__SetProvisioningServerOTP, _sai__SetProvisioningServerOTPResponse *sai__SetProvisioningServerOTPResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetProvisioningServerOTP(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetProvisioningServerOTP *sai__GetProvisioningServerOTP, _sai__GetProvisioningServerOTPResponse *sai__GetProvisioningServerOTPResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnumerateCertificateHashEntries(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnumerateCertificateHashEntries *sai__EnumerateCertificateHashEntries, _sai__EnumerateCertificateHashEntriesResponse *sai__EnumerateCertificateHashEntriesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetCertificateHashEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetCertificateHashEntry *sai__GetCertificateHashEntry, _sai__GetCertificateHashEntryResponse *sai__GetCertificateHashEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__AddCertificateHashEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__AddCertificateHashEntry *sai__AddCertificateHashEntry, _sai__AddCertificateHashEntryResponse *sai__AddCertificateHashEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__DeleteCertificateHashEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__DeleteCertificateHashEntry *sai__DeleteCertificateHashEntry, _sai__DeleteCertificateHashEntryResponse *sai__DeleteCertificateHashEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnableCertificateHashEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnableCertificateHashEntry *sai__EnableCertificateHashEntry, _sai__EnableCertificateHashEntryResponse *sai__EnableCertificateHashEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetZeroTouchConfigurationMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetZeroTouchConfigurationMode *sai__GetZeroTouchConfigurationMode, _sai__GetZeroTouchConfigurationModeResponse *sai__GetZeroTouchConfigurationModeResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetZeroTouchConfigurationMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetZeroTouchConfigurationMode *sai__SetZeroTouchConfigurationMode, _sai__SetZeroTouchConfigurationModeResponse *sai__SetZeroTouchConfigurationModeResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetProvisioningAuditRecord(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetProvisioningAuditRecord *sai__GetProvisioningAuditRecord, _sai__GetProvisioningAuditRecordResponse *sai__GetProvisioningAuditRecordResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetProvisioningPID(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetProvisioningPID *sai__GetProvisioningPID, _sai__GetProvisioningPIDResponse *sai__GetProvisioningPIDResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__ExtendProvisioningPeriod(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__ExtendProvisioningPeriod *sai__ExtendProvisioningPeriod, _sai__ExtendProvisioningPeriodResponse *sai__ExtendProvisioningPeriodResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetRealmAuthOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetRealmAuthOptions *sai__GetRealmAuthOptions, _sai__GetRealmAuthOptionsResponse *sai__GetRealmAuthOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetRealmAuthOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetRealmAuthOptions *sai__SetRealmAuthOptions, _sai__SetRealmAuthOptionsResponse *sai__SetRealmAuthOptionsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetEnvironmentDetection(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetEnvironmentDetection *sai__SetEnvironmentDetection, _sai__SetEnvironmentDetectionResponse *sai__SetEnvironmentDetectionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetEnvironmentDetection(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetEnvironmentDetection *sai__GetEnvironmentDetection, _sai__GetEnvironmentDetectionResponse *sai__GetEnvironmentDetectionResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnumeratePowerPackages(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnumeratePowerPackages *sai__EnumeratePowerPackages, _sai__EnumeratePowerPackagesResponse *sai__EnumeratePowerPackagesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetPowerPackage(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetPowerPackage *sai__GetPowerPackage, _sai__GetPowerPackageResponse *sai__GetPowerPackageResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetActivePowerPackage(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetActivePowerPackage *sai__GetActivePowerPackage, _sai__GetActivePowerPackageResponse *sai__GetActivePowerPackageResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetActivePowerPackage(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetActivePowerPackage *sai__SetActivePowerPackage, _sai__SetActivePowerPackageResponse *sai__SetActivePowerPackageResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetGlobalPowerPolicy(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetGlobalPowerPolicy *sai__SetGlobalPowerPolicy, _sai__SetGlobalPowerPolicyResponse *sai__SetGlobalPowerPolicyResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetGlobalPowerPolicy(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetGlobalPowerPolicy *sai__GetGlobalPowerPolicy, _sai__GetGlobalPowerPolicyResponse *sai__GetGlobalPowerPolicyResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreAddKey(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreAddKey *sai__CertStoreAddKey, _sai__CertStoreAddKeyResponse *sai__CertStoreAddKeyResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreEnumerateKeys(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreEnumerateKeys *sai__CertStoreEnumerateKeys, _sai__CertStoreEnumerateKeysResponse *sai__CertStoreEnumerateKeysResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreGetKey(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreGetKey *sai__CertStoreGetKey, _sai__CertStoreGetKeyResponse *sai__CertStoreGetKeyResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreRemoveKey(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreRemoveKey *sai__CertStoreRemoveKey, _sai__CertStoreRemoveKeyResponse *sai__CertStoreRemoveKeyResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreAddCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreAddCertificate *sai__CertStoreAddCertificate, _sai__CertStoreAddCertificateResponse *sai__CertStoreAddCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreGetCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreGetCertificate *sai__CertStoreGetCertificate, _sai__CertStoreGetCertificateResponse *sai__CertStoreGetCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreEnumerateCertificates(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreEnumerateCertificates *sai__CertStoreEnumerateCertificates, _sai__CertStoreEnumerateCertificatesResponse *sai__CertStoreEnumerateCertificatesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreRemoveCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreRemoveCertificate *sai__CertStoreRemoveCertificate, _sai__CertStoreRemoveCertificateResponse *sai__CertStoreRemoveCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreGetPKCS10Request(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreGetPKCS10Request *sai__CertStoreGetPKCS10Request, _sai__CertStoreGetPKCS10RequestResponse *sai__CertStoreGetPKCS10RequestResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreUpdateCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreUpdateCertificate *sai__CertStoreUpdateCertificate, _sai__CertStoreUpdateCertificateResponse *sai__CertStoreUpdateCertificateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTLSCredentials(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTLSCredentials *sai__SetTLSCredentials, _sai__SetTLSCredentialsResponse *sai__SetTLSCredentialsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTLSCredentials(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTLSCredentials *sai__GetTLSCredentials, _sai__GetTLSCredentialsResponse *sai__GetTLSCredentialsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnableVpnRouting(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnableVpnRouting *sai__EnableVpnRouting, _sai__EnableVpnRoutingResponse *sai__EnableVpnRoutingResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetConfigurationServerFQDN(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetConfigurationServerFQDN *sai__GetConfigurationServerFQDN, _sai__GetConfigurationServerFQDNResponse *sai__GetConfigurationServerFQDNResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetConfigurationServerFQDN(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetConfigurationServerFQDN *sai__SetConfigurationServerFQDN, _sai__SetConfigurationServerFQDNResponse *sai__SetConfigurationServerFQDNResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetAclEnabledState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetAclEnabledState *sai__SetAclEnabledState, _sai__SetAclEnabledStateResponse *sai__SetAclEnabledStateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetAclEnabledState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetAclEnabledState *sai__GetAclEnabledState, _sai__GetAclEnabledStateResponse *sai__GetAclEnabledStateResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___str__ExecuteStorageOperation(struct soap *soap, const char *soap_endpoint, const char *soap_action, _str__ExecuteStorageOperation *str__ExecuteStorageOperation, _str__ExecuteStorageOperationResponse *str__ExecuteStorageOperationResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__GetGlobalStorageAttributes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__GetGlobalStorageAttributes *stra__GetGlobalStorageAttributes, _stra__GetGlobalStorageAttributesResponse *stra__GetGlobalStorageAttributesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__SetGlobalStorageAttributes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__SetGlobalStorageAttributes *stra__SetGlobalStorageAttributes, _stra__SetGlobalStorageAttributesResponse *stra__SetGlobalStorageAttributesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AdminGetRegisteredApplications(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AdminGetRegisteredApplications *stra__AdminGetRegisteredApplications, _stra__AdminGetRegisteredApplicationsResponse *stra__AdminGetRegisteredApplicationsResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AdminGetApplicationAttributes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AdminGetApplicationAttributes *stra__AdminGetApplicationAttributes, _stra__AdminGetApplicationAttributesResponse *stra__AdminGetApplicationAttributesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AdminRemoveApplication(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AdminRemoveApplication *stra__AdminRemoveApplication, _stra__AdminRemoveApplicationResponse *stra__AdminRemoveApplicationResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AddStorageEaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AddStorageEaclEntry *stra__AddStorageEaclEntry, _stra__AddStorageEaclEntryResponse *stra__AddStorageEaclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__EnumerateStorageEaclEntries(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__EnumerateStorageEaclEntries *stra__EnumerateStorageEaclEntries, _stra__EnumerateStorageEaclEntriesResponse *stra__EnumerateStorageEaclEntriesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__GetStorageEaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__GetStorageEaclEntry *stra__GetStorageEaclEntry, _stra__GetStorageEaclEntryResponse *stra__GetStorageEaclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__RemoveStorageEaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__RemoveStorageEaclEntry *stra__RemoveStorageEaclEntry, _stra__RemoveStorageEaclEntryResponse *stra__RemoveStorageEaclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AddStorageFpaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AddStorageFpaclEntry *stra__AddStorageFpaclEntry, _stra__AddStorageFpaclEntryResponse *stra__AddStorageFpaclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__EnumerateStorageAllocEntries(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__EnumerateStorageAllocEntries *stra__EnumerateStorageAllocEntries, _stra__EnumerateStorageAllocEntriesResponse *stra__EnumerateStorageAllocEntriesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__GetStorageAllocEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__GetStorageAllocEntry *stra__GetStorageAllocEntry, _stra__GetStorageAllocEntryResponse *stra__GetStorageAllocEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__UpdateStorageFpaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__UpdateStorageFpaclEntry *stra__UpdateStorageFpaclEntry, _stra__UpdateStorageFpaclEntryResponse *stra__UpdateStorageFpaclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__RemoveStorageFpaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__RemoveStorageFpaclEntry *stra__RemoveStorageFpaclEntry, _stra__RemoveStorageFpaclEntryResponse *stra__RemoveStorageFpaclEntryResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___tim__GetLowAccuracyTimeSynch(struct soap *soap, const char *soap_endpoint, const char *soap_action, _tim__GetLowAccuracyTimeSynch *tim__GetLowAccuracyTimeSynch, _tim__GetLowAccuracyTimeSynchResponse *tim__GetLowAccuracyTimeSynchResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___tim__SetHighAccuracyTimeSynch(struct soap *soap, const char *soap_endpoint, const char *soap_action, _tim__SetHighAccuracyTimeSynch *tim__SetHighAccuracyTimeSynch, _tim__SetHighAccuracyTimeSynchResponse *tim__SetHighAccuracyTimeSynchResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__AddWirelessProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__AddWirelessProfileRequest *wcxs__AddWirelessProfileRequest, _wcxs__AddWirelessProfileResponse *wcxs__AddWirelessProfileResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__GetWirelessProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__GetWirelessProfileRequest *wcxs__GetWirelessProfileRequest, _wcxs__GetWirelessProfileResponse *wcxs__GetWirelessProfileResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__RemoveWirelessProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__RemoveWirelessProfileRequest *wcxs__RemoveWirelessProfileRequest, _wcxs__RemoveWirelessProfileResponse *wcxs__RemoveWirelessProfileResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__UpdateWirelessProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__UpdateWirelessProfileRequest *wcxs__UpdateWirelessProfileRequest, _wcxs__UpdateWirelessProfileResponse *wcxs__UpdateWirelessProfileResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__EnumerateWirelessProfiles(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__EnumerateWirelessProfilesRequest *wcxs__EnumerateWirelessProfilesRequest, _wcxs__EnumerateWirelessProfilesResponse *wcxs__EnumerateWirelessProfilesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__GetWirelessCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__GetWirelessCapabilitiesRequest *wcxs__GetWirelessCapabilitiesRequest, _wcxs__GetWirelessCapabilitiesResponse *wcxs__GetWirelessCapabilitiesResponse); + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__GetWirelessSettings(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__GetWirelessSettingsRequest *wcxs__GetWirelessSettingsRequest, _wcxs__GetWirelessSettingsResponse *wcxs__GetWirelessSettingsResponse); + +#endif + +/* End of soapStub.h */ diff --git a/pcucontrol/models/intelamt/Include/stdsoap2.h b/pcucontrol/models/intelamt/Include/stdsoap2.h new file mode 100644 index 0000000..76a1ce5 --- /dev/null +++ b/pcucontrol/models/intelamt/Include/stdsoap2.h @@ -0,0 +1,2153 @@ +/* + +stdsoap2.h 2.7.8c + +gSOAP runtime + +gSOAP XML Web services tools +Copyright (C) 2000-2006, Robert van Engelen, Genivia Inc., All Rights Reserved. +This part of the software is released under one of the following licenses: +GPL, the gSOAP public license, or Genivia's license for commercial use. +-------------------------------------------------------------------------------- +Contributors: + +Wind River Systems, Inc., for the following additions (marked WR[...]): + - vxWorks compatible +-------------------------------------------------------------------------------- +gSOAP public license. + +The contents of this file are subject to the gSOAP Public License Version 1.3 +(the "License"); you may not use this file except in compliance with the +License. You may obtain a copy of the License at +http://www.cs.fsu.edu/~engelen/soaplicense.html +Software distributed under the License is distributed on an "AS IS" basis, +WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +for the specific language governing rights and limitations under the License. + +The Initial Developer of the Original Code is Robert A. van Engelen. +Copyright (C) 2000-2006, Robert van Engelen, Genivia Inc., All Rights Reserved. +-------------------------------------------------------------------------------- +GPL license. + +This program is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free Software +Foundation; either version 2 of the License, or (at your option) any later +version. + +This program is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with +this program; if not, write to the Free Software Foundation, Inc., 59 Temple +Place, Suite 330, Boston, MA 02111-1307 USA + +Author contact information: +engelen@genivia.com / engelen@acm.org +-------------------------------------------------------------------------------- +A commercial use license is available from Genivia, Inc., contact@genivia.com +-------------------------------------------------------------------------------- +*/ + +#ifdef WITH_SOAPDEFS_H +# include "soapdefs.h" /* include user-defined stuff */ +#endif + +#ifndef _THREAD_SAFE +# define _THREAD_SAFE +#endif + +#ifndef OPENSERVER +# ifndef _REENTRANT +# define _REENTRANT +# endif +#endif + +#ifndef SOAP_FMAC1 /* stdsoap2.h declaration macro */ +# define SOAP_FMAC1 +#endif + +#ifndef SOAP_FMAC2 /* stdsoap2.h declaration macro */ +# define SOAP_FMAC2 +#endif + +#ifndef SOAP_FMAC3 /* (de)serializer declaration macro */ +# define SOAP_FMAC3 +#endif + +#ifndef SOAP_FMAC3S /* string converter for (de)serializer declaration macro */ +# define SOAP_FMAC3S SOAP_FMAC3 +#endif + +#ifndef SOAP_FMAC4 /* (de)serializer declaration macro */ +# define SOAP_FMAC4 +#endif + +#ifndef SOAP_FMAC4S /* string converter for (de)serializer declaration macro */ +# define SOAP_FMAC4S SOAP_FMAC4 +#endif + +#ifndef SOAP_FMAC5 /* stub/skeleton declaration macro */ +# define SOAP_FMAC5 +#endif + +#ifndef SOAP_FMAC6 /* stub/skeleton declaration macro */ +# define SOAP_FMAC6 +#endif + +#ifndef SOAP_CMAC /* class declaration macro */ +# define SOAP_CMAC +#endif + +#ifndef SOAP_NMAC /* namespace table declaration macro */ +# define SOAP_NMAC +#endif + +#ifndef SOAP_SOURCE_STAMP +# define SOAP_SOURCE_STAMP(str) +#endif + +/* gSOAP 2.7.4 and higher: fast look-aside buffering is stable */ +#ifndef WITH_FAST +# define WITH_FAST +#endif + +#ifdef WITH_LEANER +# ifndef WITH_LEAN +# define WITH_LEAN +# endif +#endif + +#ifdef WITH_LEAN +# ifdef WITH_COOKIES +# error "Cannot build WITH_LEAN code WITH_COOKIES enabled" +# endif +#endif + +#ifndef STDSOAP_H +#define STDSOAP_H + +#if defined(__vxworks) || defined(__VXWORKS__) +# define VXWORKS +#endif + +#ifdef _WIN32 +# ifndef WIN32 +# define WIN32 +# endif +#endif + +#ifdef UNDER_CE +# ifndef WIN32 +# define WIN32 +# endif +#endif + +#ifdef __BORLANDC__ +# ifdef __WIN32__ +# ifndef WIN32 +# define WIN32 +# endif +# endif +#endif + +#ifdef __CYGWIN__ +# ifndef CYGWIN +# define CYGWIN +# endif +#endif + +#ifdef __SYMBIAN32__ +# define SYMBIAN +# undef WIN32 +#endif + +#if defined(__palmos__) || defined(PALM_GCC) || defined(__PALMOS_TRAPS__) +# ifndef PALM +# define PALM +# endif +#endif + +#if defined(__hpux) +# ifndef HP_UX +# define HP_UX +# endif +#endif + +#if defined(__alpha) && !defined(__VMS) +# ifndef TRU64 +# define TRU64 +# endif +#endif + +#ifdef __MVS__ +# ifndef OS390 +# define OS390 +# endif +#endif + +#ifdef HAVE_CONFIG_H +# include "config.h" +# ifdef WITH_OPENSSL +# ifndef HAVE_OPENSSL_SSL_H +# undef WITH_OPENSSL +# endif +# endif +#else +# if defined(UNDER_CE) +# define WITH_LEAN +# define HAVE_SSCANF +# elif defined(WIN32) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# define SOAP_LONG_FORMAT "%I64d" +# define SOAP_ULONG_FORMAT "%I64u" +# elif defined(CYGWIN) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# elif defined(__APPLE__) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_TIMEGM +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# elif defined(_AIXVERSION_431) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# elif defined(HP_UX) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# elif defined(FREEBSD) || defined(__FreeBSD__) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_STRTOLL +# define HAVE_STRTOULL +# define HAVE_GETTIMEOFDAY +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# define SOAP_LONG_FORMAT "%qd" +# define SOAP_ULONG_FORMAT "%qu" +# elif defined(__VMS) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# elif defined(__GLIBC__) || defined(__GNU__) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_STRTOLL +# define HAVE_STRTOULL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_TIMEGM +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# define HAVE_ISNAN +# elif defined(TRU64) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_GETTIMEOFDAY +# define HAVE_SYS_TIMEB_H +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define __USE_STD_IOSTREAM +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# define SOAP_LONG_FORMAT "%ld" +# define SOAP_ULONG_FORMAT "%lu" +# elif defined(MAC_CARBON) +# define WITH_NOIO +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GETHOSTBYNAME_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# elif defined(PALM) +# define WITH_LEAN +# define HAVE_STRTOD /* strtod() is defined in palmFunctions.h */ +# include /* Needs to be included before unix headers */ +# include +# define IGNORE_STDIO_STUBS +# include +# define O_NONBLOCK FNONBIO +# include +# include "palmFunctions.h" +# elif defined(SYMBIAN) +# define WITH_LEAN +# define WITH_NONAMESPACES +# define HAVE_STRTOD /* use STRTOD since sscanf doesn't seem to work */ +# include +# include +# elif defined(VXWORKS) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_PGMTIME_R +# define HAVE_PLOCALTIME_R +# define HAVE_MKTIME +# elif defined(OS390) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# elif defined(AS400) +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# elif defined(__QNX__) || defined(QNX) +/* QNX does not have a working version of strtof */ +# undef HAVE_STRTOF +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GETHOSTBYNAME_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# define LONG64 long +# define ULONG64 unsigned LONG64 +# define SOAP_LONG_FORMAT "%ld" +# define SOAP_ULONG_FORMAT "%lu" +# else +/* Default asumptions on supported functions */ +# define HAVE_STRRCHR +# define HAVE_STRTOD +# define HAVE_SSCANF +# define HAVE_STRTOL +# define HAVE_STRTOUL +# define HAVE_SYS_TIMEB_H +# define HAVE_FTIME +# define HAVE_RAND_R +# define HAVE_GETHOSTBYNAME_R +# define HAVE_GMTIME_R +# define HAVE_LOCALTIME_R +# define HAVE_WCTOMB +# define HAVE_MBTOWC +# endif +#endif + +#ifndef SOAP_LONG_FORMAT +# define SOAP_LONG_FORMAT "%lld" /* printf format for 64 bit ints */ +#endif + +#ifndef SOAP_ULONG_FORMAT +# define SOAP_ULONG_FORMAT "%llu" /* printf format for unsigned 64 bit ints */ +#endif + +#ifndef WITH_NOSTDLIB +# include +# ifndef PALM +# include +# include +# endif +# include +# include +#endif + +#if defined(__cplusplus) && !defined(WITH_LEAN) +# include +# include +#endif + +#ifdef WITH_NOHTTP +# ifndef WITH_NOIO +# define WITH_NOIO +# undef WITH_COOKIES +# endif +#endif + +#ifndef UNDER_CE +# ifndef PALM +# ifndef WITH_NOIO +# include +# include +# endif +# ifndef WITH_LEAN +# ifdef HAVE_SYS_TIMEB_H +# include /* for ftime() */ +# endif +# include +# endif +# endif +#endif + +#ifdef OPENSERVER +# include +# include +# include + extern int h_errno; +#endif + +#ifndef WITH_NOIO +# ifndef WIN32 +# ifndef PALM +# include +# ifdef VXWORKS +# include +# include +# endif +# ifndef VXWORKS +# ifndef SYMBIAN +# include +# endif +# endif +# ifdef SUN_OS +# include /* SUN */ +# include /* SUN < 2.8 (?) */ +# endif +# ifdef VXWORKS +# ifdef _WRS_KERNEL +# include +# endif +# else +# include +# endif +# include +# ifdef OS390 +# include +# else +# include /* TCP_NODELAY */ +# endif +# include +# endif +# endif +#endif + +#ifdef WITH_FASTCGI +# include +#endif + +#ifdef WITH_OPENSSL +# define OPENSSL_NO_KRB5 +# include +# include +# include +# include +# include +# ifndef ALLOW_OLD_VERSIONS +# if (OPENSSL_VERSION_NUMBER < 0x00905100L) +# error "Must use OpenSSL 0.9.6 or later" +# endif +# endif +#endif + +#ifdef WITH_GZIP +# ifndef WITH_ZLIB +# define WITH_ZLIB +# endif +#endif + +#ifdef WITH_CASEINSENSITIVETAGS +# define SOAP_STRCMP soap_tag_cmp /* case insensitve XML element/attribute names */ +#else +# define SOAP_STRCMP strcmp /* case sensitive XML element/attribute names */ +#endif + +#ifdef WITH_ZLIB +# include +#endif + +#ifndef WITH_NOSTDLIB +# ifndef PALM +# include /* for isnan() */ +# endif +#endif + +/* #define DEBUG */ /* Uncomment to debug sending (in file SENT.log) receiving (in file RECV.log) and messages (in file TEST.log) */ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef WIN32 +# ifndef UNDER_CE +# include +# include +# endif + +/* Modified by Intel Corporation to allow using winsock2.h */ +# ifdef USE_WINSOCK2 +# include +# else +# include +# endif + +# ifdef WITH_IPV6 +# include +# include +# endif +#else +# ifdef VXWORKS +# include +# include +# include +# endif +# ifndef WITH_NOIO +# ifndef PALM +# include +# include +# include +# include +# endif +# endif +#endif + +/* Portability: define SOAP_SOCKLEN_T */ +#if defined(_AIX) +# define SOAP_SOCKLEN_T socklen_t +#elif defined(SOCKLEN_T) +# define SOAP_SOCKLEN_T SOCKLEN_T +#elif defined(__socklen_t_defined) || defined(_SOCKLEN_T) || defined(CYGWIN) || defined(FREEBSD) || defined(__FreeBSD__) || defined(__QNX__) || defined(QNX) +# define SOAP_SOCKLEN_T socklen_t +#elif defined(IRIX) || defined(WIN32) || defined(__APPLE__) || defined(HP_UX) || defined(SUN_OS) || defined(OPENSERVER) || defined(TRU64) || defined(VXWORKS) +# define SOAP_SOCKLEN_T int +#else +# define SOAP_SOCKLEN_T size_t +#endif + +#ifndef SOAP_SOCKET +# ifdef WIN32 +# define SOAP_SOCKET SOCKET +# define soap_closesocket(n) closesocket(n) +# else +# define SOAP_SOCKET int +# define soap_closesocket(n) close(n) +# endif +#endif + +#define SOAP_INVALID_SOCKET (-1) +#define soap_valid_socket(n) ((n) != SOAP_INVALID_SOCKET) + +#ifndef FD_SETSIZE +# define FD_SETSIZE (1024) +#endif + +#if defined(SYMBIAN) +# define LONG64 long +# define ULONG64 unsigned LONG64 +#elif !defined(WIN32) || defined(CYGWIN) || defined(__GLIBC__) || defined(__GNU__) +# ifndef LONG64 +# define LONG64 long long +# define ULONG64 unsigned LONG64 +# endif +#elif defined(UNDER_CE) +# define LONG64 __int64 +# define ULONG64 unsigned LONG64 +#elif defined(__BORLANDC__) +# define LONG64 __int64 +# define ULONG64 unsigned LONG64 +#endif + +#if defined(WIN32) && !defined(CYGWIN) +# define soap_int32 __int32 +#elif defined(SYMBIAN) +# define soap_int32 long +#elif defined(PALM) +# define soap_int32 Int32 +#else +# define soap_int32 int32_t +#endif + +#ifdef WIN32 +# define SOAP_ERANGE ERANGE +# define SOAP_EINTR WSAEINTR +# define SOAP_EAGAIN WSAEWOULDBLOCK +# define SOAP_EWOULDBLOCK WSAEWOULDBLOCK +# define SOAP_EINPROGRESS WSAEINPROGRESS +#else +# define SOAP_ERANGE ERANGE +# define SOAP_EINTR EINTR +# define SOAP_EAGAIN EAGAIN +# ifdef SYMBIAN +# define SOAP_EWOULDBLOCK 9898 +# define SOAP_EINPROGRESS 9899 +# else +# define SOAP_EWOULDBLOCK EWOULDBLOCK +# define SOAP_EINPROGRESS EINPROGRESS +# endif +#endif + +#ifdef WIN32 +# ifdef UNDER_CE +# define soap_errno GetLastError() +# define soap_socket_errno GetLastError() +# define soap_reset_errno SetLastError(0) +# else +# define soap_errno GetLastError() +# define soap_socket_errno WSAGetLastError() +# define soap_reset_errno SetLastError(0) +# endif +#else +# ifndef WITH_NOIO +# define soap_errno errno +# define soap_socket_errno errno +# define soap_reset_errno (errno = 0) +# else +# define soap_errno 0 +# define soap_socket_errno 0 +# define soap_reset_errno +# endif +#endif + +#ifndef SOAP_BUFLEN +# ifdef WITH_UDP +# define SOAP_BUFLEN (65536) /* max UDP packet size */ +# else +# ifndef WITH_LEAN +# define SOAP_BUFLEN (65536) /* buffer length for socket packets, also used by gethostbyname_r so don't make this too small */ +# else +# define SOAP_BUFLEN (2048) +# endif +# endif +#endif +#ifndef SOAP_LABLEN +# define SOAP_LABLEN (64) /* initial look-aside buffer length */ +#endif +#ifndef SOAP_PTRBLK +# define SOAP_PTRBLK (32) /* block allocation for pointer hash table chains */ +#endif +#ifndef SOAP_PTRHASH +# ifndef WITH_LEAN +# define SOAP_PTRHASH (1024) /* size of pointer analysis hash table (must be power of 2) */ +# else +# define SOAP_PTRHASH (32) +# endif +#endif +#ifndef SOAP_IDHASH +# ifndef WITH_LEAN +# define SOAP_IDHASH (1999) /* prime size of hash table for parsed id/ref */ +# else +# define SOAP_IDHASH (19) /* 19, 199 */ +# endif +#endif +#ifndef SOAP_BLKLEN +# ifndef WITH_LEAN +# define SOAP_BLKLEN (256) /* size of blocks to collect long strings and XML attributes */ +# else +# define SOAP_BLKLEN (32) +# endif +#endif +#ifndef SOAP_TAGLEN +# ifndef WITH_LEAN +# define SOAP_TAGLEN (1024) /* maximum length of XML element tag/attribute name or host/path name + 1 */ +# else +# define SOAP_TAGLEN (64) +# endif +#endif +#ifndef SOAP_HDRLEN +# ifndef WITH_LEAN +# define SOAP_HDRLEN (8192) /* maximum length of HTTP header line (must be >4096 to read cookies) */ +# else +# define SOAP_HDRLEN (1024) +# endif +#endif +#ifndef SOAP_MAXDIMS +# ifndef WITH_LEAN +# define SOAP_MAXDIMS (16) /* maximum array dimensions (array nestings) must be less than 64 to protect soap->tmpbuf */ +# else +# define SOAP_MAXDIMS (4) +# endif +#endif + +#ifndef SOAP_MAXLOGS +# define SOAP_MAXLOGS (3) /* max number of debug logs per struct soap environment */ +# define SOAP_INDEX_RECV (0) +# define SOAP_INDEX_SENT (1) +# define SOAP_INDEX_TEST (2) +#endif + +#ifndef SOAP_MAXKEEPALIVE +# define SOAP_MAXKEEPALIVE (100) /* max iterations to keep server connection alive */ +#endif + +#ifndef SOAP_MAXARRAYSIZE +# define SOAP_MAXARRAYSIZE (100000) /* "trusted" max size of inbound SOAP array for compound array allocation */ +#endif + +#ifdef VXWORKS +# ifdef __INCmathh +# include +# ifndef HAVE_ISNAN +# define HAVE_ISNAN +# endif +# define soap_isnan(num) isNan(num) +# endif +#endif + +#ifdef WIN32 +# include +# ifndef HAVE_ISNAN +# define HAVE_ISNAN +# endif +# define soap_isnan(num) _isnan(num) +#endif + +#ifdef SUN_OS +# define HAVE_ISNAN +#endif + +#ifdef __APPLE__ +# ifdef __cplusplus +# ifndef isnan +extern "C" int isnan(double); +# endif +# endif +# define HAVE_ISNAN +#endif + +#if !defined(HAVE_ISNAN) && (defined(_MATH_H) || defined(_MATH_INCLUDED)) +# define HAVE_ISNAN +#endif + +extern const struct soap_double_nan { unsigned int n1, n2; } soap_double_nan; + +#ifdef VXWORKS +# ifndef FLT_MAX +# define FLT_MAX _ARCH_FLT_MAX +# endif +# ifndef DBL_MAX +# define DBL_MAX _ARCH_DBL_MAX +# endif +#endif + +#ifndef FLT_NAN +# define FLT_NAN (*(float*)(void*)&soap_double_nan) +#endif + +#ifndef FLT_PINFTY +# if defined(FLT_MAX) +# define FLT_PINFTY FLT_MAX +# elif defined(HUGE_VALF) +# define FLT_PINFTY (float)HUGE_VALF +# elif defined(HUGE_VAL) +# define FLT_PINFTY (float)HUGE_VAL +# elif defined(FLOAT_MAX) +# define FLT_PINFTY FLOAT_MAX +# else +# define FLT_PINFTY (3.40282347e+38F) +# endif +#endif + +#ifndef FLT_NINFTY +# define FLT_NINFTY (-FLT_PINFTY) +#endif + +#ifndef DBL_NAN +# define DBL_NAN (*(double*)(void*)&soap_double_nan) +#endif + +#ifndef DBL_PINFTY +# if defined(DBL_MAX) +# define DBL_PINFTY DBL_MAX +# elif defined(HUGE_VALF) +# define DBL_PINFTY (double)HUGE_VALF +# elif defined(HUGE_VAL) +# define DBL_PINFTY (double)HUGE_VAL +# elif defined(DOUBLE_MAX) +# define DBL_PINFTY DOUBLE_MAX +# else +# define DBL_PINFTY (1.7976931348623157e+308) +# endif +#endif + +#ifndef DBL_NINFTY +# define DBL_NINFTY (-DBL_PINFTY) +#endif + +#ifndef soap_isnan +# ifdef HAVE_ISNAN +# define soap_isnan(n) isnan(n) +# else +# define soap_isnan(n) (0) +# endif +#endif + +#define soap_ispinfd(n) ((n) >= DBL_PINFTY) +#define soap_ispinff(n) ((n) >= FLT_PINFTY) +#define soap_isninfd(n) ((n) <= DBL_NINFTY) +#define soap_isninff(n) ((n) <= FLT_NINFTY) + +/* gSOAP error codes */ + +#define SOAP_EOF EOF +#define SOAP_ERR EOF +#define SOAP_OK 0 +#define SOAP_CLI_FAULT 1 +#define SOAP_SVR_FAULT 2 +#define SOAP_TAG_MISMATCH 3 +#define SOAP_TYPE 4 +#define SOAP_SYNTAX_ERROR 5 +#define SOAP_NO_TAG 6 +#define SOAP_IOB 7 +#define SOAP_MUSTUNDERSTAND 8 +#define SOAP_NAMESPACE 9 +#define SOAP_USER_ERROR 10 +#define SOAP_FATAL_ERROR 11 +#define SOAP_FAULT 12 +#define SOAP_NO_METHOD 13 +#define SOAP_GET_METHOD 14 +#define SOAP_EOM 15 +#define SOAP_NULL 16 +#define SOAP_DUPLICATE_ID 17 +#define SOAP_MISSING_ID 18 +#define SOAP_HREF 19 +#define SOAP_UDP_ERROR 20 +#define SOAP_TCP_ERROR 21 +#define SOAP_HTTP_ERROR 22 +#define SOAP_SSL_ERROR 23 +#define SOAP_ZLIB_ERROR 24 +#define SOAP_DIME_ERROR 25 +#define SOAP_DIME_HREF 26 +#define SOAP_DIME_MISMATCH 27 +#define SOAP_DIME_END 28 +#define SOAP_MIME_ERROR 29 +#define SOAP_MIME_HREF 30 +#define SOAP_MIME_END 31 +#define SOAP_VERSIONMISMATCH 32 +#define SOAP_PLUGIN_ERROR 33 +#define SOAP_DATAENCODINGUNKNOWN 34 +#define SOAP_REQUIRED 35 +#define SOAP_PROHIBITED 36 +#define SOAP_OCCURS 37 +#define SOAP_LENGTH 38 +#define SOAP_FD_EXCEEDED 39 + +#define soap_xml_error_check(e) ((e) == SOAP_TAG_MISMATCH || (e) == SOAP_TAG_END || (e) == SOAP_SYNTAX_ERROR || (e) == SOAP_NAMESPACE || (e) == SOAP_DUPLICATE_ID || (e) == SOAP_MISSING_ID || (e) == SOAP_REQUIRED || (e) == SOAP_PROHIBITED || (e) == SOAP_OCCURS || (e) == SOAP_LENGTH || (e) == SOAP_NULL || (e) == SOAP_HREF) +#define soap_soap_error_check(e) ((e) == SOAP_CLI_FAULT || (e) == SOAP_SVR_FAULT || (e) == SOAP_VERSIONMISMATCH || (e) == SOAP_MUSTUNDERSTAND || (e) == SOAP_FAULT || (e) == SOAP_NO_METHOD) +#define soap_tcp_error_check(e) ((e) == SOAP_EOF || (e) == SOAP_TCP_ERROR) +#define soap_ssl_error_check(e) ((e) == SOAP_SSL_ERROR) +#define soap_zlib_error_check(e) ((e) == SOAP_ZLIB_ERROR) +#define soap_http_error_check(e) ((e) == SOAP_HTTP_ERROR || (e) == SOAP_GET_METHOD || ((e) >= 100 && (e) < 600)) + +/* gSOAP HTTP response status codes 100 to 599 are reserved */ + +/* Codes 600 to 999 are user definable */ + +/* Exceptional gSOAP HTTP response status codes >= 1000 */ + +#define SOAP_STOP 1000 /* No HTTP response */ +#define SOAP_FORM 1001 /* Form request/response */ +#define SOAP_HTML 1002 /* Custom HTML response */ +#define SOAP_FILE 1003 /* Custom file-based response */ + +/* gSOAP HTTP method codes */ + +#define SOAP_POST 2000 +#define SOAP_GET 2001 + +/* gSOAP DIME */ + +#define SOAP_DIME_CF 0x01 +#define SOAP_DIME_ME 0x02 +#define SOAP_DIME_MB 0x04 +#define SOAP_DIME_VERSION 0x08 /* DIME version 1 */ +#define SOAP_DIME_MEDIA 0x10 +#define SOAP_DIME_ABSURI 0x20 + +/* gSOAP ZLIB */ + +#define SOAP_ZLIB_NONE 0x00 +#define SOAP_ZLIB_DEFLATE 0x01 +#define SOAP_ZLIB_INFLATE 0x02 +#define SOAP_ZLIB_GZIP 0x02 + +/* gSOAP transport, connection, and content encoding modes */ + +typedef soap_int32 soap_mode; + +#define SOAP_IO 0x00000003 /* IO mask */ +#define SOAP_IO_FLUSH 0x00000000 /* flush output immediately, no buffering */ +#define SOAP_IO_BUFFER 0x00000001 /* buffer output in packets of size SOAP_BUFLEN */ +#define SOAP_IO_STORE 0x00000002 /* store entire output to determine length for transport */ +#define SOAP_IO_CHUNK 0x00000003 /* use HTTP chunked transfer AND buffer packets */ + +#define SOAP_IO_UDP 0x00000004 /* TCP or UDP */ + +#define SOAP_IO_LENGTH 0x00000008 /* calc message length (internal) */ +#define SOAP_IO_KEEPALIVE 0x00000010 /* keep connection alive */ + +#define SOAP_ENC_LATIN 0x00000020 /* accept iso-8859-1 encoding */ +#define SOAP_ENC_XML 0x00000040 /* plain XML encoding, no HTTP header */ +#define SOAP_ENC_DIME 0x00000080 +#define SOAP_ENC_MIME 0x00000100 +#define SOAP_ENC_MTOM 0x00000200 +#define SOAP_ENC_ZLIB 0x00000400 +#define SOAP_ENC_SSL 0x00000800 + +#define SOAP_ENC 0x00000FFF /* IO and ENC mask */ + +#define SOAP_XML_STRICT 0x00001000 /* apply strict validation */ +#define SOAP_XML_INDENT 0x00002000 /* emit indented XML */ +#define SOAP_XML_CANONICAL 0x00004000 /* EXC C14N canonical XML */ +#define SOAP_XML_TREE 0x00008000 /* emit XML tree (no id/ref) */ +#define SOAP_XML_GRAPH 0x00010000 +#define SOAP_XML_NIL 0x00020000 +#define SOAP_XML_DOM 0x00040000 +#define SOAP_XML_SEC 0x00080000 /* reserved for WS security */ + +#define SOAP_C_NOIOB 0x00100000 /* don't fault on array index out of bounds (just ignore) */ +#define SOAP_C_UTFSTRING 0x00200000 /* (de)serialize strings with UTF8 content */ +#define SOAP_C_MBSTRING 0x00400000 /* (de)serialize strings with multi-byte content */ +#define SOAP_C_NILSTRING 0x00800000 /* serialize empty strings as nil (omitted) */ + +#define SOAP_DOM_TREE 0x01000000 +#define SOAP_DOM_NODE 0x02000000 +#define SOAP_DOM_ASIS 0x04000000 + +#define SOAP_MIME_POSTCHECK 0x10000000 /* MIME flag (internal) */ + +#define SOAP_IO_DEFAULT SOAP_IO_FLUSH + +/* SSL client/server authentication settings */ + +#define SOAP_SSL_NO_AUTHENTICATION 0x00 /* for testing purposes */ +#define SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION 0x01 /* client requires server to authenticate */ +#define SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION 0x02 /* server requires client to authenticate */ + +#define SOAP_SSL_DEFAULT SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION + +/* state */ + +#define SOAP_INIT 1 +#define SOAP_COPY 2 + +#define soap_check_state(soap) (!(soap) || ((soap)->state != SOAP_INIT && (soap)->state != SOAP_COPY)) + +/* part */ + +#define SOAP_BEGIN 0 +#define SOAP_IN_ENVELOPE 2 +#define SOAP_IN_HEADER 3 +#define SOAP_END_HEADER 4 +#define SOAP_NO_BODY 5 +#define SOAP_IN_BODY 6 +#define SOAP_END_BODY 7 +#define SOAP_END_ENVELOPE 8 +#define SOAP_END 9 +#define SOAP_BEGIN_SECURITY 10 +#define SOAP_IN_SECURITY 11 +#define SOAP_END_SECURITY 12 + +/* DEBUG macros */ + +#ifndef WITH_LEAN +# ifdef DEBUG +# ifndef SOAP_DEBUG +# define SOAP_DEBUG +# endif +# endif +#endif + +#ifdef SOAP_DEBUG +# define SOAP_MALLOC(soap, size) soap_track_malloc(soap, __FILE__, __LINE__, size) +# define SOAP_FREE(soap, ptr) soap_track_free(soap, __FILE__, __LINE__, ptr) +#endif + +#ifndef SOAP_MALLOC /* use libc malloc */ +# define SOAP_MALLOC(soap, size) malloc(size) +#endif + +#ifndef SOAP_FREE /* use libc free */ +# define SOAP_FREE(soap, ptr) free(ptr) +#endif + +#ifdef SOAP_DEBUG +# ifndef SOAP_MESSAGE +# define SOAP_MESSAGE fprintf +# endif +# ifndef DBGLOG +# define DBGLOG(DBGFILE, CMD) \ +{ if (soap)\ + { if (!soap->fdebug[SOAP_INDEX_##DBGFILE])\ + soap_open_logfile((struct soap*)soap, SOAP_INDEX_##DBGFILE);\ + if (soap->fdebug[SOAP_INDEX_##DBGFILE])\ + { FILE *fdebug = soap->fdebug[SOAP_INDEX_##DBGFILE];\ + CMD;\ + fflush(fdebug);\ + }\ + }\ +} +# endif +# ifndef DBGMSG +# define DBGMSG(DBGFILE, MSG, LEN) \ +{ if (soap)\ + { if (!soap->fdebug[SOAP_INDEX_##DBGFILE])\ + soap_open_logfile((struct soap*)soap, SOAP_INDEX_##DBGFILE);\ + if (soap->fdebug[SOAP_INDEX_##DBGFILE])\ + { fwrite((MSG), 1, (LEN), soap->fdebug[SOAP_INDEX_##DBGFILE]);\ + fflush(soap->fdebug[SOAP_INDEX_##DBGFILE]);\ + }\ + }\ +} +# endif +# ifndef DGBFUN +# define DBGFUN(FNAME) DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): %s()\n", __FILE__, __LINE__, FNAME)) +# define DBGFUN1(FNAME, FMT, ARG) DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): %s("FMT")\n", __FILE__, __LINE__, FNAME, (ARG))) +# define DBGFUN2(FNAME, FMT1, ARG1, FMT2, ARG2) DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): %s("FMT1", "FMT2")\n", __FILE__, __LINE__, FNAME, (ARG1), (ARG2))) +# define DBGFUN3(FNAME, FMT1, ARG1, FMT2, ARG2, FMT3, ARG3) DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): %s("FMT1", "FMT2", "FMT3")\n", __FILE__, __LINE__, FNAME, (ARG1), (ARG2), (ARG3))) +# endif +# ifndef DBGHEX +# define DBGHEX(DBGFILE, MSG, LEN) \ +{ if (soap)\ + { if (!soap->fdebug[SOAP_INDEX_##DBGFILE])\ + soap_open_logfile(soap, SOAP_INDEX_##DBGFILE);\ + if (soap->fdebug[SOAP_INDEX_##DBGFILE])\ + { int i; char *s;\ + for (s = (char*)(MSG), i = (LEN); i; i--)\ + fprintf(soap->fdebug[SOAP_INDEX_##DBGFILE], "%2.2X ", (int)*s++&0xFF);\ + fflush(soap->fdebug[SOAP_INDEX_##DBGFILE]);\ + }\ + }\ +} +# endif +#else +# define DBGLOG(DBGFILE, CMD) +# define DBGMSG(DBGFILE, MSG, LEN) +# define DBGFUN(FNAME) +# define DBGFUN1(FNAME, FMT, ARG) +# define DBGFUN2(FNAME, FMT1, ARG1, FMT2, ARG2) +# define DBGFUN3(FNAME, FMT1, ARG1, FMT2, ARG2, FMT3, ARG3) +# define DBGHEX(DBGFILE, MSG, LEN) +#endif + +/* UCS-4 requires 32 bits (0-7FFFFFFF, the sign bit is used by gSOAP to distinguish XML entities) */ +typedef soap_int32 soap_wchar; + +/* namespace table row */ +struct Namespace +{ const char *id; + const char *ns; + const char *in; + char *out; +}; + +/* namespace stack */ +struct soap_nlist +{ struct soap_nlist *next; + unsigned int level; /* nesting depth level */ + short index; /* corresponding entry in ns mapping table */ + char *ns; /* only set when parsed ns URI is not in the ns mapping table */ + char id[1]; /* the actual string value flows into the allocated region below this struct */ +}; + +/* block stack for nested block allocations */ +struct soap_blist +{ struct soap_blist *next; + char *ptr; + size_t size; +}; + +/* array layout */ +struct soap_array +{ void *__ptr; + int __size; +}; + +/* pointer serialization management */ +struct soap_plist +{ struct soap_plist *next; + const void *ptr; + const struct soap_array *array; + int type; + int id; + char mark1; + char mark2; +}; + +/* block allocation for pointer serialization management */ +struct soap_pblk +{ struct soap_pblk *next; + struct soap_plist plist[SOAP_PTRBLK]; +}; + +#ifdef SOAP_DEBUG +/* malloc/free tracking for debugging */ +struct soap_mlist +{ struct soap_mlist *next; + const void *ptr; + const char *file; + int line; + short live; +}; +#endif + +/* class allocation list */ +struct soap_clist +{ struct soap_clist *next; + void *ptr; + int type; + int size; + void (*fdelete)(struct soap_clist*); +}; + +/* attributes */ +struct soap_attribute +{ struct soap_attribute *next; + char *value; + size_t size; + char *ns; + short visible; + char name[1]; /* the actual name string flows into the allocated region below this struct */ +}; + +#ifndef WITH_LEAN +struct soap_cookie +{ struct soap_cookie *next; + char *name; + char *value; + char *domain; + char *path; + time_t expire; /* client-side: local time to expire */ + long maxage; /* server-side: seconds to expire */ + unsigned int version; + short secure; + short session; /* server-side */ + short env; /* server-side: got cookie from client and should not be (re)send */ + short modified; /* server-side: client cookie was modified and should be send */ +}; +#endif + +#ifdef __cplusplus +SOAP_FMAC1 struct soap_multipart* SOAP_FMAC2 soap_next_multipart(struct soap_multipart*); + +class soap_multipart_iterator +{ public: + struct soap_multipart *content; + bool operator==(const soap_multipart_iterator& iter) const + { return content == iter.content; } + bool operator!=(const soap_multipart_iterator& iter) const + { return content != iter.content; } + struct soap_multipart &operator*() const + { return *content; } + soap_multipart_iterator &operator++() + { content = soap_next_multipart(content); return *this; } + soap_multipart_iterator() : content(NULL) + { } + soap_multipart_iterator(struct soap_multipart *p) : content(p) + { } +}; +#endif + +#ifndef WITH_LEANER +struct soap_dime +{ size_t count; + size_t size; + size_t chunksize; + size_t buflen; + char flags; + char *ptr; + const char *id; + const char *type; + const char *options; + struct soap_multipart *list; /* list of DIME attachments received */ + struct soap_multipart *first, *last; /* temporary in/out queue */ +#ifdef __cplusplus + soap_multipart_iterator begin() + { soap_multipart_iterator iter(list); return iter; }; + soap_multipart_iterator end() + { soap_multipart_iterator iter(NULL); return iter; }; +#endif +}; +#endif + +#ifndef WITH_LEANER +struct soap_mime +{ char *boundary; /* MIME boundary */ + const char *start; /* MIME start ID */ + struct soap_multipart *list; /* list of MIME attachments received */ + struct soap_multipart *first, *last; /* temporary in/out queue */ +#ifdef __cplusplus + soap_multipart_iterator begin() + { soap_multipart_iterator iter(list); return iter; }; + soap_multipart_iterator end() + { soap_multipart_iterator iter(NULL); return iter; }; +#endif +}; +#endif + +#ifndef WITH_LEANER +/* RFC2045 MIME content transfer encodings */ +enum soap_mime_encoding +{ SOAP_MIME_NONE, + SOAP_MIME_7BIT, + SOAP_MIME_8BIT, + SOAP_MIME_BINARY, + SOAP_MIME_QUOTED_PRINTABLE, + SOAP_MIME_BASE64, + SOAP_MIME_IETF_TOKEN, + SOAP_MIME_X_TOKEN +}; +#endif + +#ifndef WITH_LEANER +/* DIME/MIME multipart list */ +struct soap_multipart +{ struct soap_multipart *next; + char *ptr; /* points to raw data content */ + size_t size; /* size of data content */ + const char *id; /* DIME/MIME content ID or form data name */ + const char *type; /* DIME/MIME type (MIME type format) */ + const char *options; /* DIME options */ + enum soap_mime_encoding encoding; /* MIME Content-Transfer-Encoding */ + const char *location; /* MIME Content-Location (optional) */ + const char *description; /* MIME Content-Description (optional) */ +#ifdef __cplusplus + typedef soap_multipart_iterator iterator; +#endif +}; +#endif + +#ifndef WITH_LEANER +/* attachment DIME and MTOM XOP forwarding */ +struct soap_xlist +{ struct soap_xlist *next; + unsigned char **ptr; + int *size; + char *id; + char **type; + char **options; +}; +#endif + +/******************************************************************************/ + +#ifndef WITH_LEANER +#ifdef __cplusplus +class soap_dom_attribute_iterator +{ public: + struct soap_dom_attribute *att; + const char *nstr; + const char *name; + bool operator==(const soap_dom_attribute_iterator&) const; + bool operator!=(const soap_dom_attribute_iterator&) const; + struct soap_dom_attribute &operator*() const; + soap_dom_attribute_iterator &operator++(); + soap_dom_attribute_iterator(); + soap_dom_attribute_iterator(struct soap_dom_attribute*); + ~soap_dom_attribute_iterator(); +}; +#endif +#endif + +#ifndef WITH_LEANER +struct soap_dom_attribute +{ struct soap_dom_attribute *next; + const char *nstr; + char *name; + char *data; + wchar_t *wide; + struct soap *soap; +#ifdef __cplusplus + typedef soap_dom_attribute_iterator iterator; + struct soap_dom_attribute &set(const char *nstr, const char *name); /* set namespace and name */ + struct soap_dom_attribute &set(const char *data); /* set data */ + soap_dom_attribute_iterator begin(); + soap_dom_attribute_iterator end(); + soap_dom_attribute_iterator find(const char *nstr, const char *name); + void unlink(); + soap_dom_attribute(); + soap_dom_attribute(struct soap *soap); + soap_dom_attribute(struct soap *soap, const char *nstr, const char *name, const char *data); + ~soap_dom_attribute(); +#endif +}; +#endif + +#ifndef WITH_LEANER +#ifdef __cplusplus +class soap_dom_element_iterator +{ public: + struct soap_dom_element *elt; + const char *nstr; + const char *name; + int type; + bool operator==(const soap_dom_element_iterator&) const; + bool operator!=(const soap_dom_element_iterator&) const; + struct soap_dom_element &operator*() const; + soap_dom_element_iterator &operator++(); + soap_dom_element_iterator(); + soap_dom_element_iterator(struct soap_dom_element*); + ~soap_dom_element_iterator(); +}; +#endif +#endif + +#ifndef WITH_LEANER +struct soap_dom_element +{ struct soap_dom_element *next; /* next sibling */ + struct soap_dom_element *prnt; /* parent */ + struct soap_dom_element *elts; /* list of child elements */ + struct soap_dom_attribute *atts; /* list of attributes */ + const char *nstr; /* namespace string */ + char *name; /* element tag name */ + char *data; /* element content data (with SOAP_C_UTFSTRING flag set) */ + wchar_t *wide; /* element content data */ + int type; /* optional: serialized C/C++ data type */ + void *node; /* optional: pointer to serialized C/C++ data */ + char *head; /* leading whitespace to start tag */ + char *tail; /* leading whitespace to end tag */ + struct soap *soap; /* soap context that manages this node */ +#ifdef __cplusplus + typedef soap_dom_element_iterator iterator; + struct soap_dom_element &set(const char *nstr, const char *name); + struct soap_dom_element &set(const char *data); + struct soap_dom_element &set(void *node, int type); + struct soap_dom_element &add(struct soap_dom_element*); + struct soap_dom_element &add(struct soap_dom_element&); + struct soap_dom_element &add(struct soap_dom_attribute*); + struct soap_dom_element &add(struct soap_dom_attribute&); + soap_dom_element_iterator begin(); + soap_dom_element_iterator end(); + soap_dom_element_iterator find(const char *nstr, const char *name); + soap_dom_element_iterator find(int type); + void unlink(); + soap_dom_element(); + soap_dom_element(struct soap *soap); + soap_dom_element(struct soap *soap, const char *nstr, const char *name); + soap_dom_element(struct soap *soap, const char *nstr, const char *name, const char *data); + soap_dom_element(struct soap *soap, const char *nstr, const char *name, void *node, int type); + ~soap_dom_element(); +#endif +}; +SOAP_FMAC1 struct soap_dom_element * SOAP_FMAC2 soap_dom_next_element(struct soap_dom_element *elt); +SOAP_FMAC1 struct soap_dom_attribute * SOAP_FMAC2 soap_dom_next_attribute(struct soap_dom_attribute *att); +#endif + +#if defined(__cplusplus) && !defined(WITH_LEAN) +} +extern std::ostream &operator<<(std::ostream&, const struct soap_dom_element&); +extern std::istream &operator>>(std::istream&, struct soap_dom_element&); +extern "C" { +#endif + +/******************************************************************************/ + +#ifdef WIN32 +# ifdef SOAP_STD_EXPORTS +# define SOAP_STD_API __declspec(dllexport) +# else +# define SOAP_STD_API +# endif +#else +# define SOAP_STD_API +#endif + +struct SOAP_STD_API soap +{ short state; /* 0 = uninitialized, 1 = initialized, 2 = copy of another soap struct */ + short version; /* 1 = SOAP1.1 and 2 = SOAP1.2 (set automatically from namespace URI in nsmap table) */ + soap_mode mode; + soap_mode imode; + soap_mode omode; + const char *float_format; /* user-definable format string for floats (<1024 chars) */ + const char *double_format; /* user-definable format string for doubles (<1024 chars) */ + const char *dime_id_format; /* user-definable format string for integer DIME id ( 0, gives socket recv timeout in seconds, < 0 in usec */ + int send_timeout; /* when > 0, gives socket send timeout in seconds, < 0 in usec */ + int connect_timeout; /* when > 0, gives socket connect() timeout in seconds, < 0 in usec */ + int accept_timeout; /* when > 0, gives socket accept() timeout in seconds, < 0 in usec */ + int socket_flags; /* socket recv() and send() flags, e.g. set to MSG_NOSIGNAL to disable sigpipe */ + int connect_flags; /* connect() SOL_SOCKET sockopt flags, e.g. set to SO_DEBUG to debug socket */ + int bind_flags; /* bind() SOL_SOCKET sockopt flags, e.g. set to SO_REUSEADDR to enable reuse */ + int accept_flags; /* accept() SOL_SOCKET sockopt flags */ + const struct Namespace *namespaces; /* Pointer to global namespace mapping table */ + struct Namespace *local_namespaces; /* Local namespace mapping table */ + struct soap_nlist *nlist; /* namespace stack */ + struct soap_blist *blist; /* block allocation stack */ + struct soap_clist *clist; /* class instance allocation list */ + void *alist; /* memory allocation (malloc) list */ + struct soap_ilist *iht[SOAP_IDHASH]; + struct soap_plist *pht[SOAP_PTRHASH]; + struct soap_pblk *pblk; /* plist block allocation */ + short pidx; /* plist block allocation */ + struct SOAP_ENV__Header *header; + struct SOAP_ENV__Fault *fault; + int idnum; + void *user; /* to pass user-defined data */ + struct soap_plugin *plugins; /* linked list of plug-in data */ + char *userid; /* HTTP Basic authorization userid */ + char *passwd; /* HTTP Basic authorization passwd */ + int (*fpost)(struct soap*, const char*, const char*, int, const char*, const char*, size_t); + int (*fget)(struct soap*); + int (*fform)(struct soap*); + int (*fposthdr)(struct soap*, const char*, const char*); + int (*fresponse)(struct soap*, int, size_t); + int (*fparse)(struct soap*); + int (*fparsehdr)(struct soap*, const char*, const char*); + int (*fheader)(struct soap*); + int (*fresolve)(struct soap*, const char*, struct in_addr* inaddr); + int (*fconnect)(struct soap*, const char*, const char*, int); + int (*fdisconnect)(struct soap*); + int (*fclosesocket)(struct soap*, SOAP_SOCKET); + int (*fshutdownsocket)(struct soap*, SOAP_SOCKET, int); + int (*fopen)(struct soap*, const char*, const char*, int); + int (*faccept)(struct soap*, int, struct sockaddr*, int *n); + int (*fclose)(struct soap*); + int (*fsend)(struct soap*, const char*, size_t); + size_t (*frecv)(struct soap*, char*, size_t); + int (*fpoll)(struct soap*); + void (*fseterror)(struct soap*, const char **c, const char **s); + int (*fignore)(struct soap*, const char*); + int (*fserveloop)(struct soap*); + void *(*fplugin)(struct soap*, const char*); +#ifndef WITH_LEANER + int (*fprepareinit)(struct soap*); + int (*fpreparesend)(struct soap*, const char*, size_t); + int (*fpreparerecv)(struct soap*, const char*, size_t); + int (*fpreparefinal)(struct soap*); + void *(*fdimereadopen)(struct soap*, void*, const char*, const char*, const char*); + void *(*fdimewriteopen)(struct soap*, const char*, const char*, const char*); + void (*fdimereadclose)(struct soap*, void*); + void (*fdimewriteclose)(struct soap*, void*); + size_t (*fdimeread)(struct soap*, void*, char*, size_t); + int (*fdimewrite)(struct soap*, void*, const char*, size_t); + void *(*fmimereadopen)(struct soap*, void*, const char*, const char*, const char*); + void *(*fmimewriteopen)(struct soap*, void*, const char*, const char*, const char*, enum soap_mime_encoding); + void (*fmimereadclose)(struct soap*, void*); + void (*fmimewriteclose)(struct soap*, void*); + size_t (*fmimeread)(struct soap*, void*, char*, size_t); + int (*fmimewrite)(struct soap*, void*, const char*, size_t); +#endif + int master; + SOAP_SOCKET socket; /* Modified by Intel Corporation to use SOAP_SOCKET type instead of int */ +#if defined(__cplusplus) && !defined(WITH_LEAN) + std::ostream *os; + std::istream *is; +#else + void *os; /* preserve alignment */ + void *is; /* preserve alignment */ +#endif +#ifndef UNDER_CE + int sendfd; + int recvfd; +#else + FILE *sendfd; + FILE *recvfd; +#endif +#ifdef WIN32 + char errorstr[256]; /* buf for FormatMessage() */ +#endif + size_t bufidx; /* index in soap.buf[] */ + size_t buflen; /* length of soap.buf[] content */ + soap_wchar ahead; /* parser lookahead */ + short cdata; /* CDATA parser state */ + short body; /* parsed XML element has a body or not */ + unsigned int level; /* XML nesting level */ + size_t count; /* message length counter */ + size_t length; /* message length as set by HTTP header */ +#ifdef WITH_FAST + char *labbuf; /* look-aside buffer */ + size_t lablen; /* look-aside buffer allocated length */ + size_t labidx; /* look-aside buffer index to available part */ +#endif + char buf[SOAP_BUFLEN];/* send and receive buffer */ + char tmpbuf[1024]; /* in/output buffer for HTTP headers, simpleType values, attribute names, and DIME >=1024 bytes */ + char msgbuf[1024]; /* in/output buffer for messages >=1024 bytes */ + char tag[SOAP_TAGLEN]; + char id[SOAP_TAGLEN]; + char href[SOAP_TAGLEN]; + char type[SOAP_TAGLEN]; + char arrayType[SOAP_TAGLEN]; + char arraySize[SOAP_TAGLEN]; + char arrayOffset[SOAP_TAGLEN]; + short other; + short position; + int positions[SOAP_MAXDIMS]; + short root; + struct soap_attribute *attributes; /* attribute list */ + short encoding; /* when set, output encodingStyle */ + short mustUnderstand; /* a mustUnderstand element was parsed or is output */ + short keep_alive; /* connection should be kept open */ + short null; /* parsed XML is xsi:nil */ + short ns; /* when not set, output full xmlns bindings */ + short part; /* parsing state */ + short alloced; + short peeked; + size_t chunksize; + size_t chunkbuflen; + char endpoint[SOAP_TAGLEN]; + char path[SOAP_TAGLEN]; + char host[SOAP_TAGLEN]; + char *action; + char *authrealm; /* HTTP authentication realm */ + char *prolog; /* XML declaration prolog */ + unsigned long ip; /* IP number */ + int port; /* port number */ + unsigned int max_keep_alive; + const char *proxy_host; /* Proxy Server host name */ + int proxy_port; /* Proxy Server port (default = 8080) */ + const char *proxy_userid; /* Proxy Authorization user name */ + const char *proxy_passwd; /* Proxy Authorization password */ + int status; /* -1 when request, else error code to be returned by server */ + int error; + int errmode; + int errnum; +#ifndef WITH_LEANER + struct soap_dom_element *dom; + struct soap_dime dime; + struct soap_mime mime; + struct soap_xlist *xlist; +#endif +#if !defined(WITH_LEAN) || defined(SOAP_DEBUG) + const char *logfile[SOAP_MAXLOGS]; + FILE *fdebug[SOAP_MAXLOGS]; + struct soap_mlist *mht[SOAP_PTRHASH]; +#endif +#ifndef WITH_LEAN + const char *c14ninclude; + const char *c14nexclude; + struct soap_cookie *cookies; + const char *cookie_domain; + const char *cookie_path; + int cookie_max; +#endif +#ifndef WITH_NOIO +#ifdef WITH_IPV6 + struct sockaddr_storage peer; /* IPv6: set by soap_accept and by UDP recv */ +#else + struct sockaddr_in peer; /* IPv4: set by soap_connect/soap_accept and by UDP recv */ +#endif +#endif + size_t peerlen; +#ifdef WITH_OPENSSL + int (*fsslauth)(struct soap*); + int (*fsslverify)(int, X509_STORE_CTX*); + BIO *bio; + SSL *ssl; + SSL_CTX *ctx; + short require_server_auth; + short require_client_auth; + short rsa; /* when set, use RSA instead of DH */ + const char *keyfile; + const char *password; + const char *dhfile; + const char *cafile; + const char *capath; + const char *crlfile; + const char *randfile; + SSL_SESSION *session; + char session_host[SOAP_TAGLEN]; + int session_port; +#endif +#ifdef WITH_ZLIB + short zlib_state; /* SOAP_ZLIB_NONE, SOAP_ZLIB_DEFLATE, or SOAP_ZLIB_INFLATE */ + short zlib_in; /* SOAP_ZLIB_NONE, SOAP_ZLIB_DEFLATE, or SOAP_ZLIB_GZIP */ + short zlib_out; /* SOAP_ZLIB_NONE, SOAP_ZLIB_DEFLATE, or SOAP_ZLIB_GZIP */ + z_stream d_stream; /* decompression stream */ + char z_buf[SOAP_BUFLEN]; /* buffer */ + size_t z_buflen; + unsigned short z_level; /* compression level to be used (0=none, 1=fast to 9=best) */ + uLong z_crc; /* internal gzip crc */ + float z_ratio_in; /* detected compression ratio compressed_length/length of inbound message */ + float z_ratio_out; /* detected compression ratio compressed_length/length of outbound message */ +#endif +#ifdef WMW_RPM_IO + void *rpmreqid; +#endif +#ifndef WITH_LEAN +#ifdef __cplusplus + soap(); + soap(soap_mode); + soap(soap_mode, soap_mode); + soap(struct soap&); + ~soap(); +#endif +#endif +}; + +struct soap_code_map +{ long code; + const char *string; +}; + +/* forwarding list */ +struct soap_flist +{ struct soap_flist *next; + int type; + void *ptr; + unsigned int level; + size_t len; + void (*fcopy)(struct soap*, int, int, void*, size_t, const void*, size_t); +}; + +/* id-ref forwarding list */ +struct soap_ilist +{ struct soap_ilist *next; + int type; + size_t size; + void *link; + void *copy; + struct soap_flist *flist; + void *ptr; + unsigned int level; + char id[1]; /* the actual id string value flows into the allocated region below this struct */ +}; + +struct soap_plugin +{ struct soap_plugin *next; + const char *id; + void *data; + int (*fcopy)(struct soap *soap, struct soap_plugin *dst, struct soap_plugin *src); + void (*fdelete)(struct soap *soap, struct soap_plugin *p); /* should delete fields of plugin only and not free(p) */ +}; + +#ifndef WITH_NONAMESPACES +extern SOAP_NMAC struct Namespace namespaces[]; +#endif + +#ifndef WITH_LEAN +# define soap_get0(soap) (((soap)->bufidx>=(soap)->buflen && soap_recv(soap)) ? EOF : (unsigned char)(soap)->buf[(soap)->bufidx]) +# define soap_get1(soap) (((soap)->bufidx>=(soap)->buflen && soap_recv(soap)) ? EOF : (unsigned char)(soap)->buf[(soap)->bufidx++]) +#else +soap_wchar soap_get0(struct soap*); +soap_wchar soap_get1(struct soap*); +#endif + +#define soap_revget1(soap) ((soap)->bufidx--) +#define soap_unget(soap, c) ((soap)->ahead = c) +#define soap_register_plugin(soap, plugin) soap_register_plugin_arg(soap, plugin, NULL) +#define soap_imode(soap, n) ((soap)->mode = (soap)->imode = (n)) +#define soap_set_imode(soap, n) ((soap)->imode |= (n)) +#define soap_clr_imode(soap, n) ((soap)->imode &= ~(n)) +#define soap_omode(soap, n) ((soap)->mode = (soap)->omode = (n)) +#define soap_set_omode(soap, n) ((soap)->omode |= (n)) +#define soap_clr_omode(soap, n) ((soap)->omode &= ~(n)) +#define soap_set_mode(soap, n) ((soap)->imode |= (n), (soap)->omode |= (n)) +#define soap_clr_mode(soap, n) ((soap)->imode &= ~(n), (soap)->omode &= ~(n)) +#define soap_destroy(soap) soap_delete((soap), NULL) + +#ifdef HAVE_STRRCHR +# define soap_strrchr(s, t) strrchr(s, t) +#else + SOAP_FMAC1 char* SOAP_FMAC2 soap_strrchr(const char *s, int t); +#endif + +#ifdef HAVE_STRTOL +# define soap_strtol(s, t, b) strtol(s, t, b) +#else + SOAP_FMAC1 long SOAP_FMAC2 soap_strtol(const char *s, char **t, int b); +#endif + +#ifdef HAVE_STRTOUL +# define soap_strtoul(s, t, b) strtoul(s, t, b) +#else + SOAP_FMAC1 unsigned long SOAP_FMAC2 soap_strtoul(const char *s, char **t, int b); +#endif + +#if defined(WITH_OPENSSL) +# define soap_random soap_rand() +SOAP_FMAC1 int SOAP_FMAC2 soap_rand(void); +#elif defined(HAVE_RANDOM) +# define soap_random (int)random() +#else +# define soap_random rand() +#endif + +#ifdef WITH_NOIDREF +# define soap_embedded(s, p, t) (0) +# define soap_id_lookup(s, i, p, t, n, k) (p) +# define soap_id_forward(s, h, p, len, st, tt, n, k, fc) (p) +# define soap_reference(s, a, t) (1) +# define soap_array_reference(s, p, a, n, t) (1) +# define soap_embed(s, p, a, n, t, pp) (0) +# define soap_embedded_id(s, i, p, t) (i) +# define soap_is_embedded(s, p) (0) +# define soap_is_single(s, p) (1) +# define soap_lookup_type(s, i) (0) +# define soap_getindependent(s) (0) +# define soap_putindependent(s) (0) +# define soap_getelement(s, n) (n) +# define soap_putelement(s, p, t, i, n) (0) +# define soap_markelement(s, p, n) (0) +#endif + +SOAP_FMAC1 void SOAP_FMAC2 soap_fault(struct soap*); +SOAP_FMAC1 const char** SOAP_FMAC2 soap_faultcode(struct soap*); +SOAP_FMAC1 const char** SOAP_FMAC2 soap_faultsubcode(struct soap*); +SOAP_FMAC1 const char** SOAP_FMAC2 soap_faultstring(struct soap*); +SOAP_FMAC1 const char** SOAP_FMAC2 soap_faultdetail(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_serializeheader(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_putheader(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_getheader(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_serializefault(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_putfault(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_getfault(struct soap*); + +SOAP_FMAC1 void SOAP_FMAC2 soap_ssl_init(void); +SOAP_FMAC1 int SOAP_FMAC2 soap_poll(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_connect_command(struct soap*, int, const char*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_connect(struct soap*, const char*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_bind(struct soap*, const char*, int, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_accept(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_ssl_accept(struct soap*); +SOAP_FMAC1 const char * SOAP_FMAC2 soap_ssl_error(struct soap*, int); + +SOAP_FMAC1 int SOAP_FMAC2 soap_ssl_server_context(struct soap*, unsigned short, const char*, const char*, const char*, const char*, const char*, const char*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_ssl_client_context(struct soap*, unsigned short, const char*, const char*, const char*, const char*, const char*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_puthttphdr(struct soap*, int status, size_t count); + +SOAP_FMAC1 const char* SOAP_FMAC2 soap_get_header_attribute(struct soap*, const char*, const char*); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_decode_key(char*, size_t, const char*); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_decode_val(char*, size_t, const char*); + +SOAP_FMAC1 size_t SOAP_FMAC2 soap_hash(const char*); +SOAP_FMAC1 void SOAP_FMAC2 soap_set_endpoint(struct soap*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_flush_raw(struct soap*, const char*, size_t); +SOAP_FMAC1 int SOAP_FMAC2 soap_flush(struct soap*); +SOAP_FMAC1 soap_wchar SOAP_FMAC2 soap_get(struct soap*); +SOAP_FMAC1 soap_wchar SOAP_FMAC2 soap_getchar(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_tag_cmp(const char*, const char*); +SOAP_FMAC1 void SOAP_FMAC2 soap_set_fault(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_sender_fault(struct soap*, const char*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_sender_fault_subcode(struct soap*, const char*, const char*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_receiver_fault(struct soap*, const char*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_receiver_fault_subcode(struct soap*, const char*, const char*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_set_sender_error(struct soap*, const char*, const char*, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_set_receiver_error(struct soap*, const char*, const char*, int); + +SOAP_FMAC1 int SOAP_FMAC2 soap_send_raw(struct soap*, const char*, size_t); +SOAP_FMAC1 int SOAP_FMAC2 soap_recv_raw(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_recv(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_send(struct soap*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_send2(struct soap*, const char*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_send3(struct soap*, const char*, const char*, const char*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_pututf8(struct soap*, unsigned long); +SOAP_FMAC1 soap_wchar SOAP_FMAC2 soap_getutf8(struct soap*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_putbase64(struct soap*, const unsigned char*, int); +SOAP_FMAC1 unsigned char* SOAP_FMAC2 soap_getbase64(struct soap*, int*, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_puthex(struct soap*, const unsigned char*, int); +SOAP_FMAC1 unsigned char* SOAP_FMAC2 soap_gethex(struct soap*, int*); + +#ifndef WITH_LEANER +SOAP_FMAC1 int SOAP_FMAC2 soap_xop_forward(struct soap*, unsigned char**, int*, char**, char**, char**); +SOAP_FMAC1 int SOAP_FMAC2 soap_dime_forward(struct soap*, unsigned char**, int*, char**, char**, char**); +#endif + +#ifndef WITH_NOIDREF +SOAP_FMAC1 int SOAP_FMAC2 soap_pointer_lookup_id(struct soap*, void *p, int t, struct soap_plist**); +SOAP_FMAC1 int SOAP_FMAC2 soap_pointer_lookup(struct soap*, const void *p, int t, struct soap_plist**); +SOAP_FMAC1 int SOAP_FMAC2 soap_pointer_enter(struct soap*, const void *p, const struct soap_array *a, int n, int t, struct soap_plist**); +SOAP_FMAC1 int SOAP_FMAC2 soap_array_pointer_lookup(struct soap*, const void *p, const struct soap_array *a, int n, int t, struct soap_plist**); +SOAP_FMAC1 int SOAP_FMAC2 soap_embed(struct soap *soap, const void *p, const struct soap_array *a, int n, const char *tag, int type); +SOAP_FMAC1 struct soap_ilist* SOAP_FMAC2 soap_lookup(struct soap*, const char*); +SOAP_FMAC1 struct soap_ilist* SOAP_FMAC2 soap_enter(struct soap*, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_resolve(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_embedded(struct soap*, const void *p, int t); +SOAP_FMAC1 int SOAP_FMAC2 soap_reference(struct soap*, const void *p, int t); +SOAP_FMAC1 int SOAP_FMAC2 soap_array_reference(struct soap*, const void *p, const struct soap_array *a, int n, int t); +SOAP_FMAC1 int SOAP_FMAC2 soap_embedded_id(struct soap*, int id, const void *p, int t); +SOAP_FMAC1 int SOAP_FMAC2 soap_is_embedded(struct soap*, struct soap_plist*); +SOAP_FMAC1 int SOAP_FMAC2 soap_is_single(struct soap*, struct soap_plist*); +SOAP_FMAC1 void SOAP_FMAC2 soap_set_embedded(struct soap*, struct soap_plist*); +#endif + +SOAP_FMAC1 int SOAP_FMAC2 soap_begin_count(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_end_count(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_begin_send(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_end_send(struct soap*); + +SOAP_FMAC1 const struct soap_code_map* SOAP_FMAC2 soap_code(const struct soap_code_map*, const char *str); +SOAP_FMAC1 long SOAP_FMAC2 soap_code_int(const struct soap_code_map*, const char *str, long other); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_code_str(const struct soap_code_map*, long code); +SOAP_FMAC1 long SOAP_FMAC2 soap_code_bits(const struct soap_code_map *map, const char *str); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_code_list(struct soap*, const struct soap_code_map *map, long code); + +SOAP_FMAC1 int SOAP_FMAC2 soap_getline(struct soap*, char*, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_begin_recv(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_end_recv(struct soap*); + +SOAP_FMAC1 void* SOAP_FMAC2 soap_malloc(struct soap*, size_t); +SOAP_FMAC1 void SOAP_FMAC2 soap_dealloc(struct soap*, void*); +SOAP_FMAC1 struct soap_clist * SOAP_FMAC2 soap_link(struct soap*, void*, int, int, void (*fdelete)(struct soap_clist*)); +SOAP_FMAC1 void SOAP_FMAC2 soap_unlink(struct soap*, const void*); +SOAP_FMAC1 void SOAP_FMAC2 soap_free(struct soap*); + +SOAP_FMAC1 void* SOAP_FMAC2 soap_track_malloc(struct soap*, const char*, int, size_t); +SOAP_FMAC1 void SOAP_FMAC2 soap_track_free(struct soap*, const char*, int, void*); + +#ifndef WITH_NOIDREF +SOAP_FMAC1 int SOAP_FMAC2 soap_lookup_type(struct soap*, const char *id); +SOAP_FMAC1 void* SOAP_FMAC2 soap_id_lookup(struct soap*, const char *id, void **p, int t, size_t n, unsigned int k); +SOAP_FMAC1 void* SOAP_FMAC2 soap_id_forward(struct soap*, const char *id, void *p, size_t len, int st, int tt, size_t n, unsigned int k, void(*fcopy)(struct soap*, int, int, void*, size_t, const void*, size_t)); +#endif +SOAP_FMAC1 void* SOAP_FMAC2 soap_id_enter(struct soap*, const char *id, void *p, int t, size_t n, unsigned int k, const char *type, const char *arrayType, void *(*finstantiate)(struct soap*, int, const char*, const char*, size_t*)); +SOAP_FMAC1 void SOAP_FMAC2 soap_fcopy(struct soap *soap, int st, int tt, void *p, size_t, const void *q, size_t n); + +SOAP_FMAC1 int SOAP_FMAC2 soap_size(const int *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_getoffsets(const char *, const int *, int *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_getsize(const char *, const char *, int *); +SOAP_FMAC1 int SOAP_FMAC2 soap_getsizes(const char *, int *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_getposition(const char *, int *); + +SOAP_FMAC1 char* SOAP_FMAC2 soap_putsize(struct soap*, const char *, int); +SOAP_FMAC1 char* SOAP_FMAC2 soap_putsizesoffsets(struct soap*, const char *, const int *, const int *, int); +SOAP_FMAC1 char* SOAP_FMAC2 soap_putsizes(struct soap*, const char *, const int *, int); +SOAP_FMAC1 char* SOAP_FMAC2 soap_putoffset(struct soap*, int); +SOAP_FMAC1 char* SOAP_FMAC2 soap_putoffsets(struct soap*, const int *, int); + +SOAP_FMAC1 int SOAP_FMAC2 soap_closesock(struct soap*); + +SOAP_FMAC1 struct soap *SOAP_FMAC2 soap_new(void); +SOAP_FMAC1 struct soap *SOAP_FMAC2 soap_new1(soap_mode); +SOAP_FMAC1 struct soap *SOAP_FMAC2 soap_new2(soap_mode, soap_mode); +SOAP_FMAC1 void SOAP_FMAC2 soap_del(struct soap*); +SOAP_FMAC1 struct soap *SOAP_FMAC2 soap_copy(struct soap*); +SOAP_FMAC1 struct soap *SOAP_FMAC2 soap_copy_context(struct soap*, struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_copy_stream(struct soap*, struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_init(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_init1(struct soap*, soap_mode); +SOAP_FMAC1 void SOAP_FMAC2 soap_init2(struct soap*, soap_mode, soap_mode); +SOAP_FMAC1 void SOAP_FMAC2 soap_done(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_cleanup(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_begin(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_end(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_delete(struct soap*, void*); + +#ifdef SOAP_DEBUG +SOAP_FMAC1 void SOAP_FMAC2 soap_set_recv_logfile(struct soap*, const char*); +SOAP_FMAC1 void SOAP_FMAC2 soap_set_sent_logfile(struct soap*, const char*); +SOAP_FMAC1 void SOAP_FMAC2 soap_set_test_logfile(struct soap*, const char*); +SOAP_FMAC1 void SOAP_FMAC2 soap_close_logfiles(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_open_logfile(struct soap*, int); +#endif + +SOAP_FMAC1 const char* SOAP_FMAC2 soap_value(struct soap*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_match_tag(struct soap*, const char*, const char *); +SOAP_FMAC1 int SOAP_FMAC2 soap_match_array(struct soap*, const char*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_element(struct soap*, const char*, int, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_element_begin_out(struct soap*, const char *tag, int id, const char *type); +SOAP_FMAC1 int SOAP_FMAC2 soap_array_begin_out(struct soap*, const char *tag, int id, const char *type, const char *offset); +SOAP_FMAC1 int SOAP_FMAC2 soap_element_ref(struct soap*, const char *tag, int id, int href); +SOAP_FMAC1 int SOAP_FMAC2 soap_element_href(struct soap*, const char *tag, int id, const char *ref, const char *val); +SOAP_FMAC1 int SOAP_FMAC2 soap_element_null(struct soap*, const char *tag, int id, const char *type); +SOAP_FMAC1 int SOAP_FMAC2 soap_element_id(struct soap*, const char *tag, int id, const void *p, const struct soap_array *a, int d, const char *type, int n); +SOAP_FMAC1 int SOAP_FMAC2 soap_element_result(struct soap*, const char *tag); +SOAP_FMAC1 void SOAP_FMAC2 soap_check_result(struct soap*, const char *tag); +SOAP_FMAC1 int SOAP_FMAC2 soap_element_end_out(struct soap*, const char *tag); +SOAP_FMAC1 int SOAP_FMAC2 soap_element_start_end_out(struct soap*, const char *tag); + +SOAP_FMAC1 int SOAP_FMAC2 soap_attribute(struct soap*, const char*, const char*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_element_begin_in(struct soap*, const char *tag, int nillable, const char *type); + +SOAP_FMAC1 int SOAP_FMAC2 soap_element_end_in(struct soap*, const char *tag); + +SOAP_FMAC1 int SOAP_FMAC2 soap_peek_element(struct soap*); + +SOAP_FMAC1 void SOAP_FMAC2 soap_retry(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_revert(struct soap*); + +SOAP_FMAC1 char* SOAP_FMAC2 soap_strdup(struct soap*, const char*); +SOAP_FMAC1 const char * SOAP_FMAC2 soap_strsearch(const char *big, const char *little); + +SOAP_FMAC1 int SOAP_FMAC2 soap_string_out(struct soap*, const char *s, int flag); +SOAP_FMAC1 char* SOAP_FMAC2 soap_string_in(struct soap*, int, long, long); + +#ifndef WITH_LEANER +SOAP_FMAC1 int SOAP_FMAC2 soap_wstring_out(struct soap*, const wchar_t *s, int flag); +SOAP_FMAC1 wchar_t* SOAP_FMAC2 soap_wstring_in(struct soap*, int, long, long); +#endif + +SOAP_FMAC1 int SOAP_FMAC2 soap_match_namespace(struct soap*, const char *, const char*, int n1, int n2); + +SOAP_FMAC1 int SOAP_FMAC2 soap_set_namespaces(struct soap*, const struct Namespace*); +SOAP_FMAC1 void SOAP_FMAC2 soap_set_local_namespaces(struct soap*); + +SOAP_FMAC1 void SOAP_FMAC2 soap_pop_namespace(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_push_namespace(struct soap*, const char *,const char *); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_current_namespace(struct soap *soap, const char *tag); + +SOAP_FMAC1 int SOAP_FMAC2 soap_store_lab(struct soap*, const char*, size_t); +SOAP_FMAC1 int SOAP_FMAC2 soap_append_lab(struct soap*, const char*, size_t); + +SOAP_FMAC1 int SOAP_FMAC2 soap_new_block(struct soap*); +SOAP_FMAC1 void* SOAP_FMAC2 soap_push_block(struct soap*, size_t); +SOAP_FMAC1 void SOAP_FMAC2 soap_pop_block(struct soap*); +SOAP_FMAC1 size_t SOAP_FMAC2 soap_size_block(struct soap*, size_t); +SOAP_FMAC1 char* SOAP_FMAC2 soap_first_block(struct soap*); +SOAP_FMAC1 char* SOAP_FMAC2 soap_next_block(struct soap*); +SOAP_FMAC1 size_t SOAP_FMAC2 soap_block_size(struct soap*); +SOAP_FMAC1 char* SOAP_FMAC2 soap_save_block(struct soap*, char*, int); +SOAP_FMAC1 void SOAP_FMAC2 soap_end_block(struct soap*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_envelope_begin_out(struct soap*); +SOAP_FMAC1 int soap_envelope_end_out(struct soap*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_envelope_begin_in(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_envelope_end_in(struct soap*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_body_begin_out(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_body_end_out(struct soap*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_body_begin_in(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_body_end_in(struct soap*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_recv_header(struct soap*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_response(struct soap*, int); + +SOAP_FMAC1 int SOAP_FMAC2 soap_send_empty_response(struct soap*, int status); +SOAP_FMAC1 int SOAP_FMAC2 soap_recv_empty_response(struct soap*); + +SOAP_FMAC1 int SOAP_FMAC2 soap_send_fault(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_recv_fault(struct soap*); + +#ifndef WITH_NOSTDLIB +SOAP_FMAC1 void SOAP_FMAC2 soap_print_fault(struct soap*, FILE*); +SOAP_FMAC1 void SOAP_FMAC2 soap_print_fault_location(struct soap*, FILE*); +#endif + +SOAP_FMAC1 int SOAP_FMAC2 soap_s2byte(struct soap*, const char*, char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2short(struct soap*, const char*, short*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2int(struct soap*, const char*, int*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2long(struct soap*, const char*, long*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2LONG64(struct soap*, const char*, LONG64*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2float(struct soap*, const char*, float*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2double(struct soap*, const char*, double*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2unsignedByte(struct soap*, const char*, unsigned char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2unsignedShort(struct soap*, const char*, unsigned short*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2unsignedInt(struct soap*, const char*, unsigned int*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2unsignedLong(struct soap*, const char*, unsigned long*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2ULONG64(struct soap*, const char*, ULONG64*); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2string(struct soap*, const char*, char**); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2QName(struct soap*, const char*, char**); + +#ifndef WITH_LEAN +SOAP_FMAC1 int SOAP_FMAC2 soap_s2wchar(struct soap*, const char*, wchar_t**); +SOAP_FMAC1 int SOAP_FMAC2 soap_s2dateTime(struct soap*, const char*, time_t*); +SOAP_FMAC1 char* SOAP_FMAC2 soap_s2base64(struct soap*, const unsigned char*, char*, int); +SOAP_FMAC1 char* SOAP_FMAC2 soap_s2hex(struct soap*, const unsigned char*, char*, int); +#endif + +SOAP_FMAC1 const char* SOAP_FMAC2 soap_byte2s(struct soap*, char); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_short2s(struct soap*, short); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_int2s(struct soap*, int); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_long2s(struct soap*, long); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_LONG642s(struct soap*, LONG64); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_float2s(struct soap*, float); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_double2s(struct soap*, double); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_unsignedByte2s(struct soap*, unsigned char); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_unsignedShort2s(struct soap*, unsigned short); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_unsignedInt2s(struct soap*, unsigned int); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_unsignedLong2s(struct soap*, unsigned long); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_ULONG642s(struct soap*, ULONG64); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_QName2s(struct soap*, const char*); + +#ifndef WITH_LEAN +SOAP_FMAC1 const char* SOAP_FMAC2 soap_wchar2s(struct soap*, const wchar_t*); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_dateTime2s(struct soap*, time_t); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_base642s(struct soap*, const char*, char*, size_t, int*); +SOAP_FMAC1 const char* SOAP_FMAC2 soap_hex2s(struct soap*, const char*, char*, size_t, int*); +#endif + + +SOAP_FMAC1 int* SOAP_FMAC2 soap_inint(struct soap*, const char *tag, int *p, const char *, int); +SOAP_FMAC1 char* SOAP_FMAC2 soap_inbyte(struct soap*, const char *tag, char *p, const char *, int); +SOAP_FMAC1 long* SOAP_FMAC2 soap_inlong(struct soap*, const char *tag, long *p, const char *, int); +SOAP_FMAC1 LONG64* SOAP_FMAC2 soap_inLONG64(struct soap*, const char *tag, LONG64 *p, const char *, int); +SOAP_FMAC1 short* SOAP_FMAC2 soap_inshort(struct soap*, const char *tag, short *p, const char *, int); +SOAP_FMAC1 float* SOAP_FMAC2 soap_infloat(struct soap*, const char *tag, float *p, const char *, int); +SOAP_FMAC1 double* SOAP_FMAC2 soap_indouble(struct soap*, const char *tag, double *p, const char *, int); +SOAP_FMAC1 unsigned char* SOAP_FMAC2 soap_inunsignedByte(struct soap*, const char *tag, unsigned char *p, const char *, int); +SOAP_FMAC1 unsigned short* SOAP_FMAC2 soap_inunsignedShort(struct soap*, const char *tag, unsigned short *p, const char *, int); +SOAP_FMAC1 unsigned int* SOAP_FMAC2 soap_inunsignedInt(struct soap*, const char *tag, unsigned int *p, const char *, int); +SOAP_FMAC1 unsigned long* SOAP_FMAC2 soap_inunsignedLong(struct soap*, const char *tag, unsigned long *p, const char *, int); +SOAP_FMAC1 ULONG64* SOAP_FMAC2 soap_inULONG64(struct soap*, const char *tag, ULONG64 *p, const char *, int); +SOAP_FMAC1 char** SOAP_FMAC2 soap_instring(struct soap*, const char *tag, char **p, const char *, int, int, long, long); +SOAP_FMAC1 char** SOAP_FMAC2 soap_inliteral(struct soap*, const char *tag, char **p); + +#ifndef WITH_LEAN +SOAP_FMAC1 time_t* SOAP_FMAC2 soap_indateTime(struct soap*, const char *tag, time_t *p, const char *, int); +#endif + +#ifndef WITH_LEANER +SOAP_FMAC1 wchar_t** SOAP_FMAC2 soap_inwstring(struct soap*, const char *tag, wchar_t **p, const char *, int, long, long); +SOAP_FMAC1 wchar_t** SOAP_FMAC2 soap_inwliteral(struct soap*, const char *tag, wchar_t **p); +#endif + +SOAP_FMAC1 int SOAP_FMAC2 soap_outbyte(struct soap*, const char *tag, int id, const char *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outshort(struct soap*, const char *tag, int id, const short *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outint(struct soap*, const char *tag, int id, const int *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outlong(struct soap*, const char *tag, int id, const long *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outLONG64(struct soap*, const char *tag, int id, const LONG64 *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outfloat(struct soap*, const char *tag, int id, const float *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outdouble(struct soap*, const char *tag, int id, const double *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outunsignedByte(struct soap*, const char *tag, int id, const unsigned char *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outunsignedShort(struct soap*, const char *tag, int id, const unsigned short *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outunsignedInt(struct soap*, const char *tag, int id, const unsigned int *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outunsignedLong(struct soap*, const char *tag, int id, const unsigned long *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outULONG64(struct soap*, const char *tag, int id, const ULONG64 *p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outstring(struct soap*, const char *tag, int id, char *const*p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outliteral(struct soap*, const char *tag, char *const*p, const char *type); + +#ifndef WITH_LEAN +SOAP_FMAC1 int SOAP_FMAC2 soap_outdateTime(struct soap*, const char *tag, int id, const time_t *p, const char *, int); +#endif + +#ifndef WITH_LEANER +SOAP_FMAC1 int SOAP_FMAC2 soap_outwstring(struct soap*, const char *tag, int id, wchar_t *const*p, const char *, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_outwliteral(struct soap*, const char *tag, wchar_t *const*p, const char *type); +#endif + +#ifndef WITH_LEANER +SOAP_FMAC1 int SOAP_FMAC2 soap_attachment(struct soap *, const char*, int, const void*, const struct soap_array*, const char*, const char*, const char*, int, const char*, int); +SOAP_FMAC1 int SOAP_FMAC2 soap_move(struct soap*, long); +SOAP_FMAC1 size_t SOAP_FMAC2 soap_tell(struct soap*); +SOAP_FMAC1 char* SOAP_FMAC2 soap_dime_option(struct soap*, unsigned short, const char*); +SOAP_FMAC1 int SOAP_FMAC2 soap_getdimehdr(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_getdime(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_putdimehdr(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_putdime(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_getmimehdr(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_getmime(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_putmimehdr(struct soap*, struct soap_multipart*); +SOAP_FMAC1 int SOAP_FMAC2 soap_putmime(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_set_dime(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_set_mime(struct soap*, const char *boundary, const char *start); +SOAP_FMAC1 void SOAP_FMAC2 soap_clr_dime(struct soap*); +SOAP_FMAC1 void SOAP_FMAC2 soap_clr_mime(struct soap*); +SOAP_FMAC1 int SOAP_FMAC2 soap_set_dime_attachment(struct soap*, char *ptr, size_t size, const char *type, const char *id, unsigned short optype, const char *option); +SOAP_FMAC1 int SOAP_FMAC2 soap_set_mime_attachment(struct soap*, char *ptr, size_t size, enum soap_mime_encoding encoding, const char *type, const char *id, const char *location, const char *description); +SOAP_FMAC1 void SOAP_FMAC2 soap_post_check_mime_attachments(struct soap *soap); +SOAP_FMAC1 int SOAP_FMAC2 soap_check_mime_attachments(struct soap *soap); +SOAP_FMAC1 struct soap_multipart* SOAP_FMAC2 soap_get_mime_attachment(struct soap *soap, void *handle); +SOAP_FMAC1 struct soap_multipart* SOAP_FMAC2 soap_next_multipart(struct soap_multipart*); +SOAP_FMAC1 int SOAP_FMAC2 soap_match_cid(struct soap*, const char*, const char*); +#endif + +SOAP_FMAC1 int SOAP_FMAC2 soap_register_plugin_arg(struct soap*, int (*fcreate)(struct soap*, struct soap_plugin*, void*), void*); +SOAP_FMAC1 void* SOAP_FMAC2 soap_lookup_plugin(struct soap*, const char*); + +SOAP_FMAC1 const char* SOAP_FMAC2 soap_attr_value(struct soap *soap, const char *name, int flag); +SOAP_FMAC1 int SOAP_FMAC2 soap_set_attr(struct soap *soap, const char *name, const char *value); +SOAP_FMAC1 void SOAP_FMAC2 soap_clr_attr(struct soap *soap); + +#ifdef WITH_COOKIES +SOAP_FMAC1 size_t SOAP_FMAC2 soap_encode_cookie(const char*, char*, size_t); +SOAP_FMAC1 extern struct soap_cookie* SOAP_FMAC2 soap_set_cookie(struct soap*, const char*, const char*, const char*, const char*); +SOAP_FMAC1 extern struct soap_cookie* SOAP_FMAC2 soap_cookie(struct soap*, const char*, const char*, const char*); +SOAP_FMAC1 extern char* SOAP_FMAC2 soap_cookie_value(struct soap*, const char*, const char*, const char*); +SOAP_FMAC1 extern char* SOAP_FMAC2 soap_env_cookie_value(struct soap*, const char*, const char*, const char*); +SOAP_FMAC1 extern time_t SOAP_FMAC2 soap_cookie_expire(struct soap*, const char*, const char*, const char*); +SOAP_FMAC1 extern int SOAP_FMAC2 soap_set_cookie_expire(struct soap*, const char*, long, const char*, const char*); +SOAP_FMAC1 extern int SOAP_FMAC2 soap_set_cookie_session(struct soap*, const char*, const char*, const char*); +SOAP_FMAC1 extern int SOAP_FMAC2 soap_clr_cookie_session(struct soap*, const char*, const char*, const char*); +SOAP_FMAC1 extern void SOAP_FMAC2 soap_clr_cookie(struct soap*, const char*, const char*, const char*); +SOAP_FMAC1 extern int SOAP_FMAC2 soap_getenv_cookies(struct soap*); +SOAP_FMAC1 extern struct soap_cookie* SOAP_FMAC2 soap_copy_cookies(struct soap*, struct soap*); +SOAP_FMAC1 extern void SOAP_FMAC2 soap_free_cookies(struct soap*); +#endif + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif + diff --git a/pcucontrol/models/intelamt/Makefile b/pcucontrol/models/intelamt/Makefile new file mode 100644 index 0000000..d7ca4b6 --- /dev/null +++ b/pcucontrol/models/intelamt/Makefile @@ -0,0 +1,43 @@ +CC = g++ +LIBTOOL = libtool +ARCH := $(shell uname -m | sed 's/i.86/i386/') +X64FLAGS = -Wlong-long -Wformat -Wpointer-arith +CFLAGS = -Dlinux -Wall -Wno-deprecated +SSL = -DWITH_OPENSSL + +ifeq ($(ARCH),x86_64) + FLAGS = $(CFLAGS) $(X64FLAGS) $(SSL) +else + FLAGS = $(CFLAGS) $(SSL) +endif + +CFLAGS = -Dlinux -Wall -Wno-deprecated $(SSL) +GSOAP_PATH = ./ +GSOAP_CODE = ./ +INC_PATH = ./Include +SRC_PATH = ./ +INCLUDE = -I$(GSOAP_PATH) -I$(INC_PATH) -I$(GSOAP_CODE) +SRCS = $(GSOAP_CODE)/soapClient.cpp $(GSOAP_CODE)/soapC.cpp $(GSOAP_PATH)/stdsoap2.cpp $(GSOAP_PATH)/httpDigest.cpp $(GSOAP_PATH)/digcalc.cpp RemoteControlSample.cpp +OBJS = $(SRCS:.cpp=.o) Utils.o +LIBS = -lssl +APPNAME = remoteControl +WSDL2H = $(GSOAP_PATH)/wsdl2h +SOAPCPP = $(GSOAP_PATH)/soapcpp2 +all: clean $(APPNAME) + +$(APPNAME): $(OBJS) + $(LIBTOOL) --mode=link $(CC) $(FLAGS) $(INCLUDE) -o $(APPNAME) $(OBJS) $(LIBS) + +Utils.o: $(SRC_PATH)/Utils.cpp + $(CC) $(CFLAGS) $(INCLUDE) -c $(SRC_PATH)/Utils.cpp -o Utils.o + +%.o: %.cpp + $(CC) $(FLAGS) $(INCLUDE) -c $< -o $@ + +clean: + rm -f $(OBJS) $(APPNAME) *~ + rm -rf .libs + #dos2unix *.h + #dos2unix *.cpp + #dos2unix README + #dos2unix Makefile diff --git a/pcucontrol/models/intelamt/README b/pcucontrol/models/intelamt/README new file mode 100644 index 0000000..efca81f --- /dev/null +++ b/pcucontrol/models/intelamt/README @@ -0,0 +1,34 @@ +//---------------------------------------------------------------------------- +// +// Copyright (C) Intel Corporation, 2003 - 2007. +// +// File: README +// +// Contents: Intel(R) Active Management Technology (Intel(R) AMT): +// A short description of the Remote Control +// sample code for the usage of developers +// +//---------------------------------------------------------------------------- + +Remote Control sample application: +---------------------------------- +This sample application demonstrates how to retrieve information +about the Intel® AMT device capabilities and the power state +of the remote machine, and how to control remotely the boot +and power state of the managed PC. + + +How to run the sample (X32 and X64 environment): +------------------------------------------------ +1. Run "make" from a command prompt. "remoteControl" should be created. +2. Make sure that the Intel(R) AMT device has been activated on the target + machine. +3. Use the generated executable as described in the command usage (type the + command to obtain the usage instructions). + +Notes: +------ +1. This sample uses gSOAP library. +2. In order to compile the sample code it is essential to put the directories + ThirdParty, Include, Lib, Src and Samples in the same structure as in the + Intel® AMT SDK. diff --git a/pcucontrol/models/intelamt/RemoteControlSample.cpp b/pcucontrol/models/intelamt/RemoteControlSample.cpp new file mode 100644 index 0000000..161738a --- /dev/null +++ b/pcucontrol/models/intelamt/RemoteControlSample.cpp @@ -0,0 +1,950 @@ +//---------------------------------------------------------------------------- +// +// Copyright (C) Intel Corporation, 2004 - 2006. +// +// File: RemoteControlSample.cpp +// +// Contents: Sample code for an Intel® AMT Network client. +// +// Notes: this file contains routines that call (using SOAP) +// the RemoteControl functions of the Intel(R) AMT 2.0 as +// defined in the "Intel(R) AMT Network Design Guide". +// +//---------------------------------------------------------------------------- + +#include "CommonDefinitions.h" +#include "RemoteControlTypes.h" +#include "RemoteControlSoapBinding.nsmap" + +/* + * Function prototypes + */ +void Usage(char *cmd); +bool GetUserValues(uint8 *&command, uint32 *&ianaOemNumber, + uint8 *&specialCommand, uint16 *&specialCommandParameter, + uint16 *&bootOptions, uint16 *&OEMParameters); +void DisplaySystemCapabilities(uint8 specialCommandsSupported); +void DisplaySpecialCommand(uint16 specialCommandsSupported); +void DisplaySystemFirmwareCapabilities(uint32 systemFirmwareCapabilities); +void DisplayOemDefinedCapabilities(uint32 OemDefinedCapabilities); +bool ExecuteGetSystemPowerstate(Soap *server, bool verbose = true); +bool ExecuteGetRemoteControlCapabilities(Soap *server, bool verbose = true); +bool ExecuteRemoteControl(Soap *server, bool default_val = false, uint8 icommand=Reset); +bool MainFlow(Soap *server,int option,bool verbose); +bool ValidateOption(char *option, int *parameter); + +/* + * This is the main entry point + */ +int main(int argc, char* argv[]) +{ + // Command line parameter + char *option = NULL; + // Client certificate's name + char *certName = NULL; +#ifndef _WIN32 + // Password for keys file openning + char *certPass = NULL; +#else + // True if an authentication scheme is Kerberos, + // otherwise the authentication scheme is digest + bool krb = true; +#endif + // Target URL + char *target = NULL; + // Target username + char *username = NULL; + // Target password + char *password = NULL; + // Command line without app name and parameter + char **commandLine = NULL; + int commandLineLength = argc; + int parameter; + bool verbose = false; + + + if( !GetOption(&commandLineLength,argv, + MIN_NUM_OF_CL_PARAMETERS,&option,&commandLine) || + !ValidateOption(option,¶meter) || +#ifndef _WIN32 + !ParseCommandLine(commandLineLength,commandLine,&target, + &certName,&certPass,&verbose,&username,&password) +#else + !ParseCommandLine(commandLineLength,commandLine,&target, + &certName,NULL,&krb,&verbose,&username,&password) +#endif + ) + { + Usage(argv[0]); + return 1; + } + + // The last parameter should be true for local application + // and false for remote application +#ifndef _WIN32 + Soap server(target,certName,certPass,username,password); +#else + Soap server(target,certName,username,password,false,krb); +#endif + + if(MainFlow(&server,parameter,verbose) != true) + { + return 1; + } + return 0; +} + +/* + * Validates an option passed in the command line. + * Arguments: + * option - command line option + * parameter - pointer to the variable that will hold + * type of the action the apllication + * will perform. + * Return value: + * true - on succeed + * false - on failure (command line option not recognized) + */ +bool ValidateOption(char *option, int *parameter) +{ + if(!option) + { + return false; + } + bool status = true; + if(!strcmp(option,POWER)) + { + *parameter = OPT_POWER; + } + else if(!strcmp(option,CAPABILITIES)) + { + *parameter = OPT_CAPABILITIES; + } + else if(!strcmp(option,REMOTE)) + { + *parameter = OPT_REMOTE; + } + else if(!strcmp(option,API_TEST)) + { + *parameter = OPT_API_TEST; + } + else if(!strcmp(option,REDUCED_API_TEST)) + { + *parameter = OPT_REDUCED_API_TEST; + } + else + { + status = false; + } + return status; +} + +/* + * Function that performs the main flow of Remote Control sample + * Arguments: + * soap - pointer to the runtime environment + * option - variable that holds type of the action the apllication + * will perform + * verbose - boolean value for API test + * Return value: + * true - on success + * false - on failure + */ +bool MainFlow(Soap *server, int option, bool verbose) +{ + bool status = true; + switch(option) + { + case OPT_POWER: + status = ExecuteGetSystemPowerstate(server); + break; + case OPT_CAPABILITIES: + status = ExecuteGetRemoteControlCapabilities(server); + break; + case OPT_REMOTE: + status = ExecuteRemoteControl(server); + break; + case OPT_API_TEST: + if((status = ExecuteGetSystemPowerstate(server,verbose)) == false) + { + return status; + } + if((status = ExecuteGetRemoteControlCapabilities(server,verbose)) == false) + { + return status; + } + /* Ensure that the machine is powered up before trying to + * 'reset' it, since a reset on a down node will fail. */ + /*if ((status = ExecuteRemoteControl(server,true,PowerDown)) == false) + { + return status; + } + sleep(10); */ + if ((status = ExecuteRemoteControl(server,true,PowerUp)) == false) + { + return status; + } + sleep(5); + if ((status = ExecuteRemoteControl(server,true,Reset)) == false) + { + return status; + } + break; + case OPT_REDUCED_API_TEST: + if((status = ExecuteGetSystemPowerstate(server,verbose)) == false) + { + return status; + } + if((status = ExecuteGetRemoteControlCapabilities(server,verbose)) == false) + { + return status; + } + break; + default: + status = false; + } + + return status; +} + +/* + * Prints a usage information for the user. + */ +void Usage(char *cmd) +{ + printf("Usage:\n"); +#ifndef _WIN32 + printf("\t %s [%s] [%s %s ] http[s]:", cmd, VERBOSE, CERT_NAME, CERT_PASS); +#else + printf("\t %s [%s] [%s %s ] [%s ] http[s]:", + cmd, VERBOSE, USER, PASS, CERT_NAME); +#endif + printf("//:/ "); +#ifndef _WIN32 + printf("[%s %s ]\n",USER,PASS); +#endif + printf("\nWhere is :\n"); + printf("\t %s : GetSystemPowerstate\n",POWER); + printf("\t %s : GetRemoteControlCapabilities\n",CAPABILITIES); + printf("\t %s : RemoteControl\n",REMOTE); + printf("\t %s : perform API test\n",API_TEST); + printf("\t %s : perform API test without boot\n",REDUCED_API_TEST); + printf("\t To run API test in verbose mode include %s option\n", VERBOSE); + PrintAuthenticationNote(); + printf("\nExample:\n"); + printf("\t %s %s ", cmd, POWER); + printf("http://hostname:16992/RemoteControlService\n"); +#ifndef _WIN32 + printf("\t %s %s %s MyCert %s Pass https://hostname:16993/RemoteControlService\n", + cmd, POWER, CERT_NAME, CERT_PASS); +#else + printf("\t %s %s %s MyCert https://hostname:16993/RemoteControlService\n", + cmd, POWER, CERT_NAME); +#endif +} + +/* + * Queries (using SOAP) and display the system power state + * Arguments: + * server - pointer to the runtime environment + * url - address of the web service + * verbose - boolean value for API test + * Return value: + * true - on success + * false - on failure + */ +bool ExecuteGetSystemPowerstate(Soap* server, bool verbose) +{ + int res; + bool status; + + server->Init(); + + // gSOAP structures for handling + // request and response information + _rci__GetSystemPowerState request; + _rci__GetSystemPowerStateResponse response; + + FunctionCall("GetSystemPowerState"); + res = soap_call___rci__GetSystemPowerState(server->GetSoap(), + server->GetIp(),NULL, &request, &response); + + if((status = + CheckReturnStatus(res, + response.Status, + "GetSystemPowerState")) == true) + { + if(verbose) + { + printf("\nSystemPowerstate is: %u\n", response.SystemPowerState); + } + else + { + PrintSuccess(); + } + } + + return status; +} + +/* + * Queries (using SOAP) and display the Intel(R) AMT + * device remote control capabilities + * Arguments: + * server - pointer to the runtime environment + * url - address of the web service + * verbose - boolean value for API test + * Return value: + * true - on success + * false - on failure + */ +bool ExecuteGetRemoteControlCapabilities(Soap* server, bool verbose) +{ + int res; + bool status; + + server->Init(); + + // gSOAP structures for handling + // request and response information + _rci__GetRemoteControlCapabilities request; + _rci__GetRemoteControlCapabilitiesResponse response; + + FunctionCall("GetRemoteControlCapabilities"); + res = soap_call___rci__GetRemoteControlCapabilities(server->GetSoap(), + server->GetIp(),NULL, &request, &response); + + if((status = CheckReturnStatus(res,response.Status,"GetRemoteControlCapabilities")) == true) + { + if(verbose) + { + printf("\nRemote Control Capabilities\n"); + printf("---------------------------------------\n"); + + printf("IanaOemNumber = %u\n", response.IanaOemNumber); + + DisplayOemDefinedCapabilities(response.OemDefinedCapabilities); + + printf("\n"); + DisplaySpecialCommand(response.SpecialCommandsSupported); + + printf("\n"); + DisplaySystemCapabilities(response.SystemCapabilitiesSupported); + + printf("\n"); + DisplaySystemFirmwareCapabilities(response.SystemFirmwareCapabilities); + + printf("\n"); + } + else + { + PrintSuccess(); + } + } + + return status; +} + +/* + * Controls remotely (using SOAP) the boot and power state of + * Intel(R) AMT-managed PC. + * Arguments: + * server - pointer to the runtime environment + * url - address of the web service + * def_values - if false request values from user + * Return value: + * true - on success + * false - on failure + */ +bool ExecuteRemoteControl(Soap* server,bool def_values, uint8 icommand) +{ + int res; + bool status = true; + + server->Init(); + + // gSOAP structures for handling + // request and response information + _rci__RemoteControl request; + _rci__RemoteControlResponse response; + + // example values + uint8 *command = new uint8(icommand); + uint32 *ianaOemNumber = new uint32(IntelIanaNumber); + uint8 *specialCommand = NULL; //none + uint16 *oemParameter = NULL; //none + uint16 *bootOptions = NULL; //none + uint16 *specialCommandParameters = NULL; //none + + if(!def_values) + { + // To use default values above, comment the following line. + if(!GetUserValues(command, ianaOemNumber, specialCommand, oemParameter, + bootOptions, specialCommandParameters)) + { + status = false; + } + } + + if(status == true) + { + switch(*command) + { + case Reset: + request.Command = rci__RemoteControlCommandType__16; + break; + case PowerUp: + request.Command = rci__RemoteControlCommandType__17; + break; + case PowerDown: + request.Command = rci__RemoteControlCommandType__18; + break; + case PowerCycleReset: + request.Command = rci__RemoteControlCommandType__19; + break; + case SetBootOptions: + request.Command = rci__RemoteControlCommandType__33; + break; + default: + break; + } + + if(specialCommand == NULL) + { + request.SpecialCommand = NULL; + } + else + { + request.SpecialCommand = new rci__SpecialCommandType; + switch(*specialCommand) + { + case NOP: + *(request.SpecialCommand) = rci__SpecialCommandType__0; + break; + case ForcePxeBoot: + *(request.SpecialCommand) = rci__SpecialCommandType__1; + break; + case ForceHardDriveBoot: + *(request.SpecialCommand) = rci__SpecialCommandType__2; + break; + case ForceHardDriveSafeModeBoot: + *(request.SpecialCommand) = rci__SpecialCommandType__3; + break; + case ForceDiagnosticsBoot: + *(request.SpecialCommand) = rci__SpecialCommandType__4; + break; + case ForceCdOrDvdBoot: + *(request.SpecialCommand) = rci__SpecialCommandType__5; + break; + case IntelOemCommand: + *(request.SpecialCommand) = rci__SpecialCommandType__193; + break; + default: + break; + } + } + + request.IanaOemNumber = *ianaOemNumber; + request.BootOptions = bootOptions; + request.OEMparameters = oemParameter; + request.SpecialCommandParameter = specialCommandParameters; + + FunctionCall("RemoteControl"); + res = soap_call___rci__RemoteControl(server->GetSoap(), + server->GetIp(),NULL, &request, &response); + + if((status = CheckReturnStatus(res,response.Status,"RemoteControl")) == true) + { + PrintSuccess(); + } + + if(request.SpecialCommand != NULL) + { + delete request.SpecialCommand; + request.SpecialCommand = NULL; + } + } + + // cleanup heap allocated memory + if(command != NULL) + { + delete command; + command = NULL; + } + if(ianaOemNumber != NULL) + { + delete ianaOemNumber; + ianaOemNumber = NULL; + } + if(specialCommand != NULL) + { + delete specialCommand; + specialCommand = NULL; + } + if(oemParameter != NULL) + { + delete oemParameter; + oemParameter = NULL; + } + if(bootOptions != NULL) + { + delete bootOptions; + bootOptions = NULL; + } + if(specialCommandParameters != NULL) + { + delete specialCommandParameters; + specialCommandParameters = NULL; + } + + return status; +} + +/* + * Get user's settings for the RemoteControl function + * Arguments & return values: + * command - specifies the boot or power state operation to be performed + * ianaOemNumber - specifies an IANA-assigned Enterprise Number + * specialCommand - specifies an optional modification to the boot behavior + * OemParameter - specifies Intel® AMT proprietary boot options + * bootOptions - specifies standard boot options + * specialCommandParameters - specifies an optional modification to the + * boot behavior + * Return value: + * true - on success + * false - on failure + */ +bool GetUserValues(uint8 *&command, uint32 *&ianaOemNumber, + uint8 *&specialCommand, uint16 *&oemParameter, + uint16 *&bootOptions, uint16 *&specialCommandParameters) +{ + uint32 tmp; + + printf("Please specify the following parameters\n"); + + // Get mandatory parameters + + // Get Command + printf("\n\tCommand"); + printf("\n\t======="); + printf("\nPossible values:"); + printf("\n\t%u (Reset)",Reset); + printf("\n\t%u (PowerUp)",PowerUp); + printf("\n\t%u (PowerDown)",PowerDown); + printf("\n\t%u (PowerCycleReset)",PowerCycleReset); + printf("\n\t%u (SetBootOptions)\n>",SetBootOptions); + scanf("%u", &tmp); + + // verify command value + if ( tmp == Reset || + tmp == PowerUp || + tmp == PowerDown || + tmp == PowerCycleReset || + tmp == SetBootOptions) + { + // sanity check + if ( command == NULL ) + { + command = new uint8(); + } + *command = (uint8)tmp; + } + else + { + goto ILLEGAL_INPUT; + } + + // If command is Set Boot Options, ianaOemNumber + // should be IntelIanaNumber. + if( *command == SetBootOptions ) + { + // sanity check + if ( ianaOemNumber == NULL ) + { + ianaOemNumber = new uint32(); + } + + printf("\nSetBootOptions command selected. "); + printf("Iana OEM Number is IntelIanaNumber (%u)\n",IntelIanaNumber); + + *ianaOemNumber = (uint32)IntelIanaNumber; + + } + else + { + // Get Iana number + printf("\n\tIana OEM Number"); + printf("\n\t==============="); + printf("\nPossible values:"); + printf("\n\t%u (IntelIanaNumber)", IntelIanaNumber); + printf("\n\t%u (ASFIanaNumber)\n>", ASFIanaNumber); + scanf("%u", &tmp); + + // verify ianaOemNumber value + if ( tmp == IntelIanaNumber || + tmp == ASFIanaNumber ) + { + // sanity check + if ( ianaOemNumber == NULL ) + { + ianaOemNumber = new uint32(); + } + *ianaOemNumber = (uint32)tmp; + } + else + { + goto ILLEGAL_INPUT; + } + } + + // if power down, all other parameters should not be sent. + if ( *command == PowerDown ) + { + specialCommand = NULL; + oemParameter = NULL; + bootOptions = NULL; + specialCommandParameters = NULL; + return true; + } + + // Get optional parameters + + // Get Special Command + printf("\n\tSpecial Command"); + printf("\n\t==============="); + printf("\nPossible values:"); + + printf("\n\t%d (No Special Command)",-1); + printf("\n\t%u (NOP)",NOP); + printf("\n\t%u (ForcePxeBoot)",ForcePxeBoot); + printf("\n\t%u (ForceHardDriveBoot)",ForceHardDriveBoot); + printf("\n\t%u (ForceHardDriveSafeModeBoot)",ForceHardDriveSafeModeBoot); + printf("\n\t%u (ForceDiagnosticsBoot)",ForceDiagnosticsBoot); + printf("\n\t%u (ForceCdOrDvdBoot)",ForceCdOrDvdBoot); + printf("\n\t%u (IntelOemCommand)\n>",IntelOemCommand); + scanf("%u", &tmp); + + // verify specialCommand value + if ( tmp == NO_VALUE || + tmp == NOP || + tmp == ForcePxeBoot || + tmp == ForceHardDriveBoot || + tmp == ForceHardDriveSafeModeBoot || + tmp == ForceDiagnosticsBoot || + tmp == ForceCdOrDvdBoot || + tmp == IntelOemCommand ) + { + if ( tmp == NO_VALUE ) + { + specialCommand = NULL; + } + else if(tmp == IntelOemCommand && + *ianaOemNumber != IntelIanaNumber) + { + printf("Error: Special Command value %d is legal", IntelOemCommand); + printf(" only for IanaOemNumber value %d", IntelIanaNumber); + exit(1); + } + else + { + // sanity check + if ( specialCommand == NULL ) + { + specialCommand = new uint8(); + } + *specialCommand = (uint8)tmp; + } + } + else + { + goto ILLEGAL_INPUT; + } + + // Get OEM Parameter + // if ianaOemNumber is ASFIanaNumber, oemParameters should not be sent . + if ( *ianaOemNumber != IntelIanaNumber ) + { + oemParameter = NULL; + } + else + { + printf("\n\tOEM Parameters"); + printf("\n\t=============="); + printf("\nPossible values:"); + printf("\n\t%d (No OEM Parameters)",-1); + printf("\n\t%d (Undefined OEM Parameter)",UndefinedOEMParameter); + printf("\n\t%u (UseSol)\n>",UseSol); + scanf("%u", &tmp); + if ( tmp == NO_VALUE ) + { + oemParameter = NULL; + } + else + { + // sanity check + if ( oemParameter == NULL ) + { + oemParameter = new uint16(); + } + *oemParameter = (uint16) tmp; + } + } + + // Get Special Command Parameters + printf("\n\tSpecial Command Parameters"); + printf("\n\t=========================="); + printf("\nPossible values:"); + + // Special Command is not equal to 0xC1 (IntelOemCommand) + if ( specialCommand == NULL || + (specialCommand != NULL) && (*specialCommand != IntelOemCommand) ) + { + printf("\n\tSpecial command not equal to %d",IntelOemCommand); + printf("\n\tSee ASF specification for the Special Command Parameter legal values"); + printf("\n\n\t%d (No Special Command Parameter)\n>",-1); + scanf("%u", &tmp); + } + // Special Command is 0xC1, hence Special Command Parameter + // used to augment the Special Command + else + { + printf("\n\t%d (No Special Command Parameter)",-1); + printf("\n\t%d (Undefined Special Command Parameter)", + UndefinedSpecialCommandParameter); + printf("\n\t%u (UseIderFloppy)",UseIderFloppy); + printf("\n\t%u (ReflashBios)",ReflashBios); + printf("\n\t%u (BiosSetup)",BiosSetup); + printf("\n\t%u (BiosPause)",BiosPause); + printf("\n\t%u (UseIderCD)\n",UseIderCD); + + printf("\nYou can choose several options by using bitwise OR operation\n\n>"); + scanf("%u", &tmp); + + // verify specialCommandParameters value + if ( (tmp != NO_VALUE) && (tmp & SpecialCommandParametersReservedBits) ) + { + goto ILLEGAL_INPUT; + } + } + + if ( tmp == NO_VALUE ) + { + specialCommandParameters = NULL; + } + else + { + // sanity check + if ( specialCommandParameters == NULL ) + { + specialCommandParameters = new uint16(); + } + *specialCommandParameters = (uint16)tmp; + } + + + + // Get Boot Options + printf("\n\tBoot Options"); + printf("\n\t============"); + printf("\nPossible values:"); + + printf("\n\t%d (No boot options)", -1); + printf("\n\t%u (LockPowerButton)",LockPowerButton); + printf("\n\t%u (LockResetButton)",LockResetButton); + printf("\n\t%u (LockKeyboard)",LockKeyboard); + printf("\n\t%u (LockSleepButton)",LockSleepButton); + printf("\n\t%u (UserPasswordBypass)",UserPasswordBypass); + printf("\n\t%u (ForceProgressEvents)",ForceProgressEvents); + + printf("\n\n\tFirmware Verbosity Options:"); + printf( "\n\t---------------------------"); + printf("\n\t%u (FirmwareVerbositySystemDefault)",FirmwareVerbositySystemDefault); + printf("\n\t%u (FirmwareVerbosityQuiet)",FirmwareVerbosityQuiet); + printf("\n\t%u (FirmwareVerbosityVerbose)",FirmwareVerbosityVerbose); + printf("\n\t%u (FirmwareVerbosityScreen)",FirmwareVerbosityScreen); + printf("\n\n\t%u (ConfigurationDataReset)\n",ConfigurationDataReset); + + printf("\nYou can choose several options by using bitwise OR operation\n\n>"); + scanf("%u", &tmp); + + // verify bootOptions value + if ( (tmp != NO_VALUE) && (tmp & BootOptionsReservedBits) ) + { + goto ILLEGAL_INPUT; + } + else + { + if ( tmp == NO_VALUE ) + { + bootOptions = NULL; + } + else + { + // sanity check + if ( bootOptions == NULL ) + { + bootOptions = new uint16(); + } + *bootOptions = (uint16)tmp; + } + } + return true; + + ILLEGAL_INPUT: + printf("Error: %u is an illegal value. Aborting.\n", tmp); + return false; +} + +/* + * Prints system capabilities supported by the Intel(R) AMT device + * Arguments: + * systemCapabilitiesSupported - set of flags that indicate the values + * the Intel(R) AMT device supports in the + * Command parameter of the RemoteControl method + */ +void DisplaySystemCapabilities(uint8 systemCapabilitiesSupported) +{ + printf("\nSystemCapabilitiesSupported = %u", systemCapabilitiesSupported); + + if ( systemCapabilitiesSupported & SuppPowerCycleReset ) + { + printf("\nPowerCycleReset "); + } + if ( systemCapabilitiesSupported & SuppPowerDown ) + { + printf("\nPowerDown "); + } + if ( systemCapabilitiesSupported & SuppPowerUp ) + { + printf("\nPowerUp "); + } + if ( systemCapabilitiesSupported & SuppReset ) + { + printf("\nReset"); + } +} + +/* + * Prints special commands supported by the Intel(R) AMT device + * Arguments: + * specialCommandsSupported - set of flags that indicate the values + * the Intel(R) AMT device supports in the + * SpecialCommand parameter of the + * RemoteControl method + */ +void DisplaySpecialCommand(uint16 specialCommandsSupported) +{ + printf("\nSpecialCommandsSupported = %u", specialCommandsSupported); + + if ( specialCommandsSupported & SuppForcePXEBoot ) + { + printf("\nForcePXEBoot "); + } + if ( specialCommandsSupported & SuppForceHardDriveBoot ) + { + printf("\nForceHardDriveBoot "); + } + if ( specialCommandsSupported & SuppForceHardDriveSafeModeBoot ) + { + printf("\nForceHardDriveSafeModeBoot "); + } + if ( specialCommandsSupported & SuppForceDiagnosticBoot ) + { + printf("\nForceDiagnosticBoot "); + } + if ( specialCommandsSupported & SuppForceCDorDVDBoot ) + { + printf("\nForceCDorDVDBoot"); + } +} + + +/* + * Prints firmware capabilities supported by the Intel(R) AMT device + * Arguments: + * systemCapabilitiesSupported - set of flags that indicate the values + * the Intel(R) AMT device supports in the + * BootOptions parameter of the RemoteControl + * method + */ +void DisplaySystemFirmwareCapabilities(uint32 systemFirmwareCapabilities) +{ + printf("\nSystemFirmwareCapabilities = %u", systemFirmwareCapabilities); + + if ( systemFirmwareCapabilities & SuppVerbosityScreenBlank ) + { + printf("\nVerbosityScreenBlank "); + } + if ( systemFirmwareCapabilities & SuppPowerButtonLock ) + { + printf("\nPowerButtonLock "); + } + if ( systemFirmwareCapabilities & SuppResetButtonLock ) + { + printf("\nResetButtonLock "); + } + if ( systemFirmwareCapabilities & SuppKeyboardLock ) + { + printf("\nKeyboardLock "); + } + if ( systemFirmwareCapabilities & SuppSleepButtonLock ) + { + printf("\nSleepButtonLock "); + } + if ( systemFirmwareCapabilities & SuppUserPasswordBypass ) + { + printf("\nUserPasswordBypass "); + } + if ( systemFirmwareCapabilities & SuppForcedProgressEvents ) + { + printf("\nForcedProgressEvents "); + } + if ( systemFirmwareCapabilities & SuppVerbosityVerbose ) + { + printf("\nVerbosityVerbose "); + } + if ( systemFirmwareCapabilities & SuppVerbosityQuiet ) + { + printf("\nVerbosityQuiet "); + } + if ( systemFirmwareCapabilities & SuppConfigurationDataReset ) + { + printf("\nConfigurationDataReset"); + } +} + + +/* + * Prints OEM defined capabilities supported by the Intel(R) AMT device + * Arguments: + * systemCapabilitiesSupported - set of flags that indicate the values + * the Intel(R) AMT device supports in the + * OemParameters parameter of the RemoteControl + * method + */ +void DisplayOemDefinedCapabilities(uint32 oemDefinedCapabilities) +{ + printf("\nOemDefinedCapabilities = %u", oemDefinedCapabilities); + + if ( oemDefinedCapabilities & SuppIDER ) + { + printf("\nIDER"); + } + if ( oemDefinedCapabilities & SuppSOL ) + { + printf("\nSOL"); + } + if ( oemDefinedCapabilities & SuppBiosReflash ) + { + printf("\nBiosReflash"); + } + if ( oemDefinedCapabilities & SuppBiosSetup ) + { + printf("\nBiosSetup"); + } + if ( oemDefinedCapabilities & SuppBiosPause ) + { + printf("\nBiosPause"); + } +} + diff --git a/pcucontrol/models/intelamt/RemoteControlSoapBinding.nsmap b/pcucontrol/models/intelamt/RemoteControlSoapBinding.nsmap new file mode 100644 index 0000000..d474248 --- /dev/null +++ b/pcucontrol/models/intelamt/RemoteControlSoapBinding.nsmap @@ -0,0 +1,27 @@ + +#include "soapH.h" +SOAP_NMAC struct Namespace namespaces[] = +{ + {"SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/", "http://www.w3.org/*/soap-envelope", NULL}, + {"SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/", "http://www.w3.org/*/soap-encoding", NULL}, + {"xsi", "http://www.w3.org/2001/XMLSchema-instance", "http://www.w3.org/*/XMLSchema-instance", NULL}, + {"xsd", "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/*/XMLSchema", NULL}, + {"cmn", "http://schemas.intel.com/platform/client/Common/2006/01", NULL, NULL}, + {"cstr", "http://schemas.intel.com/platform/client/CertStore/2006/01", NULL, NULL}, + {"xcfg", "http://schemas.intel.com/platform/client/XProfiles/2006/01", NULL, NULL}, + {"apl", "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogLocal", NULL, NULL}, + {"apr", "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote", NULL, NULL}, + {"cb", "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker", NULL, NULL}, + {"emi", "http://schemas.intel.com/platform/client/EventManager/2004/01", NULL, NULL}, + {"hwa", "http://schemas.intel.com/platform/client/HardwareAsset/2004/01", NULL, NULL}, + {"idr", "http://schemas.intel.com/platform/client/Redirection/2004/01", NULL, NULL}, + {"inf", "http://schemas.intel.com/platform/client/GeneralInfo/2004/01", NULL, NULL}, + {"net", "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01", NULL, NULL}, + {"rci", "http://schemas.intel.com/platform/client/RemoteControl/2004/01", NULL, NULL}, + {"sai", "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01", NULL, NULL}, + {"str", "http://schemas.intel.com/platform/client/Storage/2004/01", NULL, NULL}, + {"stra", "http://schemas.intel.com/platform/client/StorageAdministration/2004/01", NULL, NULL}, + {"tim", "http://schemas.intel.com/platform/client/NetworkTime/2004/01", NULL, NULL}, + {"wcxs", "http://schemas.intel.com/platform/client/WirelessConfiguration/2006/01", NULL, NULL}, + {NULL, NULL, NULL, NULL} +}; diff --git a/pcucontrol/models/intelamt/RemoteControlTypes.h b/pcucontrol/models/intelamt/RemoteControlTypes.h new file mode 100644 index 0000000..241fc3b --- /dev/null +++ b/pcucontrol/models/intelamt/RemoteControlTypes.h @@ -0,0 +1,222 @@ +//---------------------------------------------------------------------------- +// +// Copyright (C) Intel Corporation, 2004 - 2006. +// +// File: RemoteControlTypes.h +// +// Contents: Sample code for an Intel® AMT Network client. +// +// Notes: This file contains type definitions used throughout the code +// and constants as described in the "Intel® AMT Network Design +// Guide". +// +//---------------------------------------------------------------------------- + +#ifndef _REMOTE_CONTROL_TYPES__H_ +#define _REMOTE_CONTROL_TYPES__H_ + +/* + * limits.h for UINT_MAX + */ +#include + +/* + * Type definitions + */ +typedef unsigned char uint8; +typedef unsigned short uint16; +typedef unsigned int uint32; +typedef unsigned long long uint64; +typedef unsigned char BYTE; + +/* + * Remote Control sample + * command line parameters + */ +static const char *POWER = "-p"; +static const char *CAPABILITIES = "-c"; +static const char *REMOTE = "-r"; +static const char *API_TEST = "-A"; +static const char *REDUCED_API_TEST = "-B"; +static const int MIN_NUM_OF_CL_PARAMETERS = 3; + +/* + * Command line options + */ +enum Options +{ + // Remote Control sample options + OPT_POWER, + OPT_CAPABILITIES, + OPT_REMOTE, + OPT_API_TEST, + OPT_REDUCED_API_TEST, +}; + +/* + * Constants + */ +static const uint32 NO_VALUE = UINT_MAX; + +/* + * Remote control commands + */ +enum RemoteControlCommand +{ + Reset = 16, //0x10 + PowerUp = 17, //0x11 + PowerDown = 18, //0x12 + PowerCycleReset = 19, //0x13 + SetBootOptions = 33, //0x21 +}; + +/* + * Special commands + */ +enum SpecialCommand +{ + + NOP = 0, // 0x00 + ForcePxeBoot = 1, // 0x01 + ForceHardDriveBoot = 2, // 0x02 + ForceHardDriveSafeModeBoot = 3, // 0x03 + ForceDiagnosticsBoot = 4, // 0x04 + ForceCdOrDvdBoot = 5, // 0x05 + // 06h-0BFh Reserved for future ASF definition + IntelOemCommand = 193, // 0x0C1 + // 0C1h-0FFh Reserved FOR OEM +}; + +/* + * Standard boot options + * + * Following boot options can be defined by using the bitwise OR operator. + * For example: + * unsigned short bootOptions = LockPowerButton | LockKeyboard | FirmwareVerbosityVerbose + */ +enum BootOptions +{ + + LockPowerButton = 2, // 1 << 1 + LockResetButton = 4, // 1 << 2 + LockKeyboard = 32, // 1 << 5 + LockSleepButton = 64, // 1 << 6 + UserPasswordBypass = 2048, // 1 << 11 + ForceProgressEvents = 4096, // 1 << 12 + + // only one from the Firmware verbosity options can be used + FirmwareVerbositySystemDefault = 0, // system default + FirmwareVerbosityQuiet = 8192, // 1 << 13 minimal screen activity + FirmwareVerbosityVerbose = 16384, // 1 << 14 all messages appear on the screen + FirmwareVerbosityScreen = 24576, // 3 << 13 blank, no messages appear on the screen. + + ConfigurationDataReset = 32768, // 1 << 14 +}; + +/* + * Reserved bits for checking + * correctness of the Boot Options settings + */ +const uint32 BootOptionsReservedBits = 1817; + + +/* + * Special Command Parameters + * + * Following boot options can be defined by using the bitwise OR operator. + * For example: + * unsigned short specialCommParam = UseIderCD | ReflashBios + */ +enum SpecialCommandParameters +{ + UndefinedSpecialCommandParameter = 0, + UseIderFloppy = 1, // use floppy as IDER boot device + ReflashBios = 4, // 1 << 2 + BiosSetup = 8, // 1 << 3 + BiosPause = 16, // 1 << 4 + UseIderCD = 257, // 1 | (1 << 8) use CD/DVD as IDER boot device +}; + +/* + * Reserved bits for checking + * correctness of the Special Parameters settings + */ +const uint32 SpecialCommandParametersReservedBits = 65248; + +/* + * OEM Parameters - Intel(R) AMT proprietary boot options + */ +enum OEMParameters +{ + UndefinedOEMParameter = 0, + UseSol = 1, // 1 << 1 +}; + +/* + * IANA numbers + */ +enum IanaNumbers +{ + IntelIanaNumber = 343, + ASFIanaNumber = 4542, +}; + + +/* + * The remote control capabilities supported by the Intel(R) AMT: + * + * OEM defined capabilities + */ +enum OemDefinedCapabilitiesSupported +{ + SuppIDER = 1, + SuppSOL = 2, + SuppBiosReflash = 4, + SuppBiosSetup = 8, + SuppBiosPause = 16, + +}; + +/* + * System capabilities + */ +enum SystemCapabilitiesSupported +{ + SuppPowerCycleReset = 1, + SuppPowerDown = 2, + SuppPowerUp = 4, + SuppReset = 8, +}; + +/* + * Special commands + */ +enum SpecialCommandSupported +{ + SuppForcePXEBoot = 256, + SuppForceHardDriveBoot = 512, + SuppForceHardDriveSafeModeBoot = 1024, + SuppForceDiagnosticBoot = 2048, + SuppForceCDorDVDBoot = 4096, +}; + + +/* + * System Firmware capabilities + */ +enum SystemFirmwareCapabilitiesSupported +{ + SuppVerbosityScreenBlank = 1, + SuppPowerButtonLock = 2, + SuppResetButtonLock = 4, + SuppKeyboardLock = 32, + SuppSleepButtonLock = 64, + SuppUserPasswordBypass = 2048, + SuppForcedProgressEvents = 4096, + SuppVerbosityVerbose = 8192, + SuppVerbosityQuiet = 16384, + SuppConfigurationDataReset = 32768, +}; + +#endif // _REMOTE_CONTROL_TYPES__H_ + diff --git a/pcucontrol/models/intelamt/Utils.cpp b/pcucontrol/models/intelamt/Utils.cpp new file mode 100644 index 0000000..9eaef19 --- /dev/null +++ b/pcucontrol/models/intelamt/Utils.cpp @@ -0,0 +1,775 @@ +//---------------------------------------------------------------------------- +// +// Copyright (C) Intel Corporation, 2004 - 2006. +// +// File: Utils.h +// +// Contents: Sample code for an Intel® AMT Network client. +// +// Notes: This file contains the function implementations +// used throughout the code of the all sample applications. +// +//---------------------------------------------------------------------------- + +#include +#include +#include +#include "CommonDefinitions.h" + +#ifdef _WIN32 +#define strncasecmp _strnicmp +#endif + +// Constant definitions +static const char *URL_SEPARATOR = "://"; +static const int NUM_OF_BYTES = 4; +static const int IP_BYTE_MASK = 0xFF; +static const int IP_BYTE_SHIFT = 0x8; + +/* + * Gets command line parameter that describes type of action to perform + * Arguments: + * commandLineLength - number of the command line parameters + * argv - array of strings that holds command line parameters + * numOfArgs - minimal number of command line parameters + * option - pointer to the string that will hold command line + * parameter that describes type of action to perform + * commandLine - pointer to the array of strings that will hold + * command line parameters without application name + * and parameter that describes type of action to perform + * Return Value: + * true - on success + * false - on failure + */ +bool GetOption(int *commandLineLength, char *argv[], int numOfArgs, + char **option, char **commandLine[]) +{ + if( !argv || + *commandLineLength < numOfArgs) + { + return false; + } + + *option = NULL; + *commandLine = &argv[1]; + // Skip the application name + (*commandLineLength) --; + + if( argv[1][0] == '-') + { + if(strcmp(argv[1],CERT_NAME) && strcmp(argv[1],USER) && + strcmp(argv[1],VERBOSE) +#ifdef _WIN32 + && strcmp(argv[1],LOCAL) +#endif + ) + { + *option = argv[1]; + *commandLine = &argv[2]; + (*commandLineLength) --; + } + } + + return true; +} + +#ifdef _WIN32 +/* + * Parses the user input text + * Arguments: + * commandLineLength - number of arguments + * commandLine - command line arguments received + * target - pointer to the string that will hold the target url + * certName - pointer to the string that will hold client certificate's name + * verbose - pointer to the verbose flag + * username - pointer to the string that will hold the username + * password - pointer to the string that will hold the password + * Return Value: + * true - on success + * false - on failure + */ +bool ParseCommandLine(int commandLineLength,char* commandLine[],char **target, + char **certName, bool *local, bool *krb, bool *verbose, + char **username, char **password) +{ +#else +/* + * Parses the user input text + * Arguments: + * commandLineLength - number of arguments + * commandLine - command line arguments received + * target - pointer to the string that will hold the target url + * certName - pointer to the string that will hold client certificate's name* + * certPass - pointer to the string that will hold passphrase for decryption + * the file that contains private key associated with the given + * client certificate + * verbose - pointer to the verbose flag + * username - pointer to the string that will hold the username + * password - pointer to the string that will hold the password + * Return Value: + * true - on success + * false - on failure + */ +bool ParseCommandLine(int commandLineLength,char* commandLine[],char **target, + char **certName,char **certPass, bool *verbose, + char **username, char **password) +{ + *certPass = NULL; +#endif + *certName = NULL; + *target = NULL; + *password = NULL; + *username = NULL; + + if (verbose != NULL) { + *verbose = false; + } + + for(int i = 0; i < commandLineLength; i++) + { + if( !strcmp(commandLine[i], CERT_NAME) ) + { + if( i+1 < commandLineLength && ! *certName ) + { + *certName = commandLine[++i]; + } + else + { + return false; + } + } +#ifndef _WIN32 + else if( !strcmp(commandLine[i], CERT_PASS) ) + { + if( i+1 < commandLineLength && ! *certPass ) + { + *certPass = commandLine[++i]; + } + else + { + return false; + } + } +#endif + else if( !strcmp(commandLine[i], VERBOSE) && verbose != NULL) + { + *verbose = true; + } +#ifdef _WIN32 + else if( !strcmp(commandLine[i], LOCAL) && local != NULL) + { + *local = true; + } +#endif + else if( !strcmp(commandLine[i], USER) ) + { + + if( i+1 < commandLineLength && ! *username ) + { + *username = commandLine[++i]; + } + else + { + return false; + } + } + else if( !strcmp(commandLine[i], PASS) ) + { + + if( i+1 < commandLineLength && ! *password ) + { + *password = commandLine[++i]; + } + else + { + return false; + } + } + else + { + //this is a target URL argument + if( !ValidateIP(commandLine[i]) ) + { + return false; + } + *target = commandLine[i]; + } + } + if( !*target || (!strncasecmp(*target, "http:", 5) && *certName != 0 )) + { + return false; + } + if( (*username && !*password) || (!*username && *password)) + { + return false; + } +#ifdef _WIN32 + else if(*username && *password) + { + *krb = false; + } +#else + else if(!*username) + { + return false; + } +#endif + return true; +} + +/* + * Checks if IP address exists in the URI + * Arguments: + * uri - pointer to the string that represents the URI + * Return value: + * true - on success + * false - on failure + */ +bool ValidateIP(const char *uri) +{ + if( strncasecmp(uri, "http:", 5 ) && strncasecmp(uri, "https:", 6 ) ) + { + return false; + } + bool retVal = true; + + // pointer to the start of the IP address + const char *start = strstr(uri,URL_SEPARATOR); + if(start != NULL) + { + start += (sizeof(URL_SEPARATOR) - 1); + + // pointer to the end of the IP address + const char *end = strchr(start,':'); + + if(end != NULL && start != end) + { + retVal = true; + } + else + { + retVal = false; + } + } + else + { + retVal = false; + } + + return retVal; +} + +/* + * Gets an input string from the user + * Assumptions: caller pre-allocates string, and user must not overflow (!) + * Arguments: + * msg - message string + * s - pre-allocated input string that will represent the binary data + * hidden - echo input string (true / false) + */ +void GetString(char *msg, char *s, bool hidden) +{ + + // Output informative message + if(msg != NULL) + { + printf ("%s", msg); + } + fflush(NULL); + +#ifdef _WIN32 + char c; // for the next input character + int count = 0; // number of characters + + // Get input string character by character + do + { + c = _getch(); + + count ++; + + if (c == '\r' || // carriage return + c == '\n' || // new line + c == '\t' || // TAB + count == MAX_LINE_LEN ) // maximal line length + { + *s=0; + break; + } + else if ( c==3 ) // + C + { + exit(0); + } + else if ( c == '\b' ) // backspace + { + count --; + if(count > 0) + { + printf("%c", c); + printf("%c", ' '); + printf("%c", c); + count --; + s --; + } + continue; + } + + // The password should be hidden + if ( hidden ) + { + printf("*"); + } + else + { + printf("%c", c); + } + *s = c; + s++; + } + while ( true ); + printf("\n"); +#else + + if(hidden == false) + { + if(fgets(s,MAX_LINE_LEN,stdin)) + { + char *tmp = strchr(s,'\n'); + if(tmp != NULL) + { + *tmp = '\0'; + } + } + } + else + { + strcpy(s,getpass("")); + } +#endif +} + +/* + * Receives yes or no answer from the user. + * Arguments: + * msg - pointer to the string that holds a question + * Return value: + * true - if answer is 'y' (yes) + * false - otherwise + */ +bool DisplayWarning(const char *msg) +{ + printf("%s",msg); + char c; + scanf("%c",&c); + + if(c != 'y' && c != 'n') + { + printf("Illegal choice. Aborting.\n"); + return false; + } + else if(c == 'n') + { + return false; + } + scanf("%c",&c); + + return true; +} + +/* + * Gets a number from the user + * Arguments: + * number - pointer to the variable that will be hold a number + * Return value: + * true - on success + * false - on failure + */ +bool GetNumber(int *number) +{ + scanf("%d",number); + int c = getchar(); + if(c != '\n' && c != '\r') + { + return false; + } + return true; +} + +/* + * Checks the exit status of the SOAP query + * Arguments: + * res - exit statis of the gSOAP function call + * status - status codes that are returned by + * Intel(R) AMT network API + * message - string that holds the function name + * Return value: + * true - if the query succeed + * false - if the query failed + */ +bool CheckReturnStatus(unsigned int res, unsigned long status, + const char *message) +{ + if (res || status) + { + printf("\nError: failed while calling %s\n", message); + if(res == 0) + { +#ifndef _WIN32 + printf("Status = %lu\n", status); +#else + wchar_t err[MAX_LINE_LEN]; + GetStatusString(status,err,MAX_LINE_LEN); + wprintf(err); + printf("\n"); +#endif + } + else + { + printf("SOAP failure: error code = %u\n", res); + } + return false; + } + return true; +} + +/* + * Changes the service name at the URI + * Arguments: + * uri - null-terminated string which holds the whole URI as supplied + * at the command line + * newService - string which represents the new service name + * newUri - pre-allocated string which will hold the new service URI + */ +bool ChangeService(const char *uri, const char *newService, char *newUri) +{ + const char *tmp = strrchr(uri,'/'); + if(tmp == NULL) + { + return false; + } + + int n = tmp - uri + 1; + + strncpy(newUri,uri,n); + newUri[strlen(uri) - strlen(tmp) + 1] = '\0'; + //check new Uri allocated + if(&(newUri[n]) == NULL) + { + return false; + } + //copy newService to end of string instead '\o' + strcpy(&(newUri[n]),newService); + + return true; +} + +/* + * Replaces substring within given string + * Arguments: + * oldString - pointer to the old null-terminated string + * oldSubstr - substring that will be replaced + * newSubstr - string which represents the new substring + * newString - pre-allocated buffer which will hold the new string + */ +void ReplaceSubstring(const char *oldString,const char *oldSubstr, + const char *newSubstr, char *newString) +{ + // Locate substring + const char *tmp = strstr(oldString,oldSubstr); + + if(tmp == NULL) + { + printf("Error: cannot find '%s' within '%s'\n",oldSubstr,oldString); + exit(1); + } + + int len1 = strlen(oldSubstr); + int len2 = strlen(newSubstr); + int i,k,j; + + // Copy string to the buffer with appropriate change + for(i = 0, k = 0; oldString[i] != '\0'; i ++, k ++) + { + if(tmp == &oldString[i]) + { + for(j = 0; j < len2; k ++, j ++) + { + newString[k] = newSubstr[j]; + } + i += len1; + } + newString[k] = oldString[i]; + } + newString[k] = oldString[i]; +} + +/* + * Converts the IP address from the dot-separated format + * to the usigned long number + * Arguments: + * address - number that will hold a converted IP address + * bytes - array for IP address's bytes + */ +void SetIPAddress(unsigned long &address, unsigned long bytes[]) +{ + address = 0; + int i; + for(i = 0; i < NUM_OF_BYTES - 1; i ++) + { + address += bytes[i]; + address <<= 8; + } + address += bytes[i]; +} + +/* + * Extracts bytes from the IP address for the dot-separated representation + * Arguments: + * address - number that holds a IP address + * bytes - array that will hold IP address bytes + */ +void NumberToIP(unsigned long address, unsigned long bytes[]) +{ + int i; + for(i = NUM_OF_BYTES - 1; i > 0; i --) + { + bytes[i] = address & IP_BYTE_MASK; + address >>= IP_BYTE_SHIFT; + } + bytes[i] = address & IP_BYTE_MASK; +} + + +/* + * Converts a number to a string + * Arguments & Return values: + * number - number which will convert + * string - string which will hold the converted number + */ +void NumberToString(unsigned long number, char *string) +{ + div_t res; + int i = 0; + char tmp[MAX_LINE_LEN]; + do + { + res = div(number,10); + tmp[i++] = (char)('0' + res.rem); + number = res.quot; + }while(number != 0); + + for(i --; i >= 0; i --) + { + *string = tmp[i]; + string ++; + } + *string = '\0'; +} + +/* + * Converts the IP address to the dot-separated string form + * Arguments & Return values: + * address - number which holds the IP address + * string - string which will represent the IP address in + * the dot-separated format + */ +void IpToString(unsigned long address, char *string) +{ + unsigned long bytes[NUM_OF_BYTES]; + NumberToIP(address,bytes);//one,two,three,four); + + char tmp[MAX_LINE_LEN]; + char *ptr = string; + + for(int i = 0; i < NUM_OF_BYTES; i ++) + { + NumberToString(bytes[i],tmp); + strcpy(ptr,tmp); + ptr += strlen(tmp); + *ptr = '.'; + ptr ++; + } + ptr --; + *ptr = '\0'; +} + +/* + * Converts the string that represents dot-separated + * format of the IP address to the number + * Arguments: + * string - string which represents IP address in + * the dot-separated format + * address - number which will hold the converted IP address + */ +void StringToIP(const char *string, unsigned long &address) +{ + // local copy of the string + char tmpStr[MAX_LINE_LEN]; + strncpy(tmpStr,string,MAX_LINE_LEN - 1); + tmpStr[MAX_LINE_LEN - 1] = '\0'; + + char *tmpPtr1 = NULL; + char *tmpPtr2 = tmpStr; + unsigned long bytes[NUM_OF_BYTES]; + int i; + + for(i = 0; i < NUM_OF_BYTES - 1; i ++) + { + if((tmpPtr1 = strstr(tmpPtr2,".")) == NULL) + { + goto FAULT_EXIT; + } + + *tmpPtr1 = '\0'; + bytes[i] = atol(tmpPtr2); + tmpPtr2 = tmpPtr1 + 1; + } + bytes[i] = atol(tmpPtr2); + + SetIPAddress(address,bytes);//one,two,three,four); + + return; + + FAULT_EXIT: + printf("Error: invalid format\n"); + exit(1); +} + +/* + * Converts the bunary guid to a string according to the representation + * described in the CDE 1.1 RPC specification + * Arguments & Return values: + * guid - a pointer to the 16 byte guid + * string - string which will hold the guid string + */ +void GuidToString(const unsigned char* guid, char* string) +{ + if(guid != NULL && string != NULL) + { + int j = sprintf(string, "%02X%02X%02X%02X", guid[3], guid[2], guid[1], guid[0]); + j += sprintf(string + j, "-%02X%02X", guid[5], guid[4]); + j += sprintf(string + j, "-%02X%02X", guid[7], guid[6]); + j += sprintf(string + j, "-%02X%02X-", guid[8], guid[9]); + for(int i = 10; i <= 15; i ++) + { + j += sprintf(string + j, "%02X", guid[i]); + } + } +} + +/* + * Extracts IP address from the URI + * Arguments: + * uri - pointer to the string that represents the URI + * Return value: + * true - on success + * false - on failure + */ +bool ExtractIPFromUri(const char *uri, char *baseUrl) +{ + char *ip = baseUrl; + bool retVal = true; + + // pointer to the start of the IP address + const char *start = strstr(uri,URL_SEPARATOR); + if(start != NULL) + { + start += (sizeof(URL_SEPARATOR) - 1); + + // pointer to the end of the IP address + const char *end = strchr(start,':'); + + if(end != NULL && start != end) + { + while(start != end) + { + *ip = *start; + ip ++; + start ++; + } + *ip = '\0'; // NULL termination + } + else + { + retVal = false; + } + } + else + { + retVal = false; + } + + return retVal; +} + +/* + * prints "success" to output + * Argument: + * printS - prints only if true + */ +void PrintSuccess(bool printS) +{ + if(printS) + { + printf("success\n"); + } +} + +/* + * prints function call to output + * Argument: + * message - name of function + */ +void FunctionCall(const char *message) +{ + printf("\nCalling function %s... ", message); +} + +/* + * Performs testing of the URL + * Arguments: + * targetUrl - string that represents URL of the target machine + * isEmulator - pointer to the variable that will be 1 if the targetUrl + * points to the Intel® AMT device or 0 if the targetUrl + * points to the Intel® AMT Emulator + */ +void IsEmulator(const char *targetUrl, int *isEmulator) +{ + *isEmulator = 1; + + if((strstr(targetUrl,".asmx")) == (targetUrl + strlen(targetUrl) - 5)) + { + *isEmulator = 0; + } +} + +/* + * Prints notes for usage by authentication options + */ +void PrintAuthenticationNote() +{ +#ifndef _WIN32 + printf("\t %s %s : for digest authentication.\n",USER,PASS); +#else + printf("\n\t If %s %s are defined the Digest authentication" ,USER,PASS); + printf(" scheme is used,\n\t otherwise the Kerberos authentication scheme will be attempted.\n"); +#endif + printf("\nClient authentication options (TLS Mutual Authentication mode only):\n"); +#ifndef _WIN32 + printf("\t %s: If option defined specify the full path of the ", + CERT_NAME); + printf("file containing client certificate and private keys.\n"); + printf("\t %s: If option defined specify the passphrase ", + CERT_PASS); + printf("that protects the private key. "); +#else + printf("\t %s: If option defined, specifies the client certificate's", + CERT_NAME); + printf(" Common Name (CN).\n"); + + printf("\t\t If option is not specified the sample application will search the certificate store \n"); + printf("\t\t for a client certificate matching Intel(R) AMT requirements. \n"); + printf("\t\t The first one found will be used for authentication.\n"); +#endif +} + diff --git a/pcucontrol/models/intelamt/digcalc.cpp b/pcucontrol/models/intelamt/digcalc.cpp new file mode 100644 index 0000000..7f2197a --- /dev/null +++ b/pcucontrol/models/intelamt/digcalc.cpp @@ -0,0 +1,153 @@ +//------------------------------------------------------------------- +// Copyright (C) The Internet Society (1999). All Rights Reserved. +// +// This document and translations of it may be copied and furnished to +// others, and derivative works that comment on or otherwise explain it +// or assist in its implementation may be prepared, copied, published +// and distributed, in whole or in part, without restriction of any +// kind, provided that the above copyright notice and this paragraph are +// included on all such copies and derivative works. However, this +// document itself may not be modified in any way, such as by removing +// the copyright notice or references to the Internet Society or other +// Internet organizations, except as needed for the purpose of +// developing Internet standards in which case the procedures for +// copyrights defined in the Internet Standards process must be +// followed, or as required to translate it into languages other than +// English. +// +// The limited permissions granted above are perpetual and will not be +// revoked by the Internet Society or its successors or assigns. +// +// This document and the information contained herein is provided on an +// "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING +// TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +// BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION +// HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF +// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. +// +// +// Modifiyed by Intel Corporation, 2005 +//------------------------------------------------------------------------- + +#include +#include +#include +#include +#include "digcalc.h" + +int stricmp(const char *b, const char *a) +{ + while (*a != '\0' && *b != '\0' && tolower(*a) == tolower(*b)) + { a++; + b++; + } + return *a == *b ? 0 : + tolower(*a) < tolower(*b) ? -1 : 1; +} + +void CvtHex( + HASH Bin, + HASHHEX Hex + ) +{ + unsigned short i; + unsigned char j; + + for (i = 0; i < HASHLEN; i++) { + j = (Bin[i] >> 4) & 0xf; + if (j <= 9) + Hex[i*2] = (j + '0'); + else + Hex[i*2] = (j + 'a' - 10); + j = Bin[i] & 0xf; + if (j <= 9) + Hex[i*2+1] = (j + '0'); + else + Hex[i*2+1] = (j + 'a' - 10); + }; + Hex[HASHHEXLEN] = '\0'; +}; + +/* calculate H(A1) as per spec */ +void DigestCalcHA1( + char * pszAlg, + char * pszUserName, + char * pszRealm, + char * pszPassword, + char * pszNonce, + char * pszCNonce, + HASHHEX SessionKey + ) +{ + MD5_CTX Md5Ctx; + HASH HA1; + HASHHEX HA1HEX; + + MD5_Init(&Md5Ctx); + MD5_Update(&Md5Ctx, pszUserName, strlen(pszUserName)); + MD5_Update(&Md5Ctx, ":", 1); + MD5_Update(&Md5Ctx, pszRealm, strlen(pszRealm)); + MD5_Update(&Md5Ctx, ":", 1); + MD5_Update(&Md5Ctx, pszPassword, strlen(pszPassword)); + MD5_Final(HA1, &Md5Ctx); + if (stricmp(pszAlg, "md5-sess") == 0) { + CvtHex(HA1, HA1HEX); + MD5_Init(&Md5Ctx); + MD5_Update(&Md5Ctx, HA1HEX, HASHHEXLEN); + MD5_Update(&Md5Ctx, ":", 1); + MD5_Update(&Md5Ctx, pszNonce, strlen(pszNonce)); + MD5_Update(&Md5Ctx, ":", 1); + MD5_Update(&Md5Ctx, pszCNonce, strlen(pszCNonce)); + MD5_Final(HA1, &Md5Ctx); + }; + CvtHex(HA1, SessionKey); +}; + +/* calculate request-digest/response-digest as per HTTP Digest spec */ +void DigestCalcResponse( + HASHHEX HA1, /* H(A1) */ + char * pszNonce, /* nonce from server */ + char * pszNonceCount, /* 8 hex digits */ + char * pszCNonce, /* client nonce */ + char * pszQop, /* qop-value: "", "auth", "auth-int" */ + char * pszMethod, /* method from the request */ + char * pszDigestUri, /* requested URL */ + HASHHEX HEntity, /* H(entity body) if qop="auth-int" */ + HASHHEX Response /* request-digest or response-digest */ + ) +{ + MD5_CTX Md5Ctx; + HASH HA2; + HASH RespHash; + HASHHEX HA2Hex; + + // calculate H(A2) + MD5_Init(&Md5Ctx); + MD5_Update(&Md5Ctx, pszMethod, strlen(pszMethod)); + MD5_Update(&Md5Ctx, ":", 1); + MD5_Update(&Md5Ctx, pszDigestUri, strlen(pszDigestUri)); + if (stricmp(pszQop, "auth-int") == 0) { + MD5_Update(&Md5Ctx, ":", 1); + MD5_Update(&Md5Ctx, HEntity, HASHHEXLEN); + }; + MD5_Final(HA2, &Md5Ctx); + CvtHex(HA2, HA2Hex); + + // calculate response + MD5_Init(&Md5Ctx); + MD5_Update(&Md5Ctx, HA1, HASHHEXLEN); + MD5_Update(&Md5Ctx, ":", 1); + MD5_Update(&Md5Ctx, pszNonce, strlen(pszNonce)); + MD5_Update(&Md5Ctx, ":", 1); + if (*pszQop) { + MD5_Update(&Md5Ctx, pszNonceCount, strlen(pszNonceCount)); + MD5_Update(&Md5Ctx, ":", 1); + MD5_Update(&Md5Ctx, pszCNonce, strlen(pszCNonce)); + MD5_Update(&Md5Ctx, ":", 1); + MD5_Update(&Md5Ctx, pszQop, strlen(pszQop)); + MD5_Update(&Md5Ctx, ":", 1); + }; + MD5_Update(&Md5Ctx, HA2Hex, HASHHEXLEN); + MD5_Final(RespHash, &Md5Ctx); + CvtHex(RespHash, Response); +}; diff --git a/pcucontrol/models/intelamt/httpDigest.cpp b/pcucontrol/models/intelamt/httpDigest.cpp new file mode 100644 index 0000000..4db0415 --- /dev/null +++ b/pcucontrol/models/intelamt/httpDigest.cpp @@ -0,0 +1,715 @@ +//---------------------------------------------------------------------------- +// +// Copyright (C) Intel Corporation, 2003 - 2005. +// +// File: httpDigest.cpp +// +// Contents: Sample code for a gSOAP plugin to implement HTTP Digest +// authentication. +// +// Limitations: +// - MIME, DIME and HTTP chunks (SOAP_IO_CHUNK) are not supported. +// - This implementationn will internally buffer the entire outgoing +// message before sending +// - This implementation will fail if challenge isn't received within +// SOAP_BUFLEN bytes read. +// - This implementation will fail if challenge or response are larger +// than the constants we used. +// - This implementation calculates the digest response for each call +// and doesn't save information. +// - This implementation assumes that the algorithm is MD5 and that +// qop="auth". +// +// Usage: Add the httpDigest.h and httpDigest.cpp files to your project +// +// In your source, just after calling soap_init(), register this +// plugin with soap_register_plugin( soap, http_digest ). +// Use soap.userid and soap.passwd for the username and password. +// As in gSOAP, username and password have to be provided for each call. +// +// e.g. +// struct soap soap; +// soap_init( &soap ); +// soap_register_plugin( &soap, http_digest ); +// soap.userid = "admin"; +// soap.passwd = "admin"; +// ... +// soap_done(&soap); +// +//---------------------------------------------------------------------------- + +#include "httpDigest.h" +#include "digcalc.h" + +#define HDR_SIZE 1024 + +const char HTTP_DIGEST_ID[12] = "HTTP-Digest"; // plugin identification + +struct http_digest_data +{ + struct soap *soap; // back pointer + + // send buffer parameters + char *sendBuffer; // send buffer + size_t sendMsgSize; // total length of the message + size_t sendBufferLength; // length of data in buffer + + // receive buffer parameters + char *rcvBuffer; // receive buffer + size_t rcvSize; // length of buffer + size_t rcvIdx; // currecnt index + size_t rcvRead; // amount of data read + + // open parameters + char *endpoint; + char *host; + int port; + + // function pointers + int (*fopen)(struct soap*, const char*, const char*, int); // open function + int (*fsend)(struct soap*, const char*, size_t); // send function + size_t (*frecv)(struct soap*, char*, size_t); // receive function + int (*fposthdr)(struct soap*, const char*, const char*); // post header function + + char *username; + char *password; + char requestUrl[128]; + char method[5]; +}; + +static int http_digest_init(struct soap *soap, struct http_digest_data *data); +static int http_digest_copy(struct soap *soap, struct soap_plugin *dst, + struct soap_plugin *src); +static void http_digest_delete(struct soap *soap, struct soap_plugin *p); + +static int http_digest_fopen(struct soap *soap, const char *endpoint, const char *host, + int port); +static int http_digest_fsend(struct soap *soap, const char *buf, size_t size); +static size_t http_digest_frecv(struct soap *soap, char *buf, size_t size); +static int http_digest_fposthdr(struct soap *soap, const char *key, const char *value); + +/* + * The entry point for HTTP digest plugin + * Arguments: + * soap - pointer to the soap runtime environment + * p - pointer to the soap plugin + * arg - reserved. Should be NULL + * + * Returns SOAP_OK for suceess. Other values for error + */ +int http_digest(struct soap *soap, struct soap_plugin *p, void *arg) +{ + p->id = HTTP_DIGEST_ID; + p->data = (void*)malloc(sizeof(struct http_digest_data)); + p->fcopy = http_digest_copy; + p->fdelete = http_digest_delete; + if (p->data) { + memset(p->data, 0, sizeof(struct http_digest_data)); + if (http_digest_init(soap, (struct http_digest_data*)p->data)) { + free(p->data); + return SOAP_EOM; + } + return SOAP_OK; + } + return SOAP_EOM; +} + +/* + * Initializes the http digest data structure. + * Arguments: + * soap - pointer to the soap runtime environment + * data - pointer to the http digest data structure + * + * Returns SOAP_OK for suceess. Other values for error + */ +static int http_digest_init(struct soap *soap, struct http_digest_data *data) +{ + data->soap = soap; + data->fopen = soap->fopen; + soap->fopen = http_digest_fopen; + data->fsend = soap->fsend; + soap->fsend = http_digest_fsend; + data->frecv = soap->frecv; + soap->frecv = http_digest_frecv; + data->fposthdr = soap->fposthdr; + soap->fposthdr = http_digest_fposthdr; + + return SOAP_OK; +} + +/* + * Creates the HTTP digest response + * Arguments: + * userName - the user name + * password - the password + * method - the HTTP method ("GET", "POST) + * realm - the realm for the authentication + * uri - the URI from the HTTP request + * nonce - the nonce from the challenge + * cnonce - client generated nonce + * digestResponse - The result authorization string + * length - size of buffer for response + * + * Returns 0 for suceess. -1 for error + */ +int CalculateResponse(char *userName, char *password, char *method, char *realm, char *uri, + char *nonce, char *cnonce, char *digestResponse, size_t *length) +{ + size_t currOffset = 0, segmentLength; + static const char *INITIAL_HDR = "Authorization: Digest username=\""; + static const char *REALEM_HDR = "\", realm=\""; + static const char *ALGO_HDR = "\", qop=\"auth\", algorithm=\"MD5\", uri=\""; + static const char *NONCE_HDR = "\", nonce=\""; + static const char *NC_HDR = "\", nc=00000002, cnonce=\""; + static const char *RSP_HDR = "\", response=\""; + + HASHHEX HA1; + HASHHEX HA2 = ""; + HASHHEX response; + + //"Authorization: Digest username=" + segmentLength = strlen(INITIAL_HDR); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, INITIAL_HDR, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username + segmentLength = strlen(userName); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, userName, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username", realm=" + segmentLength = strlen(REALEM_HDR); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, REALEM_HDR, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username", realm="realm + segmentLength = strlen(realm); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, realm, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username", realm="myRealm", qop="auth", + //algorithm="MD5", uri=" + segmentLength = strlen(ALGO_HDR); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, ALGO_HDR, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username", realm="myRealm", qop="auth", + //algorithm="MD5", uri="/....Service + segmentLength = strlen(uri); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, uri, segmentLength); + currOffset+= segmentLength; + + //"Authorization: Digest username="username", realm="myRealm", qop="auth", + //algorithm="MD5", uri="/....Service", nonce=" + segmentLength = strlen(NONCE_HDR); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, NONCE_HDR, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username", realm="myRealm", qop="auth", + //algorithm="MD5", uri="/....Service", nonce="7a5c... + segmentLength = strlen(nonce); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, nonce, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username", realm="myRealm", qop="auth", + //algorithm="MD5", uri="/....Service", nonce="7a5c...", nc=00000002, + //cnonce=" + segmentLength = strlen(NC_HDR); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, NC_HDR, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username", realm="myRealm", qop="auth", + //algorithm="MD5", uri="/....Service", nonce="7a5c...", nc=00000002, + //cnonce="ab341... + segmentLength = strlen(cnonce); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, cnonce, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username", realm="myRealm", qop="auth", + //algorithm="MD5", uri="/....Service", nonce="7a5c...", nc=00000002, + //cnonce="ab341...", response=" + segmentLength = strlen(RSP_HDR); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, RSP_HDR, segmentLength); + currOffset += segmentLength; + + //calc response + DigestCalcHA1("MD5", userName, realm, password, nonce, cnonce, HA1); + DigestCalcResponse(HA1, nonce, "00000002", cnonce, "auth", method, uri, + HA2, response); + + //"Authorization: Digest username="username", realm="myRealm", qop="auth", + //algorithm="MD5", uri="/....Service", nonce="7a5c...", nc=00000002, + //cnonce="ab341...", response="8bbf2... + segmentLength = strlen(response); + if (*length < (currOffset + segmentLength)) { + return -1; + } + memcpy(digestResponse + currOffset, response, segmentLength); + currOffset += segmentLength; + + //"Authorization: Digest username="username", realm="myRealm", qop="auth", + //algorithm="MD5", uri="/....Service", nonce="7a5c...", nc=00000002, + //cnonce="ab341...", response="8bbf2..." + if (*length < (currOffset + 2)) { + return -1; + } + memcpy(digestResponse + currOffset, "\"", 1); + currOffset += 1; + + //add null termination + *(digestResponse+currOffset) = 0; + *length = currOffset; + + return 0; +} + +/* + * generate a 32 byte random hexadecimal string such as "4f6ba982..." + * Arguments: + * outbuff - buffer to fill + */ +void GenerateCNonce(char *outbuff) +{ + srand((unsigned int)time(NULL)); + for(int i = 0; i < 32; i++) { + int num = (int)(((double) rand()/ ((double)RAND_MAX+1)) * 16); + switch(num) { + case 0: case 1: case 2: case 3: case 4: case 5: + case 6: case 7: case 8: case 9: + outbuff[i] = '0' + num; + break; + case 10: case 11: case 12: case 13: case 14: case 15: + outbuff[i] = 'a' + (num-10); + break; + default: + outbuff[i] = 'f'; + } + } + outbuff[32] = 0; +} + +/* + * Creates the HTTP digest response + * Arguments: + * data - the HTTP digest structure + * authHeader - the HTTP digest challenge + * responseLength - size of response buffer + * digestResponse - buffer for HTTP digest response + * + * Returns 0 for suceess. -1 for error + */ +int CreateDigestResponse(struct http_digest_data *data, char *authHeader, + size_t *responseLength, char *digestResponse) +{ + char cnonce[33]; + char *realmPtrStart, *realmPtrEnd, *noncePtrStart, *noncePtrEnd; + size_t segmentLength; + char realm[HDR_SIZE], nonce[HDR_SIZE];; + + if (digestResponse == NULL || authHeader == NULL) { + return -1; + } + + GenerateCNonce(cnonce); + + //grep realm from challange + realmPtrStart = strstr(authHeader, "realm="); + if (realmPtrStart == NULL) { + return -1; + } + //point to start of realm + realmPtrStart += 7; + realmPtrEnd = strstr(realmPtrStart, "\""); + segmentLength = realmPtrEnd - realmPtrStart; + memcpy(realm, realmPtrStart, segmentLength); + //add NULL termination + realm[segmentLength] = 0; + + //grep nonce from challange + noncePtrStart = strstr(authHeader, "nonce="); + if (noncePtrStart == NULL) { + return -1; + } + //point to start of nonce + noncePtrStart += 7; + noncePtrEnd = strstr(noncePtrStart, "\""); + segmentLength = noncePtrEnd - noncePtrStart; + memcpy(nonce, noncePtrStart, segmentLength); + //add NULL termination + nonce[segmentLength]=0; + + return CalculateResponse(data->username, data->password, data->method, realm, + data->requestUrl, nonce, cnonce,digestResponse, responseLength); +} + + +/* + * Copies the contents of the plugin + * Arguments: + * soap - pointer to the soap runtime environment + * dst - the destination plugin + * src - the original plugin + * + * Returns SOAP_OK for suceess. Error value for error + */ +static int http_digest_copy(struct soap *soap, struct soap_plugin *dst, + struct soap_plugin *src) +{ + *dst = *src; + dst->data = (void*)malloc(sizeof(struct http_digest_data)); + if (!dst->data) { + return SOAP_EOM; + } + memcpy(dst->data, src->data, sizeof(struct http_digest_data)); + + ((struct http_digest_data*)dst->data)->sendBuffer = NULL; + return SOAP_OK; +} + +/* + * Deletes the contents of the plugin + * Arguments: + * soap - pointer to the soap runtime environment + * p - the plugin + */ +static void http_digest_delete(struct soap *soap, struct soap_plugin *p) +{ + struct http_digest_data *data = + (struct http_digest_data*)soap_lookup_plugin(soap, HTTP_DIGEST_ID); + + if (data) { + if (data->sendBuffer) { + free(data->sendBuffer); + } + free(data); + } +} + +/* + * Open function. Will be called when connection opened. Used for saving parameters. + * Arguments: + * soap - pointer to the soap runtime environment + * endpoint - the URL + * host - machine to connect to + * port - port on the host + * + * Returns SOAP_OK for suceess. Error value for error + */ +static int http_digest_fopen(struct soap *soap, const char *endpoint, const char *host, + int port) +{ + struct http_digest_data *data = + (struct http_digest_data *)soap_lookup_plugin(soap, HTTP_DIGEST_ID); + data->endpoint = (char*)endpoint; + data->host = (char*)host; + data->port = port; + return data->fopen(soap, endpoint, host, port); +} + +/* + * Post header function. Used to identify parameters of the HTTP message + * Arguments: + * soap - pointer to the soap runtime environment + * key - the header key + * value - the header value + * + * Returns SOAP_OK for suceess. Error value for error + */ +static int http_digest_fposthdr(struct soap *soap, const char *key, const char *value) +{ + struct http_digest_data *data = + (struct http_digest_data *)soap_lookup_plugin(soap, HTTP_DIGEST_ID); + char *s1, *s2; + + // if this is the initial POST header then we initialize our send buffer + if (key && !value) { + data->sendMsgSize = 0; + data->sendBufferLength = 0; + + if (data->sendBuffer) { + free(data->sendBuffer); + data->sendBuffer = NULL; + } + + data->password = soap->passwd; + data->username = soap->userid; + soap->passwd = soap->userid = NULL; + soap->frecv = http_digest_frecv; + + // read the method and URI form the key + if (!strncmp(key, "GET", 3)) + memcpy(data->method, "GET", 4); + else if (!strncmp(key, "POST", 4)) + memcpy(data->method, "POST", 5); + else + return soap->error = SOAP_EOM; + + s1 = const_cast(strstr(key, " ")); + if (!s1) { + return soap->error = SOAP_EOM; + } + s1++; + + s2 = strstr(s1, " "); + if (!s2) { + return soap->error = SOAP_EOM; + } + + if (sizeof(data->requestUrl) <= (size_t)(s2 - s1)) { + return soap->error = SOAP_EOM; + } + memcpy(data->requestUrl, s1, s2-s1); + data->requestUrl[s2-s1] = '\0'; + + } else if (value) { + // determine the maximum length of this message so that we can + // correctly determine when we have completed the send + if (!strcmp(key, "Content-Length" )) { + data->sendMsgSize += strtoul(value, NULL, 10); + } + } + + // calculate the header size + data->sendMsgSize += 2; + if (key) { + data->sendMsgSize += strlen(key); + if (value) { + data->sendMsgSize += (strlen(value) + 2); + } + } + return data->fposthdr(soap, key, value); +} + +/* + * Send function. Used to buffer the sent data and save for resends + * Arguments: + * soap - pointer to the soap runtime environment + * buf - buffer to be sent + * size - size of data to send + * + * Returns SOAP_OK for suceess. Error value for error + */ +static int http_digest_fsend(struct soap *soap, const char *buf, size_t size) +{ + struct http_digest_data *data = + (struct http_digest_data *)soap_lookup_plugin(soap, HTTP_DIGEST_ID); + size_t newBufferLen = data->sendBufferLength + size; + + if (!data->sendBuffer || (newBufferLen > data->sendMsgSize)) { + if (newBufferLen > data->sendMsgSize) { + data->sendMsgSize = newBufferLen; + } + data->sendBuffer = (char *)realloc(data->sendBuffer, data->sendMsgSize); + if (!data->sendBuffer) { + return SOAP_EOM; + } + } + memcpy(data->sendBuffer + data->sendBufferLength, buf, size); + data->sendBufferLength = newBufferLen; + + // if we haven't got the entire length of the message yet, then + // we return to gsoap and let it continue + if (data->sendBufferLength < data->sendMsgSize) { + return SOAP_OK; + } + + // we've now got the entire message, now we can send the buffer + return data->fsend(soap, data->sendBuffer, data->sendBufferLength); +} + +/* + * Reads the next character. May need to read from the network + * Arguments: + * data - pointer to the http digest structure + * + * Returns the next character or EOF for failure. + */ +static char http_digest_getchar(struct http_digest_data *data) +{ + size_t res; + if (data->rcvIdx < data->rcvRead) + return data->rcvBuffer[data->rcvIdx++]; + res = data->frecv(data->soap, (data->rcvBuffer + data->rcvRead), + (data->rcvSize - data->rcvRead)); + if (res <= 0) + return EOF; + data->rcvRead += res; + return data->rcvBuffer[data->rcvIdx++]; +} + +/* + * Reads the next HTTP header line. + * Arguments: + * data - pointer to the http digest structure + * line - buffer to store the line read + * len - length of the line buffer + * + * Returns SOAP_OK for suceess. Error value for error. + */ +static int http_digest_getline(struct http_digest_data *data, char *line, size_t len) +{ + unsigned int i = len; + char c = 0, *s = line; + for (;;) { + while (--i > 0) { + c = http_digest_getchar(data); + if (c == '\r') + break; + if (c == EOF) + return SOAP_EOF; + *s++ = c; + } + c = http_digest_getchar(data); + if (c == '\n') { + *s = '\0'; + if (i+1 == len) // empty line: end of HTTP header + break; + c = http_digest_getchar(data); + data->rcvIdx--; // return to previous character + if (c != ' ' && c != '\t') // HTTP line continuation? + break; + } else if ((int)c == EOF) + return SOAP_EOF; + } + return SOAP_OK; +} + +/* + * receive function. Used to look for digest authentication challenge. + * If the challenge is found will calculate the response and resend. + * Arguments: + * soap - pointer to the soap runtime environment + * buf - buffer read data into + * size - size of buf + * + * Returns number of characters read. 0 for error. + */ +static size_t http_digest_frecv(struct soap *soap, char *buf, size_t size) { + struct http_digest_data *data = + (struct http_digest_data *)soap_lookup_plugin(soap, HTTP_DIGEST_ID); + char header[HDR_SIZE], authResponse[HDR_SIZE]; + static const char *CHALLANGE = "WWW-Authenticate: Digest"; + static const unsigned int SYN_DELAY = 400000; + char *s; + unsigned long httpStatus; + size_t len; + int found = 0; + + data->rcvBuffer = buf; + data->rcvSize = size; + data->rcvIdx = 0; + data->rcvRead = 0; + + do { + if (http_digest_getline(data, header, HDR_SIZE)) + goto _out; + if ((s = strchr(header, ' '))) + httpStatus = soap_strtoul(s, NULL, 10); + else + httpStatus = 0; + + if ((httpStatus != 100) && (httpStatus != 401)) + goto _out; + + for (;;) { + if (http_digest_getline(data, header, SOAP_HDRLEN)) + goto _out; + + if (!*header) + break; + + if ((httpStatus == 401) && !strncmp(header, CHALLANGE, strlen(CHALLANGE))) { + found = 1; + break; + } + } + } while (httpStatus == 100); + + // if we got here httpStatus==401 + if (!found) + goto _out; + + // header is HTTP digest challenge + len = HDR_SIZE; + if (CreateDigestResponse(data, header, &len, authResponse)) + goto _out; + + s = strstr(data->sendBuffer, "\r\n"); + if (!s) + goto _out; + + s += 2; // point to the start of second line + + // reset rcvRead so that if error occurs will return 0. + data->rcvRead = 0; + + //delay sending SYN to allow AMT to close connection gracefully + usleep(SYN_DELAY); + + soap->socket = data->fopen(soap, data->endpoint, data->host, data->port); + if (soap->error || !soap_valid_socket(soap->socket)) + goto _out; + + if (data->fsend(soap, data->sendBuffer, s-data->sendBuffer) || + data->fsend(soap, authResponse, len) || + data->fsend(soap, "\r\n", 2) || + data->fsend(soap, s, data->sendBufferLength - (s-data->sendBuffer))) + goto _out; + + // after send - send FIN if needed +#ifdef WITH_OPENSSL + if (!soap->ssl && soap_valid_socket(soap->socket) && !soap->keep_alive) + soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 1); // Send TCP FIN +#else + if (soap_valid_socket(soap->socket) && !soap->keep_alive) + soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 1); // Send TCP FIN +#endif + + data->rcvRead = data->frecv(soap, buf, size); + +_out: + if (data->sendBuffer) { + free(data->sendBuffer); + data->sendBuffer = NULL; + } + soap->frecv = data->frecv; + return data->rcvRead; +} + + + + + diff --git a/pcucontrol/models/intelamt/soapC.cpp b/pcucontrol/models/intelamt/soapC.cpp new file mode 100644 index 0000000..53a5b7e --- /dev/null +++ b/pcucontrol/models/intelamt/soapC.cpp @@ -0,0 +1,152355 @@ +/* soapC.cpp + Generated by gSOAP 2.7.8c from ../../Samples/gSoapGeneratedCode/AmtWsdlInterface.h + Copyright (C) 2000-2006, Robert van Engelen, Genivia Inc. All Rights Reserved. + This part of the software is released under one of the following licenses: + GPL, the gSOAP public license, or Genivia's license for commercial use. +*/ + +#include "soapH.h" + +SOAP_SOURCE_STAMP("@(#) soapC.cpp ver 2.7.8c 2007-06-07 16:01:50 GMT") + + +#ifndef WITH_NOGLOBAL + +SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap) +{ + if (soap->header) + soap_serialize_SOAP_ENV__Header(soap, soap->header); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap) +{ + if (soap->header) + { soap->part = SOAP_IN_HEADER; + soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL); + soap->part = SOAP_END_HEADER; + } + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap) +{ + soap->part = SOAP_IN_HEADER; + soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL); + soap->part = SOAP_END_HEADER; + return soap->header == NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap) +{ + if (!soap->fault) + { soap->fault = (struct SOAP_ENV__Fault*)soap_malloc(soap, sizeof(struct SOAP_ENV__Fault)); + soap_default_SOAP_ENV__Fault(soap, soap->fault); + } + if (soap->version == 2 && !soap->fault->SOAP_ENV__Code) + { soap->fault->SOAP_ENV__Code = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code)); + soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code); + } + if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason) + { soap->fault->SOAP_ENV__Reason = (struct SOAP_ENV__Reason*)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason)); + soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason); + } +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap) +{ + if (soap->fault) + soap_serialize_SOAP_ENV__Fault(soap, soap->fault); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap) +{ + if (soap->fault) + return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", NULL); + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap) +{ + return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL; +} + +SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap) +{ + soap_fault(soap); + if (soap->version == 2) + return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value; + return (const char**)&soap->fault->faultcode; +} + +SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap) +{ + soap_fault(soap); + if (soap->version == 2) + { if (!soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode) + { soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code)); + soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode); + } + return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value; + } + return (const char**)&soap->fault->faultcode; +} + +SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap) +{ + soap_fault(soap); + if (soap->version == 2) + return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text; + return (const char**)&soap->fault->faultstring; +} + +SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap) +{ + soap_fault(soap); + if (soap->version == 1) + { if (!soap->fault->detail) + { soap->fault->detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail)); + soap_default_SOAP_ENV__Detail(soap, soap->fault->detail); + } + return (const char**)&soap->fault->detail->__any; + } + if (!soap->fault->SOAP_ENV__Detail) + { soap->fault->SOAP_ENV__Detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail)); + soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail); + } + return (const char**)&soap->fault->SOAP_ENV__Detail->__any; +} + +#endif + +#ifndef WITH_NOIDREF +SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap) +{ + int t; + for (;;) + if (!soap_getelement(soap, &t)) + if (soap->error || soap_ignore_element(soap)) + break; + if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF) + soap->error = SOAP_OK; + return soap->error; +} +#endif + +#ifndef WITH_NOIDREF +SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, int *type) +{ + if (soap_peek_element(soap)) + return NULL; + if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id))) + *type = soap_lookup_type(soap, soap->href); + switch (*type) + { + case SOAP_TYPE_byte: + return soap_in_byte(soap, NULL, NULL, "xsd:byte"); + case SOAP_TYPE_short: + return soap_in_short(soap, NULL, NULL, "xsd:short"); + case SOAP_TYPE_int: + return soap_in_int(soap, NULL, NULL, "xsd:int"); + case SOAP_TYPE_wcxs__ProfilePriorityType: + return soap_in_wcxs__ProfilePriorityType(soap, NULL, NULL, "wcxs:ProfilePriorityType"); + case SOAP_TYPE_rci__SystemCapabilitiesSupportedType: + return soap_in_rci__SystemCapabilitiesSupportedType(soap, NULL, NULL, "rci:SystemCapabilitiesSupportedType"); + case SOAP_TYPE_apr__WatchdogState: + return soap_in_apr__WatchdogState(soap, NULL, NULL, "apr:WatchdogState"); + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE: + return soap_in_hwa__PT_USCOREMEMORY_USCORETYPE(soap, NULL, NULL, "hwa:PT_MEMORY_TYPE"); + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR: + return soap_in_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(soap, NULL, NULL, "hwa:PT_MEMORY_FORM_FACTOR"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE: + return soap_in_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(soap, NULL, NULL, "hwa:PT_PROCESSOR_UPGRADE"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS: + return soap_in_hwa__PT_USCOREPROCESSOR_USCORESTATUS(soap, NULL, NULL, "hwa:PT_PROCESSOR_STATUS"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY: + return soap_in_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(soap, NULL, NULL, "hwa:PT_PROCESSOR_FAMILY"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE: + return soap_in_hwa__PT_USCOREPROCESSOR_USCORETYPE(soap, NULL, NULL, "hwa:PT_PROCESSOR_TYPE"); + case SOAP_TYPE_emi__AlertSubscriptionPolicyIDType: + return soap_in_emi__AlertSubscriptionPolicyIDType(soap, NULL, NULL, "emi:AlertSubscriptionPolicyIDType"); + case SOAP_TYPE_net__LinkPolicyType: + return soap_in_net__LinkPolicyType(soap, NULL, NULL, "net:LinkPolicyType"); + case SOAP_TYPE_unsignedByte: + return soap_in_unsignedByte(soap, NULL, NULL, "xsd:unsignedByte"); + case SOAP_TYPE_rci__OemParametersType: + return soap_in_rci__OemParametersType(soap, NULL, NULL, "rci:OemParametersType"); + case SOAP_TYPE_rci__SpecialCommandParameterType: + return soap_in_rci__SpecialCommandParameterType(soap, NULL, NULL, "rci:SpecialCommandParameterType"); + case SOAP_TYPE_rci__BootOptionsType: + return soap_in_rci__BootOptionsType(soap, NULL, NULL, "rci:BootOptionsType"); + case SOAP_TYPE_rci__SpecialCommandsSupportedType: + return soap_in_rci__SpecialCommandsSupportedType(soap, NULL, NULL, "rci:SpecialCommandsSupportedType"); + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL: + return soap_in_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(soap, NULL, NULL, "hwa:PT_MEMORY_TYPE_DETAIL"); + case SOAP_TYPE_unsignedShort: + return soap_in_unsignedShort(soap, NULL, NULL, "xsd:unsignedShort"); + case SOAP_TYPE_rci__OemDefinedCapabilitiesType: + return soap_in_rci__OemDefinedCapabilitiesType(soap, NULL, NULL, "rci:OemDefinedCapabilitiesType"); + case SOAP_TYPE_rci__SystemFirmwareCapabilitiesType: + return soap_in_rci__SystemFirmwareCapabilitiesType(soap, NULL, NULL, "rci:SystemFirmwareCapabilitiesType"); + case SOAP_TYPE_rci__PT_USCORESTATUS: + return soap_in_rci__PT_USCORESTATUS(soap, NULL, NULL, "rci:PT_STATUS"); + case SOAP_TYPE_rci__SystemPowerStateType: + return soap_in_rci__SystemPowerStateType(soap, NULL, NULL, "rci:SystemPowerStateType"); + case SOAP_TYPE_inf__IPv4AddressType: + return soap_in_inf__IPv4AddressType(soap, NULL, NULL, "inf:IPv4AddressType"); + case SOAP_TYPE_inf__TimeType: + return soap_in_inf__TimeType(soap, NULL, NULL, "inf:TimeType"); + case SOAP_TYPE_inf__PT_USCORESTATUS: + return soap_in_inf__PT_USCORESTATUS(soap, NULL, NULL, "inf:PT_STATUS"); + case SOAP_TYPE_str__PT_USCORESTATUS: + return soap_in_str__PT_USCORESTATUS(soap, NULL, NULL, "str:PT_STATUS"); + case SOAP_TYPE_tim__TimeType: + return soap_in_tim__TimeType(soap, NULL, NULL, "tim:TimeType"); + case SOAP_TYPE_tim__PT_USCORESTATUS: + return soap_in_tim__PT_USCORESTATUS(soap, NULL, NULL, "tim:PT_STATUS"); + case SOAP_TYPE_idr__IPv4AddressType: + return soap_in_idr__IPv4AddressType(soap, NULL, NULL, "idr:IPv4AddressType"); + case SOAP_TYPE_idr__TimeType: + return soap_in_idr__TimeType(soap, NULL, NULL, "idr:TimeType"); + case SOAP_TYPE_idr__PT_USCORESTATUS: + return soap_in_idr__PT_USCORESTATUS(soap, NULL, NULL, "idr:PT_STATUS"); + case SOAP_TYPE_apl__PT_USCORESTATUS: + return soap_in_apl__PT_USCORESTATUS(soap, NULL, NULL, "apl:PT_STATUS"); + case SOAP_TYPE_apr__PT_USCORESTATUS: + return soap_in_apr__PT_USCORESTATUS(soap, NULL, NULL, "apr:PT_STATUS"); + case SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS: + return soap_in_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(soap, NULL, NULL, "hwa:PT_BIOS_CHARACTERISTICS"); + case SOAP_TYPE_hwa__PT_USCORESTATUS: + return soap_in_hwa__PT_USCORESTATUS(soap, NULL, NULL, "hwa:PT_STATUS"); + case SOAP_TYPE_cb__TimeType: + return soap_in_cb__TimeType(soap, NULL, NULL, "cb:TimeType"); + case SOAP_TYPE_cb__PT_USCORESTATUS: + return soap_in_cb__PT_USCORESTATUS(soap, NULL, NULL, "cb:PT_STATUS"); + case SOAP_TYPE_emi__SensorHandleType: + return soap_in_emi__SensorHandleType(soap, NULL, NULL, "emi:SensorHandleType"); + case SOAP_TYPE_emi__IPv4AddressType: + return soap_in_emi__IPv4AddressType(soap, NULL, NULL, "emi:IPv4AddressType"); + case SOAP_TYPE_emi__PT_USCORESTATUS: + return soap_in_emi__PT_USCORESTATUS(soap, NULL, NULL, "emi:PT_STATUS"); + case SOAP_TYPE_emi__EventFilterHandleType: + return soap_in_emi__EventFilterHandleType(soap, NULL, NULL, "emi:EventFilterHandleType"); + case SOAP_TYPE_emi__AlertSubscriptionHandleType: + return soap_in_emi__AlertSubscriptionHandleType(soap, NULL, NULL, "emi:AlertSubscriptionHandleType"); + case SOAP_TYPE_emi__TimeType: + return soap_in_emi__TimeType(soap, NULL, NULL, "emi:TimeType"); + case SOAP_TYPE_stra__StorageAllocEntryHandleType: + return soap_in_stra__StorageAllocEntryHandleType(soap, NULL, NULL, "stra:StorageAllocEntryHandleType"); + case SOAP_TYPE_stra__StorageEaclEntryHandleType: + return soap_in_stra__StorageEaclEntryHandleType(soap, NULL, NULL, "stra:StorageEaclEntryHandleType"); + case SOAP_TYPE_stra__StorageApplicationHandleType: + return soap_in_stra__StorageApplicationHandleType(soap, NULL, NULL, "stra:StorageApplicationHandleType"); + case SOAP_TYPE_stra__PT_USCORESTATUS: + return soap_in_stra__PT_USCORESTATUS(soap, NULL, NULL, "stra:PT_STATUS"); + case SOAP_TYPE_net__InterfaceHandleType: + return soap_in_net__InterfaceHandleType(soap, NULL, NULL, "net:InterfaceHandleType"); + case SOAP_TYPE_net__IPv4AddressType: + return soap_in_net__IPv4AddressType(soap, NULL, NULL, "net:IPv4AddressType"); + case SOAP_TYPE_net__PT_USCORESTATUS: + return soap_in_net__PT_USCORESTATUS(soap, NULL, NULL, "net:PT_STATUS"); + case SOAP_TYPE_sai__CertificateHandleType: + return soap_in_sai__CertificateHandleType(soap, NULL, NULL, "sai:CertificateHandleType"); + case SOAP_TYPE_sai__IPv4AddressType: + return soap_in_sai__IPv4AddressType(soap, NULL, NULL, "sai:IPv4AddressType"); + case SOAP_TYPE_sai__UserAclEntryHandleType: + return soap_in_sai__UserAclEntryHandleType(soap, NULL, NULL, "sai:UserAclEntryHandleType"); + case SOAP_TYPE_sai__PT_USCORESTATUS: + return soap_in_sai__PT_USCORESTATUS(soap, NULL, NULL, "sai:PT_STATUS"); + case SOAP_TYPE_cstr__KeyPairHandleType: + return soap_in_cstr__KeyPairHandleType(soap, NULL, NULL, "cstr:KeyPairHandleType"); + case SOAP_TYPE_cmn__InterfaceHandleType: + return soap_in_cmn__InterfaceHandleType(soap, NULL, NULL, "cmn:InterfaceHandleType"); + case SOAP_TYPE_cmn__IPv4AddressType: + return soap_in_cmn__IPv4AddressType(soap, NULL, NULL, "cmn:IPv4AddressType"); + case SOAP_TYPE_cmn__PT_USCORESTATUS: + return soap_in_cmn__PT_USCORESTATUS(soap, NULL, NULL, "cmn:PT_STATUS"); + case SOAP_TYPE_unsignedInt: + return soap_in_unsignedInt(soap, NULL, NULL, "xsd:unsignedInt"); + case SOAP_TYPE_bool: + return soap_in_bool(soap, NULL, NULL, "xsd:boolean"); + case SOAP_TYPE_wcxs__FeatureType: + return soap_in_wcxs__FeatureType(soap, NULL, NULL, "wcxs:FeatureType"); + case SOAP_TYPE_wcxs__KeyIndexType: + return soap_in_wcxs__KeyIndexType(soap, NULL, NULL, "wcxs:KeyIndexType"); + case SOAP_TYPE_rci__SpecialCommandType: + return soap_in_rci__SpecialCommandType(soap, NULL, NULL, "rci:SpecialCommandType"); + case SOAP_TYPE_rci__RemoteControlCommandType: + return soap_in_rci__RemoteControlCommandType(soap, NULL, NULL, "rci:RemoteControlCommandType"); + case SOAP_TYPE_inf__EnabledInterfacesType: + return soap_in_inf__EnabledInterfacesType(soap, NULL, NULL, "inf:EnabledInterfacesType"); + case SOAP_TYPE_inf__PasswordModelType: + return soap_in_inf__PasswordModelType(soap, NULL, NULL, "inf:PasswordModelType"); + case SOAP_TYPE_inf__ProvisioningStateType: + return soap_in_inf__ProvisioningStateType(soap, NULL, NULL, "inf:ProvisioningStateType"); + case SOAP_TYPE_inf__ProvisioningModeType: + return soap_in_inf__ProvisioningModeType(soap, NULL, NULL, "inf:ProvisioningModeType"); + case SOAP_TYPE_apr__CbActionType: + return soap_in_apr__CbActionType(soap, NULL, NULL, "apr:CbActionType"); + case SOAP_TYPE_hwa__AssetTypeType: + return soap_in_hwa__AssetTypeType(soap, NULL, NULL, "hwa:AssetTypeType"); + case SOAP_TYPE_cb__HcbTriggerReasonType: + return soap_in_cb__HcbTriggerReasonType(soap, NULL, NULL, "cb:HcbTriggerReasonType"); + case SOAP_TYPE_cb__HcbStateType: + return soap_in_cb__HcbStateType(soap, NULL, NULL, "cb:HcbStateType"); + case SOAP_TYPE_cb__CircuitBreakerApplicationType: + return soap_in_cb__CircuitBreakerApplicationType(soap, NULL, NULL, "cb:CircuitBreakerApplicationType"); + case SOAP_TYPE_cb__CircuitBreakerProfileType: + return soap_in_cb__CircuitBreakerProfileType(soap, NULL, NULL, "cb:CircuitBreakerProfileType"); + case SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType: + return soap_in_cb__CircuitBreakerFilterIPAddressDirectionType(soap, NULL, NULL, "cb:CircuitBreakerFilterIPAddressDirectionType"); + case SOAP_TYPE_cb__CircuitBreakerFilterDirectionType: + return soap_in_cb__CircuitBreakerFilterDirectionType(soap, NULL, NULL, "cb:CircuitBreakerFilterDirectionType"); + case SOAP_TYPE_emi__AlertAuthOptionsType: + return soap_in_emi__AlertAuthOptionsType(soap, NULL, NULL, "emi:AlertAuthOptionsType"); + case SOAP_TYPE_emi__EventSeverityType: + return soap_in_emi__EventSeverityType(soap, NULL, NULL, "emi:EventSeverityType"); + case SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE: + return soap_in_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, NULL, NULL, "stra:ISVS_APP_ATTR_TYPE"); + case SOAP_TYPE_net__InterfaceModeType: + return soap_in_net__InterfaceModeType(soap, NULL, NULL, "net:InterfaceModeType"); + case SOAP_TYPE_net__DhcpModeType: + return soap_in_net__DhcpModeType(soap, NULL, NULL, "net:DhcpModeType"); + case SOAP_TYPE_xcfg__CertNameOptionsType: + return soap_in_xcfg__CertNameOptionsType(soap, NULL, NULL, "xcfg:CertNameOptionsType"); + case SOAP_TYPE_sai__HTTPAuthOptionType: + return soap_in_sai__HTTPAuthOptionType(soap, NULL, NULL, "sai:HTTPAuthOptionType"); + case SOAP_TYPE_sai__HashTypeType: + return soap_in_sai__HashTypeType(soap, NULL, NULL, "sai:HashTypeType"); + case SOAP_TYPE_sai__ProvisioningTLSModeType: + return soap_in_sai__ProvisioningTLSModeType(soap, NULL, NULL, "sai:ProvisioningTLSModeType"); + case SOAP_TYPE_sai__TlsAthenticationType: + return soap_in_sai__TlsAthenticationType(soap, NULL, NULL, "sai:TlsAthenticationType"); + case SOAP_TYPE_sai__InterfaceType: + return soap_in_sai__InterfaceType(soap, NULL, NULL, "sai:InterfaceType"); + case SOAP_TYPE_sai__EnabledInterfacesType: + return soap_in_sai__EnabledInterfacesType(soap, NULL, NULL, "sai:EnabledInterfacesType"); + case SOAP_TYPE_sai__PowerStateType: + return soap_in_sai__PowerStateType(soap, NULL, NULL, "sai:PowerStateType"); + case SOAP_TYPE_sai__KerberosEncryptionType: + return soap_in_sai__KerberosEncryptionType(soap, NULL, NULL, "sai:KerberosEncryptionType"); + case SOAP_TYPE_sai__KerberosSpnProtocolType: + return soap_in_sai__KerberosSpnProtocolType(soap, NULL, NULL, "sai:KerberosSpnProtocolType"); + case SOAP_TYPE_sai__AccessPermissionType: + return soap_in_sai__AccessPermissionType(soap, NULL, NULL, "sai:AccessPermissionType"); + case SOAP_TYPE_sai__ProvisioningModeType: + return soap_in_sai__ProvisioningModeType(soap, NULL, NULL, "sai:ProvisioningModeType"); + case SOAP_TYPE_sai__RngKeyEncodingType: + return soap_in_sai__RngKeyEncodingType(soap, NULL, NULL, "sai:RngKeyEncodingType"); + case SOAP_TYPE_sai__RsaCertificateEncodingType: + return soap_in_sai__RsaCertificateEncodingType(soap, NULL, NULL, "sai:RsaCertificateEncodingType"); + case SOAP_TYPE_sai__RsaKeyEncodingType: + return soap_in_sai__RsaKeyEncodingType(soap, NULL, NULL, "sai:RsaKeyEncodingType"); + case SOAP_TYPE_sai__UserAclRealmType: + return soap_in_sai__UserAclRealmType(soap, NULL, NULL, "sai:UserAclRealmType"); + case SOAP_TYPE_wcxs__PassPhrase63Type: + return soap_in_wcxs__PassPhrase63Type(soap, NULL, NULL, "wcxs:PassPhrase63Type"); + case SOAP_TYPE_wcxs__PassPhraseWEP128Type: + return soap_in_wcxs__PassPhraseWEP128Type(soap, NULL, NULL, "wcxs:PassPhraseWEP128Type"); + case SOAP_TYPE_wcxs__PassPhrase5Type: + return soap_in_wcxs__PassPhrase5Type(soap, NULL, NULL, "wcxs:PassPhrase5Type"); + case SOAP_TYPE_wcxs__RawKey256Type: + return soap_in_wcxs__RawKey256Type(soap, NULL, NULL, "wcxs:RawKey256Type"); + case SOAP_TYPE_wcxs__RawKey128Type: + return soap_in_wcxs__RawKey128Type(soap, NULL, NULL, "wcxs:RawKey128Type"); + case SOAP_TYPE_wcxs__RawKey64Type: + return soap_in_wcxs__RawKey64Type(soap, NULL, NULL, "wcxs:RawKey64Type"); + case SOAP_TYPE_wcxs__ProfileNameType: + return soap_in_wcxs__ProfileNameType(soap, NULL, NULL, "wcxs:ProfileNameType"); + case SOAP_TYPE_cb__IPv6AddressStringType: + return soap_in_cb__IPv6AddressStringType(soap, NULL, NULL, "cb:IPv6AddressStringType"); + case SOAP_TYPE_cb__IPv4AddressStringType: + return soap_in_cb__IPv4AddressStringType(soap, NULL, NULL, "cb:IPv4AddressStringType"); + case SOAP_TYPE_emi__CommunityStringType: + return soap_in_emi__CommunityStringType(soap, NULL, NULL, "emi:CommunityStringType"); + case SOAP_TYPE_net__MACAddressType: + return soap_in_net__MACAddressType(soap, NULL, NULL, "net:MACAddressType"); + case SOAP_TYPE_sai__FriendlyNameType: + return soap_in_sai__FriendlyNameType(soap, NULL, NULL, "sai:FriendlyNameType"); + case SOAP_TYPE_sai__ProvisioningOTPType: + return soap_in_sai__ProvisioningOTPType(soap, NULL, NULL, "sai:ProvisioningOTPType"); + case SOAP_TYPE_sai__MEBxPasswordType: + return soap_in_sai__MEBxPasswordType(soap, NULL, NULL, "sai:MEBxPasswordType"); + case SOAP_TYPE_sai__AclPasswordStringType: + return soap_in_sai__AclPasswordStringType(soap, NULL, NULL, "sai:AclPasswordStringType"); + case SOAP_TYPE_sai__AclStringType: + return soap_in_sai__AclStringType(soap, NULL, NULL, "sai:AclStringType"); + case SOAP_TYPE_cmn__GuidBuf: + return soap_in_cmn__GuidBuf(soap, NULL, NULL, "cmn:GuidBuf"); + case SOAP_TYPE_cmn__IPv6AddressStringType: + return soap_in_cmn__IPv6AddressStringType(soap, NULL, NULL, "cmn:IPv6AddressStringType"); + case SOAP_TYPE_cmn__IPv4AddressStringType: + return soap_in_cmn__IPv4AddressStringType(soap, NULL, NULL, "cmn:IPv4AddressStringType"); + case SOAP_TYPE_cmn__HostNameType: + return soap_in_cmn__HostNameType(soap, NULL, NULL, "cmn:HostNameType"); + case SOAP_TYPE_wcxs__WirelessSettingsType: + return soap_in_wcxs__WirelessSettingsType(soap, NULL, NULL, "wcxs:WirelessSettingsType"); + case SOAP_TYPE_wcxs__WirelessCapabilitiesType: + return soap_in_wcxs__WirelessCapabilitiesType(soap, NULL, NULL, "wcxs:WirelessCapabilitiesType"); + case SOAP_TYPE_wcxs__ProfileType: + return soap_in_wcxs__ProfileType(soap, NULL, NULL, "wcxs:ProfileType"); + case SOAP_TYPE_wcxs__ProfileSecuritySettingsType: + return soap_in_wcxs__ProfileSecuritySettingsType(soap, NULL, NULL, "wcxs:ProfileSecuritySettingsType"); + case SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType: + return soap_in_wcxs__ProfileSecuritySettingRSNType(soap, NULL, NULL, "wcxs:ProfileSecuritySettingRSNType"); + case SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType: + return soap_in_wcxs__ProfileSecuritySettingWPAType(soap, NULL, NULL, "wcxs:ProfileSecuritySettingWPAType"); + case SOAP_TYPE_wcxs__DataEncryptionCCMPType: + return soap_in_wcxs__DataEncryptionCCMPType(soap, NULL, NULL, "wcxs:DataEncryptionCCMPType"); + case SOAP_TYPE_wcxs__DataEncryptionTKIPType: + return soap_in_wcxs__DataEncryptionTKIPType(soap, NULL, NULL, "wcxs:DataEncryptionTKIPType"); + case SOAP_TYPE_wcxs__DataEncryptionWEPType: + return soap_in_wcxs__DataEncryptionWEPType(soap, NULL, NULL, "wcxs:DataEncryptionWEPType"); + case SOAP_TYPE_wcxs__DataEncryptionWEPXType: + return soap_in_wcxs__DataEncryptionWEPXType(soap, NULL, NULL, "wcxs:DataEncryptionWEPXType"); + case SOAP_TYPE_wcxs__WEP128Type: + return soap_in_wcxs__WEP128Type(soap, NULL, NULL, "wcxs:WEP128Type"); + case SOAP_TYPE_wcxs__WEP64Type: + return soap_in_wcxs__WEP64Type(soap, NULL, NULL, "wcxs:WEP64Type"); + case SOAP_TYPE_inf__FirmwareVersionType: + return soap_in_inf__FirmwareVersionType(soap, NULL, NULL, "inf:FirmwareVersionType"); + case SOAP_TYPE_inf__IderSessionLogEntryType: + return soap_in_inf__IderSessionLogEntryType(soap, NULL, NULL, "inf:IderSessionLogEntryType"); + case SOAP_TYPE_idr__FirmwareVersionType: + return soap_in_idr__FirmwareVersionType(soap, NULL, NULL, "idr:FirmwareVersionType"); + case SOAP_TYPE_idr__IderSessionLogEntryType: + return soap_in_idr__IderSessionLogEntryType(soap, NULL, NULL, "idr:IderSessionLogEntryType"); + case SOAP_TYPE_apl__GUID: + return soap_in_apl__GUID(soap, NULL, NULL, "apl:GUID"); + case SOAP_TYPE_apr__AgentPresenceCapabilitiesType: + return soap_in_apr__AgentPresenceCapabilitiesType(soap, NULL, NULL, "apr:AgentPresenceCapabilitiesType"); + case SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType: + return soap_in_apr__CircuitBreakerHardwarePolicyType(soap, NULL, NULL, "apr:CircuitBreakerHardwarePolicyType"); + case SOAP_TYPE_apr__ConsoleWatchdogActionType: + return soap_in_apr__ConsoleWatchdogActionType(soap, NULL, NULL, "apr:ConsoleWatchdogActionType"); + case SOAP_TYPE_apr__ConsoleWatchdogEntryType: + return soap_in_apr__ConsoleWatchdogEntryType(soap, NULL, NULL, "apr:ConsoleWatchdogEntryType"); + case SOAP_TYPE_apr__GUID: + return soap_in_apr__GUID(soap, NULL, NULL, "apr:GUID"); + case SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE: + return soap_in_hwa__PT_USCOREMEDIA_USCOREDEVICE(soap, NULL, NULL, "hwa:PT_MEDIA_DEVICE"); + case SOAP_TYPE_hwa__PT_USCOREFRU: + return soap_in_hwa__PT_USCOREFRU(soap, NULL, NULL, "hwa:PT_FRU"); + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE: + return soap_in_hwa__PT_USCOREMEMORY_USCOREMODULE(soap, NULL, NULL, "hwa:PT_MEMORY_MODULE"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR: + return soap_in_hwa__PT_USCOREPROCESSOR(soap, NULL, NULL, "hwa:PT_PROCESSOR"); + case SOAP_TYPE_hwa__PT_USCOREBASEBOARD: + return soap_in_hwa__PT_USCOREBASEBOARD(soap, NULL, NULL, "hwa:PT_BASEBOARD"); + case SOAP_TYPE_hwa__GUID: + return soap_in_hwa__GUID(soap, NULL, NULL, "hwa:GUID"); + case SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM: + return soap_in_hwa__PT_USCORECOMPUTER_USCORESYSTEM(soap, NULL, NULL, "hwa:PT_COMPUTER_SYSTEM"); + case SOAP_TYPE_hwa__PT_USCOREBIOS: + return soap_in_hwa__PT_USCOREBIOS(soap, NULL, NULL, "hwa:PT_BIOS"); + case SOAP_TYPE_hwa__AssetDataType: + return soap_in_hwa__AssetDataType(soap, NULL, NULL, "hwa:AssetDataType"); + case SOAP_TYPE_hwa__AssetDataArrayType: + return soap_in_hwa__AssetDataArrayType(soap, NULL, NULL, "hwa:AssetDataArrayType"); + case SOAP_TYPE_hwa__AssetTypeArrayType: + return soap_in_hwa__AssetTypeArrayType(soap, NULL, NULL, "hwa:AssetTypeArrayType"); + case SOAP_TYPE_cb__HcbOptionsType: + return soap_in_cb__HcbOptionsType(soap, NULL, NULL, "cb:HcbOptionsType"); + case SOAP_TYPE_cb__BlockedPortInfoType: + return soap_in_cb__BlockedPortInfoType(soap, NULL, NULL, "cb:BlockedPortInfoType"); + case SOAP_TYPE_cb__TimedCounterType: + return soap_in_cb__TimedCounterType(soap, NULL, NULL, "cb:TimedCounterType"); + case SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType: + return soap_in_cb__CircuitBreakerHardwarePolicyType(soap, NULL, NULL, "cb:CircuitBreakerHardwarePolicyType"); + case SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType: + return soap_in_cb__CircuitBreakerFilterStatisticsType(soap, NULL, NULL, "cb:CircuitBreakerFilterStatisticsType"); + case SOAP_TYPE_cb__CircuitBreakerCapabilitiesType: + return soap_in_cb__CircuitBreakerCapabilitiesType(soap, NULL, NULL, "cb:CircuitBreakerCapabilitiesType"); + case SOAP_TYPE_cb__CircuitBreakerFilterInfoType: + return soap_in_cb__CircuitBreakerFilterInfoType(soap, NULL, NULL, "cb:CircuitBreakerFilterInfoType"); + case SOAP_TYPE_cb__CircuitBreakerFilterType: + return soap_in_cb__CircuitBreakerFilterType(soap, NULL, NULL, "cb:CircuitBreakerFilterType"); + case SOAP_TYPE_cb__CircuitBreakerPacketType: + return soap_in_cb__CircuitBreakerPacketType(soap, NULL, NULL, "cb:CircuitBreakerPacketType"); + case SOAP_TYPE_cb__CircuitBreakerPacketETHType: + return soap_in_cb__CircuitBreakerPacketETHType(soap, NULL, NULL, "cb:CircuitBreakerPacketETHType"); + case SOAP_TYPE_cb__CircuitBreakerPacketIPType: + return soap_in_cb__CircuitBreakerPacketIPType(soap, NULL, NULL, "cb:CircuitBreakerPacketIPType"); + case SOAP_TYPE_cb__CircuitBreakerPacketTCPType: + return soap_in_cb__CircuitBreakerPacketTCPType(soap, NULL, NULL, "cb:CircuitBreakerPacketTCPType"); + case SOAP_TYPE_cb__CircuitBreakerPacketUDPType: + return soap_in_cb__CircuitBreakerPacketUDPType(soap, NULL, NULL, "cb:CircuitBreakerPacketUDPType"); + case SOAP_TYPE_cb__CircuitBreakerIPPacketType: + return soap_in_cb__CircuitBreakerIPPacketType(soap, NULL, NULL, "cb:CircuitBreakerIPPacketType"); + case SOAP_TYPE_cb__CircuitBreakerIPv6Type: + return soap_in_cb__CircuitBreakerIPv6Type(soap, NULL, NULL, "cb:CircuitBreakerIPv6Type"); + case SOAP_TYPE_cb__CircuitBreakerIPv4Type: + return soap_in_cb__CircuitBreakerIPv4Type(soap, NULL, NULL, "cb:CircuitBreakerIPv4Type"); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType: + return soap_in_cb__CircuitBreakerIPLayeredTCPFlagsType(soap, NULL, NULL, "cb:CircuitBreakerIPLayeredTCPFlagsType"); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType: + return soap_in_cb__CircuitBreakerIPLayeredPortType(soap, NULL, NULL, "cb:CircuitBreakerIPLayeredPortType"); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType: + return soap_in_cb__CircuitBreakerIPLayeredPortRangeType(soap, NULL, NULL, "cb:CircuitBreakerIPLayeredPortRangeType"); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType: + return soap_in_cb__CircuitBreakerIPLayeredPortSimpleType(soap, NULL, NULL, "cb:CircuitBreakerIPLayeredPortSimpleType"); + case SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType: + return soap_in_cb__CircuitBreakerIPv6AddressAndMaskType(soap, NULL, NULL, "cb:CircuitBreakerIPv6AddressAndMaskType"); + case SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType: + return soap_in_cb__CircuitBreakerIPv4AddressAndMaskType(soap, NULL, NULL, "cb:CircuitBreakerIPv4AddressAndMaskType"); + case SOAP_TYPE_cb__CircuitBreakerPolicyInfoType: + return soap_in_cb__CircuitBreakerPolicyInfoType(soap, NULL, NULL, "cb:CircuitBreakerPolicyInfoType"); + case SOAP_TYPE_cb__CircuitBreakerPolicyType: + return soap_in_cb__CircuitBreakerPolicyType(soap, NULL, NULL, "cb:CircuitBreakerPolicyType"); + case SOAP_TYPE_cb__CircuitBreakerDefaultFilterType: + return soap_in_cb__CircuitBreakerDefaultFilterType(soap, NULL, NULL, "cb:CircuitBreakerDefaultFilterType"); + case SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType: + return soap_in_cb__CircuitBreakerAntiSpoofingFilterType(soap, NULL, NULL, "cb:CircuitBreakerAntiSpoofingFilterType"); + case SOAP_TYPE_emi__AlertSubscriptionGeneralType: + return soap_in_emi__AlertSubscriptionGeneralType(soap, NULL, NULL, "emi:AlertSubscriptionGeneralType"); + case SOAP_TYPE_emi__AlertSubscriptionSoapType: + return soap_in_emi__AlertSubscriptionSoapType(soap, NULL, NULL, "emi:AlertSubscriptionSoapType"); + case SOAP_TYPE_emi__AlertSubscriptionSNMPType: + return soap_in_emi__AlertSubscriptionSNMPType(soap, NULL, NULL, "emi:AlertSubscriptionSNMPType"); + case SOAP_TYPE_emi__AlertCredentialsType: + return soap_in_emi__AlertCredentialsType(soap, NULL, NULL, "emi:AlertCredentialsType"); + case SOAP_TYPE_emi__ByteStr: + return soap_in_emi__ByteStr(soap, NULL, NULL, "emi:ByteStr"); + case SOAP_TYPE_emi__SensorAttributesType: + return soap_in_emi__SensorAttributesType(soap, NULL, NULL, "emi:SensorAttributesType"); + case SOAP_TYPE_emi__SensorHandleArrayType: + return soap_in_emi__SensorHandleArrayType(soap, NULL, NULL, "emi:SensorHandleArrayType"); + case SOAP_TYPE_emi__EventLogRecordArrayType: + return soap_in_emi__EventLogRecordArrayType(soap, NULL, NULL, "emi:EventLogRecordArrayType"); + case SOAP_TYPE_emi__EventFilterHandleArrayType: + return soap_in_emi__EventFilterHandleArrayType(soap, NULL, NULL, "emi:EventFilterHandleArrayType"); + case SOAP_TYPE_emi__AlertSubscriptionHandleArrayType: + return soap_in_emi__AlertSubscriptionHandleArrayType(soap, NULL, NULL, "emi:AlertSubscriptionHandleArrayType"); + case SOAP_TYPE_emi__AlertSubscriptionType: + return soap_in_emi__AlertSubscriptionType(soap, NULL, NULL, "emi:AlertSubscriptionType"); + case SOAP_TYPE_emi__EventFilterType: + return soap_in_emi__EventFilterType(soap, NULL, NULL, "emi:EventFilterType"); + case SOAP_TYPE_emi__EventLogRecordType: + return soap_in_emi__EventLogRecordType(soap, NULL, NULL, "emi:EventLogRecordType"); + case SOAP_TYPE_emi__ByteData: + return soap_in_emi__ByteData(soap, NULL, NULL, "emi:ByteData"); + case SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType: + return soap_in_emi__AlertSubscriptionPolicyIDArrayType(soap, NULL, NULL, "emi:AlertSubscriptionPolicyIDArrayType"); + case SOAP_TYPE_stra__StorageApplicationAttributesType: + return soap_in_stra__StorageApplicationAttributesType(soap, NULL, NULL, "stra:StorageApplicationAttributesType"); + case SOAP_TYPE_stra__StorageSnrpApplicationAttributeType: + return soap_in_stra__StorageSnrpApplicationAttributeType(soap, NULL, NULL, "stra:StorageSnrpApplicationAttributeType"); + case SOAP_TYPE_stra__StorageApplicationHandleListType: + return soap_in_stra__StorageApplicationHandleListType(soap, NULL, NULL, "stra:StorageApplicationHandleListType"); + case SOAP_TYPE_stra__GlobalStorageAttributesType: + return soap_in_stra__GlobalStorageAttributesType(soap, NULL, NULL, "stra:GlobalStorageAttributesType"); + case SOAP_TYPE_stra__GUID: + return soap_in_stra__GUID(soap, NULL, NULL, "stra:GUID"); + case SOAP_TYPE_stra__StorageAllocEntryHandleListType: + return soap_in_stra__StorageAllocEntryHandleListType(soap, NULL, NULL, "stra:StorageAllocEntryHandleListType"); + case SOAP_TYPE_stra__StorageAllocSnrpEntryType: + return soap_in_stra__StorageAllocSnrpEntryType(soap, NULL, NULL, "stra:StorageAllocSnrpEntryType"); + case SOAP_TYPE_stra__StorageAllocEntryType: + return soap_in_stra__StorageAllocEntryType(soap, NULL, NULL, "stra:StorageAllocEntryType"); + case SOAP_TYPE_stra__StorageEaclEntryHandleListType: + return soap_in_stra__StorageEaclEntryHandleListType(soap, NULL, NULL, "stra:StorageEaclEntryHandleListType"); + case SOAP_TYPE_stra__StorageEaclEntryType: + return soap_in_stra__StorageEaclEntryType(soap, NULL, NULL, "stra:StorageEaclEntryType"); + case SOAP_TYPE_net__InterfaceDescriptorGetType: + return soap_in_net__InterfaceDescriptorGetType(soap, NULL, NULL, "net:InterfaceDescriptorGetType"); + case SOAP_TYPE_net__InterfaceDescriptorSetType: + return soap_in_net__InterfaceDescriptorSetType(soap, NULL, NULL, "net:InterfaceDescriptorSetType"); + case SOAP_TYPE_net__IPv4ParametersType: + return soap_in_net__IPv4ParametersType(soap, NULL, NULL, "net:IPv4ParametersType"); + case SOAP_TYPE_net__StaticIPv4ParametersType: + return soap_in_net__StaticIPv4ParametersType(soap, NULL, NULL, "net:StaticIPv4ParametersType"); + case SOAP_TYPE_xcfg__XProfileType: + return soap_in_xcfg__XProfileType(soap, NULL, NULL, "xcfg:XProfileType"); + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType: + return soap_in_xcfg__XProfileEAPFAST_USCORETLSType(soap, NULL, NULL, "xcfg:XProfileEAPFAST_TLSType"); + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType: + return soap_in_xcfg__XProfileEAPFAST_USCOREGTCType(soap, NULL, NULL, "xcfg:XProfileEAPFAST_GTCType"); + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type: + return soap_in_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, NULL, NULL, "xcfg:XProfileEAPFAST_MSCHAPv2Type"); + case SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType: + return soap_in_xcfg__XProfileEAP_USCOREGTCType(soap, NULL, NULL, "xcfg:XProfileEAP_GTCType"); + case SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type: + return soap_in_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, NULL, NULL, "xcfg:XProfilePEAP_MSCHAPv2Type"); + case SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type: + return soap_in_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, NULL, NULL, "xcfg:XProfileTTLS_MSCHAPv2Type"); + case SOAP_TYPE_xcfg__XProfileTLSType: + return soap_in_xcfg__XProfileTLSType(soap, NULL, NULL, "xcfg:XProfileTLSType"); + case SOAP_TYPE_xcfg__ServerIdentityType: + return soap_in_xcfg__ServerIdentityType(soap, NULL, NULL, "xcfg:ServerIdentityType"); + case SOAP_TYPE_xcfg__ManualPACType: + return soap_in_xcfg__ManualPACType(soap, NULL, NULL, "xcfg:ManualPACType"); + case SOAP_TYPE_xcfg__CertificateNameType: + return soap_in_xcfg__CertificateNameType(soap, NULL, NULL, "xcfg:CertificateNameType"); + case SOAP_TYPE_xcfg__UserCredentialsType: + return soap_in_xcfg__UserCredentialsType(soap, NULL, NULL, "xcfg:UserCredentialsType"); + case SOAP_TYPE_sai__GlobalPowerPolicyType: + return soap_in_sai__GlobalPowerPolicyType(soap, NULL, NULL, "sai:GlobalPowerPolicyType"); + case SOAP_TYPE_sai__EnvironmentDetectionType: + return soap_in_sai__EnvironmentDetectionType(soap, NULL, NULL, "sai:EnvironmentDetectionType"); + case SOAP_TYPE_sai__EnvironmentDetectionDomainType: + return soap_in_sai__EnvironmentDetectionDomainType(soap, NULL, NULL, "sai:EnvironmentDetectionDomainType"); + case SOAP_TYPE_sai__ProvisioningAuditRecordType: + return soap_in_sai__ProvisioningAuditRecordType(soap, NULL, NULL, "sai:ProvisioningAuditRecordType"); + case SOAP_TYPE_sai__CertHashEntryType: + return soap_in_sai__CertHashEntryType(soap, NULL, NULL, "sai:CertHashEntryType"); + case SOAP_TYPE_sai__PkiCapsType: + return soap_in_sai__PkiCapsType(soap, NULL, NULL, "sai:PkiCapsType"); + case SOAP_TYPE_sai__CrlType: + return soap_in_sai__CrlType(soap, NULL, NULL, "sai:CrlType"); + case SOAP_TYPE_sai__CertificateType: + return soap_in_sai__CertificateType(soap, NULL, NULL, "sai:CertificateType"); + case SOAP_TYPE_sai__TlsOptionsType: + return soap_in_sai__TlsOptionsType(soap, NULL, NULL, "sai:TlsOptionsType"); + case SOAP_TYPE_sai__KerberosOptionsType: + return soap_in_sai__KerberosOptionsType(soap, NULL, NULL, "sai:KerberosOptionsType"); + case SOAP_TYPE_sai__KerberosSpnType: + return soap_in_sai__KerberosSpnType(soap, NULL, NULL, "sai:KerberosSpnType"); + case SOAP_TYPE_sai__AdminAclEntryExType: + return soap_in_sai__AdminAclEntryExType(soap, NULL, NULL, "sai:AdminAclEntryExType"); + case SOAP_TYPE_sai__UserAclEntryExType: + return soap_in_sai__UserAclEntryExType(soap, NULL, NULL, "sai:UserAclEntryExType"); + case SOAP_TYPE_sai__UserEntryKerberosType: + return soap_in_sai__UserEntryKerberosType(soap, NULL, NULL, "sai:UserEntryKerberosType"); + case SOAP_TYPE_sai__UserEntryDigestType: + return soap_in_sai__UserEntryDigestType(soap, NULL, NULL, "sai:UserEntryDigestType"); + case SOAP_TYPE_sai__AmtVersion: + return soap_in_sai__AmtVersion(soap, NULL, NULL, "sai:AmtVersion"); + case SOAP_TYPE_sai__UpdateCoreUrlKeyType: + return soap_in_sai__UpdateCoreUrlKeyType(soap, NULL, NULL, "sai:UpdateCoreUrlKeyType"); + case SOAP_TYPE_sai__CertificateChainType: + return soap_in_sai__CertificateChainType(soap, NULL, NULL, "sai:CertificateChainType"); + case SOAP_TYPE_sai__RngKeyType: + return soap_in_sai__RngKeyType(soap, NULL, NULL, "sai:RngKeyType"); + case SOAP_TYPE_sai__RsaKeyType: + return soap_in_sai__RsaKeyType(soap, NULL, NULL, "sai:RsaKeyType"); + case SOAP_TYPE_sai__UserAclRealmListType: + return soap_in_sai__UserAclRealmListType(soap, NULL, NULL, "sai:UserAclRealmListType"); + case SOAP_TYPE_sai__UserAclEntryHandleListType: + return soap_in_sai__UserAclEntryHandleListType(soap, NULL, NULL, "sai:UserAclEntryHandleListType"); + case SOAP_TYPE_sai__AdminAclEntryType: + return soap_in_sai__AdminAclEntryType(soap, NULL, NULL, "sai:AdminAclEntryType"); + case SOAP_TYPE_sai__UserAclEntryType: + return soap_in_sai__UserAclEntryType(soap, NULL, NULL, "sai:UserAclEntryType"); + case SOAP_TYPE_cstr__KeyPairType: + return soap_in_cstr__KeyPairType(soap, NULL, NULL, "cstr:KeyPairType"); + case SOAP_TYPE_cstr__RSAKeyPairType: + return soap_in_cstr__RSAKeyPairType(soap, NULL, NULL, "cstr:RSAKeyPairType"); + case SOAP_TYPE_cmn__NodeAddressType: + return soap_in_cmn__NodeAddressType(soap, NULL, NULL, "cmn:NodeAddressType"); + case SOAP_TYPE_cmn__URLType: + return soap_in_cmn__URLType(soap, NULL, NULL, "cmn:URLType"); + case SOAP_TYPE_xsd__base64Binary: + return soap_in_xsd__base64Binary(soap, NULL, NULL, "xsd:base64Binary"); + case SOAP_TYPE_xsd__anyURI: + return soap_in_xsd__anyURI(soap, NULL, NULL, "xsd:anyURI"); + case SOAP_TYPE_std__string: + return soap_in_std__string(soap, NULL, NULL, "xsd:string"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsResponse: + return soap_in_PointerTo_wcxs__GetWirelessSettingsResponse(soap, NULL, NULL, "wcxs:GetWirelessSettingsResponse"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsRequest: + return soap_in_PointerTo_wcxs__GetWirelessSettingsRequest(soap, NULL, NULL, "wcxs:GetWirelessSettingsRequest"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesResponse: + return soap_in_PointerTo_wcxs__GetWirelessCapabilitiesResponse(soap, NULL, NULL, "wcxs:GetWirelessCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesRequest: + return soap_in_PointerTo_wcxs__GetWirelessCapabilitiesRequest(soap, NULL, NULL, "wcxs:GetWirelessCapabilitiesRequest"); + case SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesResponse: + return soap_in_PointerTo_wcxs__EnumerateWirelessProfilesResponse(soap, NULL, NULL, "wcxs:EnumerateWirelessProfilesResponse"); + case SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesRequest: + return soap_in_PointerTo_wcxs__EnumerateWirelessProfilesRequest(soap, NULL, NULL, "wcxs:EnumerateWirelessProfilesRequest"); + case SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileResponse: + return soap_in_PointerTo_wcxs__UpdateWirelessProfileResponse(soap, NULL, NULL, "wcxs:UpdateWirelessProfileResponse"); + case SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileRequest: + return soap_in_PointerTo_wcxs__UpdateWirelessProfileRequest(soap, NULL, NULL, "wcxs:UpdateWirelessProfileRequest"); + case SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileResponse: + return soap_in_PointerTo_wcxs__RemoveWirelessProfileResponse(soap, NULL, NULL, "wcxs:RemoveWirelessProfileResponse"); + case SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileRequest: + return soap_in_PointerTo_wcxs__RemoveWirelessProfileRequest(soap, NULL, NULL, "wcxs:RemoveWirelessProfileRequest"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileResponse: + return soap_in_PointerTo_wcxs__GetWirelessProfileResponse(soap, NULL, NULL, "wcxs:GetWirelessProfileResponse"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileRequest: + return soap_in_PointerTo_wcxs__GetWirelessProfileRequest(soap, NULL, NULL, "wcxs:GetWirelessProfileRequest"); + case SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileResponse: + return soap_in_PointerTo_wcxs__AddWirelessProfileResponse(soap, NULL, NULL, "wcxs:AddWirelessProfileResponse"); + case SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileRequest: + return soap_in_PointerTo_wcxs__AddWirelessProfileRequest(soap, NULL, NULL, "wcxs:AddWirelessProfileRequest"); + case SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynchResponse: + return soap_in_PointerTo_tim__SetHighAccuracyTimeSynchResponse(soap, NULL, NULL, "tim:SetHighAccuracyTimeSynchResponse"); + case SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynch: + return soap_in_PointerTo_tim__SetHighAccuracyTimeSynch(soap, NULL, NULL, "tim:SetHighAccuracyTimeSynch"); + case SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynchResponse: + return soap_in_PointerTo_tim__GetLowAccuracyTimeSynchResponse(soap, NULL, NULL, "tim:GetLowAccuracyTimeSynchResponse"); + case SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynch: + return soap_in_PointerTo_tim__GetLowAccuracyTimeSynch(soap, NULL, NULL, "tim:GetLowAccuracyTimeSynch"); + case SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntryResponse: + return soap_in_PointerTo_stra__RemoveStorageFpaclEntryResponse(soap, NULL, NULL, "stra:RemoveStorageFpaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntry: + return soap_in_PointerTo_stra__RemoveStorageFpaclEntry(soap, NULL, NULL, "stra:RemoveStorageFpaclEntry"); + case SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntryResponse: + return soap_in_PointerTo_stra__UpdateStorageFpaclEntryResponse(soap, NULL, NULL, "stra:UpdateStorageFpaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntry: + return soap_in_PointerTo_stra__UpdateStorageFpaclEntry(soap, NULL, NULL, "stra:UpdateStorageFpaclEntry"); + case SOAP_TYPE_PointerTo_stra__GetStorageAllocEntryResponse: + return soap_in_PointerTo_stra__GetStorageAllocEntryResponse(soap, NULL, NULL, "stra:GetStorageAllocEntryResponse"); + case SOAP_TYPE_PointerTo_stra__GetStorageAllocEntry: + return soap_in_PointerTo_stra__GetStorageAllocEntry(soap, NULL, NULL, "stra:GetStorageAllocEntry"); + case SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntriesResponse: + return soap_in_PointerTo_stra__EnumerateStorageAllocEntriesResponse(soap, NULL, NULL, "stra:EnumerateStorageAllocEntriesResponse"); + case SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntries: + return soap_in_PointerTo_stra__EnumerateStorageAllocEntries(soap, NULL, NULL, "stra:EnumerateStorageAllocEntries"); + case SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntryResponse: + return soap_in_PointerTo_stra__AddStorageFpaclEntryResponse(soap, NULL, NULL, "stra:AddStorageFpaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntry: + return soap_in_PointerTo_stra__AddStorageFpaclEntry(soap, NULL, NULL, "stra:AddStorageFpaclEntry"); + case SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntryResponse: + return soap_in_PointerTo_stra__RemoveStorageEaclEntryResponse(soap, NULL, NULL, "stra:RemoveStorageEaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntry: + return soap_in_PointerTo_stra__RemoveStorageEaclEntry(soap, NULL, NULL, "stra:RemoveStorageEaclEntry"); + case SOAP_TYPE_PointerTo_stra__GetStorageEaclEntryResponse: + return soap_in_PointerTo_stra__GetStorageEaclEntryResponse(soap, NULL, NULL, "stra:GetStorageEaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__GetStorageEaclEntry: + return soap_in_PointerTo_stra__GetStorageEaclEntry(soap, NULL, NULL, "stra:GetStorageEaclEntry"); + case SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntriesResponse: + return soap_in_PointerTo_stra__EnumerateStorageEaclEntriesResponse(soap, NULL, NULL, "stra:EnumerateStorageEaclEntriesResponse"); + case SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntries: + return soap_in_PointerTo_stra__EnumerateStorageEaclEntries(soap, NULL, NULL, "stra:EnumerateStorageEaclEntries"); + case SOAP_TYPE_PointerTo_stra__AddStorageEaclEntryResponse: + return soap_in_PointerTo_stra__AddStorageEaclEntryResponse(soap, NULL, NULL, "stra:AddStorageEaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__AddStorageEaclEntry: + return soap_in_PointerTo_stra__AddStorageEaclEntry(soap, NULL, NULL, "stra:AddStorageEaclEntry"); + case SOAP_TYPE_PointerTo_stra__AdminRemoveApplicationResponse: + return soap_in_PointerTo_stra__AdminRemoveApplicationResponse(soap, NULL, NULL, "stra:AdminRemoveApplicationResponse"); + case SOAP_TYPE_PointerTo_stra__AdminRemoveApplication: + return soap_in_PointerTo_stra__AdminRemoveApplication(soap, NULL, NULL, "stra:AdminRemoveApplication"); + case SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributesResponse: + return soap_in_PointerTo_stra__AdminGetApplicationAttributesResponse(soap, NULL, NULL, "stra:AdminGetApplicationAttributesResponse"); + case SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributes: + return soap_in_PointerTo_stra__AdminGetApplicationAttributes(soap, NULL, NULL, "stra:AdminGetApplicationAttributes"); + case SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplicationsResponse: + return soap_in_PointerTo_stra__AdminGetRegisteredApplicationsResponse(soap, NULL, NULL, "stra:AdminGetRegisteredApplicationsResponse"); + case SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplications: + return soap_in_PointerTo_stra__AdminGetRegisteredApplications(soap, NULL, NULL, "stra:AdminGetRegisteredApplications"); + case SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributesResponse: + return soap_in_PointerTo_stra__SetGlobalStorageAttributesResponse(soap, NULL, NULL, "stra:SetGlobalStorageAttributesResponse"); + case SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributes: + return soap_in_PointerTo_stra__SetGlobalStorageAttributes(soap, NULL, NULL, "stra:SetGlobalStorageAttributes"); + case SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributesResponse: + return soap_in_PointerTo_stra__GetGlobalStorageAttributesResponse(soap, NULL, NULL, "stra:GetGlobalStorageAttributesResponse"); + case SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributes: + return soap_in_PointerTo_stra__GetGlobalStorageAttributes(soap, NULL, NULL, "stra:GetGlobalStorageAttributes"); + case SOAP_TYPE_PointerTo_str__ExecuteStorageOperationResponse: + return soap_in_PointerTo_str__ExecuteStorageOperationResponse(soap, NULL, NULL, "str:ExecuteStorageOperationResponse"); + case SOAP_TYPE_PointerTo_str__ExecuteStorageOperation: + return soap_in_PointerTo_str__ExecuteStorageOperation(soap, NULL, NULL, "str:ExecuteStorageOperation"); + case SOAP_TYPE_PointerTo_sai__GetAclEnabledStateResponse: + return soap_in_PointerTo_sai__GetAclEnabledStateResponse(soap, NULL, NULL, "sai:GetAclEnabledStateResponse"); + case SOAP_TYPE_PointerTo_sai__GetAclEnabledState: + return soap_in_PointerTo_sai__GetAclEnabledState(soap, NULL, NULL, "sai:GetAclEnabledState"); + case SOAP_TYPE_PointerTo_sai__SetAclEnabledStateResponse: + return soap_in_PointerTo_sai__SetAclEnabledStateResponse(soap, NULL, NULL, "sai:SetAclEnabledStateResponse"); + case SOAP_TYPE_PointerTo_sai__SetAclEnabledState: + return soap_in_PointerTo_sai__SetAclEnabledState(soap, NULL, NULL, "sai:SetAclEnabledState"); + case SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDNResponse: + return soap_in_PointerTo_sai__SetConfigurationServerFQDNResponse(soap, NULL, NULL, "sai:SetConfigurationServerFQDNResponse"); + case SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDN: + return soap_in_PointerTo_sai__SetConfigurationServerFQDN(soap, NULL, NULL, "sai:SetConfigurationServerFQDN"); + case SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDNResponse: + return soap_in_PointerTo_sai__GetConfigurationServerFQDNResponse(soap, NULL, NULL, "sai:GetConfigurationServerFQDNResponse"); + case SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDN: + return soap_in_PointerTo_sai__GetConfigurationServerFQDN(soap, NULL, NULL, "sai:GetConfigurationServerFQDN"); + case SOAP_TYPE_PointerTo_sai__EnableVpnRoutingResponse: + return soap_in_PointerTo_sai__EnableVpnRoutingResponse(soap, NULL, NULL, "sai:EnableVpnRoutingResponse"); + case SOAP_TYPE_PointerTo_sai__EnableVpnRouting: + return soap_in_PointerTo_sai__EnableVpnRouting(soap, NULL, NULL, "sai:EnableVpnRouting"); + case SOAP_TYPE_PointerTo_sai__GetTLSCredentialsResponse: + return soap_in_PointerTo_sai__GetTLSCredentialsResponse(soap, NULL, NULL, "sai:GetTLSCredentialsResponse"); + case SOAP_TYPE_PointerTo_sai__GetTLSCredentials: + return soap_in_PointerTo_sai__GetTLSCredentials(soap, NULL, NULL, "sai:GetTLSCredentials"); + case SOAP_TYPE_PointerTo_sai__SetTLSCredentialsResponse: + return soap_in_PointerTo_sai__SetTLSCredentialsResponse(soap, NULL, NULL, "sai:SetTLSCredentialsResponse"); + case SOAP_TYPE_PointerTo_sai__SetTLSCredentials: + return soap_in_PointerTo_sai__SetTLSCredentials(soap, NULL, NULL, "sai:SetTLSCredentials"); + case SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificateResponse: + return soap_in_PointerTo_sai__CertStoreUpdateCertificateResponse(soap, NULL, NULL, "sai:CertStoreUpdateCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificate: + return soap_in_PointerTo_sai__CertStoreUpdateCertificate(soap, NULL, NULL, "sai:CertStoreUpdateCertificate"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10RequestResponse: + return soap_in_PointerTo_sai__CertStoreGetPKCS10RequestResponse(soap, NULL, NULL, "sai:CertStoreGetPKCS10RequestResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10Request: + return soap_in_PointerTo_sai__CertStoreGetPKCS10Request(soap, NULL, NULL, "sai:CertStoreGetPKCS10Request"); + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificateResponse: + return soap_in_PointerTo_sai__CertStoreRemoveCertificateResponse(soap, NULL, NULL, "sai:CertStoreRemoveCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificate: + return soap_in_PointerTo_sai__CertStoreRemoveCertificate(soap, NULL, NULL, "sai:CertStoreRemoveCertificate"); + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificatesResponse: + return soap_in_PointerTo_sai__CertStoreEnumerateCertificatesResponse(soap, NULL, NULL, "sai:CertStoreEnumerateCertificatesResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificates: + return soap_in_PointerTo_sai__CertStoreEnumerateCertificates(soap, NULL, NULL, "sai:CertStoreEnumerateCertificates"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetCertificateResponse: + return soap_in_PointerTo_sai__CertStoreGetCertificateResponse(soap, NULL, NULL, "sai:CertStoreGetCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetCertificate: + return soap_in_PointerTo_sai__CertStoreGetCertificate(soap, NULL, NULL, "sai:CertStoreGetCertificate"); + case SOAP_TYPE_PointerTo_sai__CertStoreAddCertificateResponse: + return soap_in_PointerTo_sai__CertStoreAddCertificateResponse(soap, NULL, NULL, "sai:CertStoreAddCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreAddCertificate: + return soap_in_PointerTo_sai__CertStoreAddCertificate(soap, NULL, NULL, "sai:CertStoreAddCertificate"); + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveKeyResponse: + return soap_in_PointerTo_sai__CertStoreRemoveKeyResponse(soap, NULL, NULL, "sai:CertStoreRemoveKeyResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveKey: + return soap_in_PointerTo_sai__CertStoreRemoveKey(soap, NULL, NULL, "sai:CertStoreRemoveKey"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetKeyResponse: + return soap_in_PointerTo_sai__CertStoreGetKeyResponse(soap, NULL, NULL, "sai:CertStoreGetKeyResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetKey: + return soap_in_PointerTo_sai__CertStoreGetKey(soap, NULL, NULL, "sai:CertStoreGetKey"); + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeysResponse: + return soap_in_PointerTo_sai__CertStoreEnumerateKeysResponse(soap, NULL, NULL, "sai:CertStoreEnumerateKeysResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeys: + return soap_in_PointerTo_sai__CertStoreEnumerateKeys(soap, NULL, NULL, "sai:CertStoreEnumerateKeys"); + case SOAP_TYPE_PointerTo_sai__CertStoreAddKeyResponse: + return soap_in_PointerTo_sai__CertStoreAddKeyResponse(soap, NULL, NULL, "sai:CertStoreAddKeyResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreAddKey: + return soap_in_PointerTo_sai__CertStoreAddKey(soap, NULL, NULL, "sai:CertStoreAddKey"); + case SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicyResponse: + return soap_in_PointerTo_sai__GetGlobalPowerPolicyResponse(soap, NULL, NULL, "sai:GetGlobalPowerPolicyResponse"); + case SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicy: + return soap_in_PointerTo_sai__GetGlobalPowerPolicy(soap, NULL, NULL, "sai:GetGlobalPowerPolicy"); + case SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicyResponse: + return soap_in_PointerTo_sai__SetGlobalPowerPolicyResponse(soap, NULL, NULL, "sai:SetGlobalPowerPolicyResponse"); + case SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicy: + return soap_in_PointerTo_sai__SetGlobalPowerPolicy(soap, NULL, NULL, "sai:SetGlobalPowerPolicy"); + case SOAP_TYPE_PointerTo_sai__SetActivePowerPackageResponse: + return soap_in_PointerTo_sai__SetActivePowerPackageResponse(soap, NULL, NULL, "sai:SetActivePowerPackageResponse"); + case SOAP_TYPE_PointerTo_sai__SetActivePowerPackage: + return soap_in_PointerTo_sai__SetActivePowerPackage(soap, NULL, NULL, "sai:SetActivePowerPackage"); + case SOAP_TYPE_PointerTo_sai__GetActivePowerPackageResponse: + return soap_in_PointerTo_sai__GetActivePowerPackageResponse(soap, NULL, NULL, "sai:GetActivePowerPackageResponse"); + case SOAP_TYPE_PointerTo_sai__GetActivePowerPackage: + return soap_in_PointerTo_sai__GetActivePowerPackage(soap, NULL, NULL, "sai:GetActivePowerPackage"); + case SOAP_TYPE_PointerTo_sai__GetPowerPackageResponse: + return soap_in_PointerTo_sai__GetPowerPackageResponse(soap, NULL, NULL, "sai:GetPowerPackageResponse"); + case SOAP_TYPE_PointerTo_sai__GetPowerPackage: + return soap_in_PointerTo_sai__GetPowerPackage(soap, NULL, NULL, "sai:GetPowerPackage"); + case SOAP_TYPE_PointerTo_sai__EnumeratePowerPackagesResponse: + return soap_in_PointerTo_sai__EnumeratePowerPackagesResponse(soap, NULL, NULL, "sai:EnumeratePowerPackagesResponse"); + case SOAP_TYPE_PointerTo_sai__EnumeratePowerPackages: + return soap_in_PointerTo_sai__EnumeratePowerPackages(soap, NULL, NULL, "sai:EnumeratePowerPackages"); + case SOAP_TYPE_PointerTo_sai__GetEnvironmentDetectionResponse: + return soap_in_PointerTo_sai__GetEnvironmentDetectionResponse(soap, NULL, NULL, "sai:GetEnvironmentDetectionResponse"); + case SOAP_TYPE_PointerTo_sai__GetEnvironmentDetection: + return soap_in_PointerTo_sai__GetEnvironmentDetection(soap, NULL, NULL, "sai:GetEnvironmentDetection"); + case SOAP_TYPE_PointerTo_sai__SetEnvironmentDetectionResponse: + return soap_in_PointerTo_sai__SetEnvironmentDetectionResponse(soap, NULL, NULL, "sai:SetEnvironmentDetectionResponse"); + case SOAP_TYPE_PointerTo_sai__SetEnvironmentDetection: + return soap_in_PointerTo_sai__SetEnvironmentDetection(soap, NULL, NULL, "sai:SetEnvironmentDetection"); + case SOAP_TYPE_PointerTo_sai__SetRealmAuthOptionsResponse: + return soap_in_PointerTo_sai__SetRealmAuthOptionsResponse(soap, NULL, NULL, "sai:SetRealmAuthOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__SetRealmAuthOptions: + return soap_in_PointerTo_sai__SetRealmAuthOptions(soap, NULL, NULL, "sai:SetRealmAuthOptions"); + case SOAP_TYPE_PointerTo_sai__GetRealmAuthOptionsResponse: + return soap_in_PointerTo_sai__GetRealmAuthOptionsResponse(soap, NULL, NULL, "sai:GetRealmAuthOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__GetRealmAuthOptions: + return soap_in_PointerTo_sai__GetRealmAuthOptions(soap, NULL, NULL, "sai:GetRealmAuthOptions"); + case SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriodResponse: + return soap_in_PointerTo_sai__ExtendProvisioningPeriodResponse(soap, NULL, NULL, "sai:ExtendProvisioningPeriodResponse"); + case SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriod: + return soap_in_PointerTo_sai__ExtendProvisioningPeriod(soap, NULL, NULL, "sai:ExtendProvisioningPeriod"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningPIDResponse: + return soap_in_PointerTo_sai__GetProvisioningPIDResponse(soap, NULL, NULL, "sai:GetProvisioningPIDResponse"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningPID: + return soap_in_PointerTo_sai__GetProvisioningPID(soap, NULL, NULL, "sai:GetProvisioningPID"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecordResponse: + return soap_in_PointerTo_sai__GetProvisioningAuditRecordResponse(soap, NULL, NULL, "sai:GetProvisioningAuditRecordResponse"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecord: + return soap_in_PointerTo_sai__GetProvisioningAuditRecord(soap, NULL, NULL, "sai:GetProvisioningAuditRecord"); + case SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationModeResponse: + return soap_in_PointerTo_sai__SetZeroTouchConfigurationModeResponse(soap, NULL, NULL, "sai:SetZeroTouchConfigurationModeResponse"); + case SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationMode: + return soap_in_PointerTo_sai__SetZeroTouchConfigurationMode(soap, NULL, NULL, "sai:SetZeroTouchConfigurationMode"); + case SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationModeResponse: + return soap_in_PointerTo_sai__GetZeroTouchConfigurationModeResponse(soap, NULL, NULL, "sai:GetZeroTouchConfigurationModeResponse"); + case SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationMode: + return soap_in_PointerTo_sai__GetZeroTouchConfigurationMode(soap, NULL, NULL, "sai:GetZeroTouchConfigurationMode"); + case SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntryResponse: + return soap_in_PointerTo_sai__EnableCertificateHashEntryResponse(soap, NULL, NULL, "sai:EnableCertificateHashEntryResponse"); + case SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntry: + return soap_in_PointerTo_sai__EnableCertificateHashEntry(soap, NULL, NULL, "sai:EnableCertificateHashEntry"); + case SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntryResponse: + return soap_in_PointerTo_sai__DeleteCertificateHashEntryResponse(soap, NULL, NULL, "sai:DeleteCertificateHashEntryResponse"); + case SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntry: + return soap_in_PointerTo_sai__DeleteCertificateHashEntry(soap, NULL, NULL, "sai:DeleteCertificateHashEntry"); + case SOAP_TYPE_PointerTo_sai__AddCertificateHashEntryResponse: + return soap_in_PointerTo_sai__AddCertificateHashEntryResponse(soap, NULL, NULL, "sai:AddCertificateHashEntryResponse"); + case SOAP_TYPE_PointerTo_sai__AddCertificateHashEntry: + return soap_in_PointerTo_sai__AddCertificateHashEntry(soap, NULL, NULL, "sai:AddCertificateHashEntry"); + case SOAP_TYPE_PointerTo_sai__GetCertificateHashEntryResponse: + return soap_in_PointerTo_sai__GetCertificateHashEntryResponse(soap, NULL, NULL, "sai:GetCertificateHashEntryResponse"); + case SOAP_TYPE_PointerTo_sai__GetCertificateHashEntry: + return soap_in_PointerTo_sai__GetCertificateHashEntry(soap, NULL, NULL, "sai:GetCertificateHashEntry"); + case SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntriesResponse: + return soap_in_PointerTo_sai__EnumerateCertificateHashEntriesResponse(soap, NULL, NULL, "sai:EnumerateCertificateHashEntriesResponse"); + case SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntries: + return soap_in_PointerTo_sai__EnumerateCertificateHashEntries(soap, NULL, NULL, "sai:EnumerateCertificateHashEntries"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTPResponse: + return soap_in_PointerTo_sai__GetProvisioningServerOTPResponse(soap, NULL, NULL, "sai:GetProvisioningServerOTPResponse"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTP: + return soap_in_PointerTo_sai__GetProvisioningServerOTP(soap, NULL, NULL, "sai:GetProvisioningServerOTP"); + case SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTPResponse: + return soap_in_PointerTo_sai__SetProvisioningServerOTPResponse(soap, NULL, NULL, "sai:SetProvisioningServerOTPResponse"); + case SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTP: + return soap_in_PointerTo_sai__SetProvisioningServerOTP(soap, NULL, NULL, "sai:SetProvisioningServerOTP"); + case SOAP_TYPE_PointerTo_sai__SetMEBxPasswordResponse: + return soap_in_PointerTo_sai__SetMEBxPasswordResponse(soap, NULL, NULL, "sai:SetMEBxPasswordResponse"); + case SOAP_TYPE_PointerTo_sai__SetMEBxPassword: + return soap_in_PointerTo_sai__SetMEBxPassword(soap, NULL, NULL, "sai:SetMEBxPassword"); + case SOAP_TYPE_PointerTo_sai__PartialUnprovisionResponse: + return soap_in_PointerTo_sai__PartialUnprovisionResponse(soap, NULL, NULL, "sai:PartialUnprovisionResponse"); + case SOAP_TYPE_PointerTo_sai__PartialUnprovision: + return soap_in_PointerTo_sai__PartialUnprovision(soap, NULL, NULL, "sai:PartialUnprovision"); + case SOAP_TYPE_PointerTo_sai__SetTLSPSKResponse: + return soap_in_PointerTo_sai__SetTLSPSKResponse(soap, NULL, NULL, "sai:SetTLSPSKResponse"); + case SOAP_TYPE_PointerTo_sai__SetTLSPSK: + return soap_in_PointerTo_sai__SetTLSPSK(soap, NULL, NULL, "sai:SetTLSPSK"); + case SOAP_TYPE_PointerTo_sai__GetPowerSavingOptionsResponse: + return soap_in_PointerTo_sai__GetPowerSavingOptionsResponse(soap, NULL, NULL, "sai:GetPowerSavingOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__GetPowerSavingOptions: + return soap_in_PointerTo_sai__GetPowerSavingOptions(soap, NULL, NULL, "sai:GetPowerSavingOptions"); + case SOAP_TYPE_PointerTo_sai__SetPowerSavingOptionsResponse: + return soap_in_PointerTo_sai__SetPowerSavingOptionsResponse(soap, NULL, NULL, "sai:SetPowerSavingOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__SetPowerSavingOptions: + return soap_in_PointerTo_sai__SetPowerSavingOptions(soap, NULL, NULL, "sai:SetPowerSavingOptions"); + case SOAP_TYPE_PointerTo_sai__GetPkiCapabilitiesResponse: + return soap_in_PointerTo_sai__GetPkiCapabilitiesResponse(soap, NULL, NULL, "sai:GetPkiCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_sai__GetPkiCapabilities: + return soap_in_PointerTo_sai__GetPkiCapabilities(soap, NULL, NULL, "sai:GetPkiCapabilities"); + case SOAP_TYPE_PointerTo_sai__GetServerCertificateReqResponse: + return soap_in_PointerTo_sai__GetServerCertificateReqResponse(soap, NULL, NULL, "sai:GetServerCertificateReqResponse"); + case SOAP_TYPE_PointerTo_sai__GetServerCertificateReq: + return soap_in_PointerTo_sai__GetServerCertificateReq(soap, NULL, NULL, "sai:GetServerCertificateReq"); + case SOAP_TYPE_PointerTo_sai__GetCRLResponse: + return soap_in_PointerTo_sai__GetCRLResponse(soap, NULL, NULL, "sai:GetCRLResponse"); + case SOAP_TYPE_PointerTo_sai__GetCRL: + return soap_in_PointerTo_sai__GetCRL(soap, NULL, NULL, "sai:GetCRL"); + case SOAP_TYPE_PointerTo_sai__SetCRLResponse: + return soap_in_PointerTo_sai__SetCRLResponse(soap, NULL, NULL, "sai:SetCRLResponse"); + case SOAP_TYPE_PointerTo_sai__SetCRL: + return soap_in_PointerTo_sai__SetCRL(soap, NULL, NULL, "sai:SetCRL"); + case SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCNResponse: + return soap_in_PointerTo_sai__GetTrustedFqdnCNResponse(soap, NULL, NULL, "sai:GetTrustedFqdnCNResponse"); + case SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCN: + return soap_in_PointerTo_sai__GetTrustedFqdnCN(soap, NULL, NULL, "sai:GetTrustedFqdnCN"); + case SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCNResponse: + return soap_in_PointerTo_sai__SetTrustedFqdnCNResponse(soap, NULL, NULL, "sai:SetTrustedFqdnCNResponse"); + case SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCN: + return soap_in_PointerTo_sai__SetTrustedFqdnCN(soap, NULL, NULL, "sai:SetTrustedFqdnCN"); + case SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificatesResponse: + return soap_in_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(soap, NULL, NULL, "sai:EnumerateTrustedRootCertificatesResponse"); + case SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificates: + return soap_in_PointerTo_sai__EnumerateTrustedRootCertificates(soap, NULL, NULL, "sai:EnumerateTrustedRootCertificates"); + case SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificateResponse: + return soap_in_PointerTo_sai__DeleteTrustedRootCertificateResponse(soap, NULL, NULL, "sai:DeleteTrustedRootCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificate: + return soap_in_PointerTo_sai__DeleteTrustedRootCertificate(soap, NULL, NULL, "sai:DeleteTrustedRootCertificate"); + case SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificateResponse: + return soap_in_PointerTo_sai__GetTrustedRootCertificateResponse(soap, NULL, NULL, "sai:GetTrustedRootCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificate: + return soap_in_PointerTo_sai__GetTrustedRootCertificate(soap, NULL, NULL, "sai:GetTrustedRootCertificate"); + case SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificateResponse: + return soap_in_PointerTo_sai__AddTrustedRootCertificateResponse(soap, NULL, NULL, "sai:AddTrustedRootCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificate: + return soap_in_PointerTo_sai__AddTrustedRootCertificate(soap, NULL, NULL, "sai:AddTrustedRootCertificate"); + case SOAP_TYPE_PointerTo_sai__GetTlsOptionsResponse: + return soap_in_PointerTo_sai__GetTlsOptionsResponse(soap, NULL, NULL, "sai:GetTlsOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__GetTlsOptions: + return soap_in_PointerTo_sai__GetTlsOptions(soap, NULL, NULL, "sai:GetTlsOptions"); + case SOAP_TYPE_PointerTo_sai__SetTlsOptionsResponse: + return soap_in_PointerTo_sai__SetTlsOptionsResponse(soap, NULL, NULL, "sai:SetTlsOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__SetTlsOptions: + return soap_in_PointerTo_sai__SetTlsOptions(soap, NULL, NULL, "sai:SetTlsOptions"); + case SOAP_TYPE_PointerTo_sai__GetEnabledInterfacesResponse: + return soap_in_PointerTo_sai__GetEnabledInterfacesResponse(soap, NULL, NULL, "sai:GetEnabledInterfacesResponse"); + case SOAP_TYPE_PointerTo_sai__GetEnabledInterfaces: + return soap_in_PointerTo_sai__GetEnabledInterfaces(soap, NULL, NULL, "sai:GetEnabledInterfaces"); + case SOAP_TYPE_PointerTo_sai__SetEnabledInterfacesResponse: + return soap_in_PointerTo_sai__SetEnabledInterfacesResponse(soap, NULL, NULL, "sai:SetEnabledInterfacesResponse"); + case SOAP_TYPE_PointerTo_sai__SetEnabledInterfaces: + return soap_in_PointerTo_sai__SetEnabledInterfaces(soap, NULL, NULL, "sai:SetEnabledInterfaces"); + case SOAP_TYPE_PointerTo_sai__GetKerberosOptionsResponse: + return soap_in_PointerTo_sai__GetKerberosOptionsResponse(soap, NULL, NULL, "sai:GetKerberosOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__GetKerberosOptions: + return soap_in_PointerTo_sai__GetKerberosOptions(soap, NULL, NULL, "sai:GetKerberosOptions"); + case SOAP_TYPE_PointerTo_sai__SetKerberosOptionsResponse: + return soap_in_PointerTo_sai__SetKerberosOptionsResponse(soap, NULL, NULL, "sai:SetKerberosOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__SetKerberosOptions: + return soap_in_PointerTo_sai__SetKerberosOptions(soap, NULL, NULL, "sai:SetKerberosOptions"); + case SOAP_TYPE_PointerTo_sai__GetDigestRealmResponse: + return soap_in_PointerTo_sai__GetDigestRealmResponse(soap, NULL, NULL, "sai:GetDigestRealmResponse"); + case SOAP_TYPE_PointerTo_sai__GetDigestRealm: + return soap_in_PointerTo_sai__GetDigestRealm(soap, NULL, NULL, "sai:GetDigestRealm"); + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntryExResponse: + return soap_in_PointerTo_sai__SetAdminAclEntryExResponse(soap, NULL, NULL, "sai:SetAdminAclEntryExResponse"); + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntryEx: + return soap_in_PointerTo_sai__SetAdminAclEntryEx(soap, NULL, NULL, "sai:SetAdminAclEntryEx"); + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryExResponse: + return soap_in_PointerTo_sai__UpdateUserAclEntryExResponse(soap, NULL, NULL, "sai:UpdateUserAclEntryExResponse"); + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryEx: + return soap_in_PointerTo_sai__UpdateUserAclEntryEx(soap, NULL, NULL, "sai:UpdateUserAclEntryEx"); + case SOAP_TYPE_PointerTo_sai__GetUserAclEntryExResponse: + return soap_in_PointerTo_sai__GetUserAclEntryExResponse(soap, NULL, NULL, "sai:GetUserAclEntryExResponse"); + case SOAP_TYPE_PointerTo_sai__GetUserAclEntryEx: + return soap_in_PointerTo_sai__GetUserAclEntryEx(soap, NULL, NULL, "sai:GetUserAclEntryEx"); + case SOAP_TYPE_PointerTo_sai__AddUserAclEntryExResponse: + return soap_in_PointerTo_sai__AddUserAclEntryExResponse(soap, NULL, NULL, "sai:AddUserAclEntryExResponse"); + case SOAP_TYPE_PointerTo_sai__AddUserAclEntryEx: + return soap_in_PointerTo_sai__AddUserAclEntryEx(soap, NULL, NULL, "sai:AddUserAclEntryEx"); + case SOAP_TYPE_PointerTo_sai__GetCoreVersionResponse: + return soap_in_PointerTo_sai__GetCoreVersionResponse(soap, NULL, NULL, "sai:GetCoreVersionResponse"); + case SOAP_TYPE_PointerTo_sai__GetCoreVersion: + return soap_in_PointerTo_sai__GetCoreVersion(soap, NULL, NULL, "sai:GetCoreVersion"); + case SOAP_TYPE_PointerTo_sai__CommitChangesResponse: + return soap_in_PointerTo_sai__CommitChangesResponse(soap, NULL, NULL, "sai:CommitChangesResponse"); + case SOAP_TYPE_PointerTo_sai__CommitChanges: + return soap_in_PointerTo_sai__CommitChanges(soap, NULL, NULL, "sai:CommitChanges"); + case SOAP_TYPE_PointerTo_sai__UnprovisionResponse: + return soap_in_PointerTo_sai__UnprovisionResponse(soap, NULL, NULL, "sai:UnprovisionResponse"); + case SOAP_TYPE_PointerTo_sai__Unprovision: + return soap_in_PointerTo_sai__Unprovision(soap, NULL, NULL, "sai:Unprovision"); + case SOAP_TYPE_PointerTo_sai__SetProvisioningModeResponse: + return soap_in_PointerTo_sai__SetProvisioningModeResponse(soap, NULL, NULL, "sai:SetProvisioningModeResponse"); + case SOAP_TYPE_PointerTo_sai__SetProvisioningMode: + return soap_in_PointerTo_sai__SetProvisioningMode(soap, NULL, NULL, "sai:SetProvisioningMode"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningModeResponse: + return soap_in_PointerTo_sai__GetProvisioningModeResponse(soap, NULL, NULL, "sai:GetProvisioningModeResponse"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningMode: + return soap_in_PointerTo_sai__GetProvisioningMode(soap, NULL, NULL, "sai:GetProvisioningMode"); + case SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrlResponse: + return soap_in_PointerTo_sai__UpdateCoreFromUrlResponse(soap, NULL, NULL, "sai:UpdateCoreFromUrlResponse"); + case SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrl: + return soap_in_PointerTo_sai__UpdateCoreFromUrl(soap, NULL, NULL, "sai:UpdateCoreFromUrl"); + case SOAP_TYPE_PointerTo_sai__GetTLSCertificateResponse: + return soap_in_PointerTo_sai__GetTLSCertificateResponse(soap, NULL, NULL, "sai:GetTLSCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__GetTLSCertificate: + return soap_in_PointerTo_sai__GetTLSCertificate(soap, NULL, NULL, "sai:GetTLSCertificate"); + case SOAP_TYPE_PointerTo_sai__SetTLSCertificateResponse: + return soap_in_PointerTo_sai__SetTLSCertificateResponse(soap, NULL, NULL, "sai:SetTLSCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__SetTLSCertificate: + return soap_in_PointerTo_sai__SetTLSCertificate(soap, NULL, NULL, "sai:SetTLSCertificate"); + case SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificateResponse: + return soap_in_PointerTo_sai__SetTLSKeyAndCertificateResponse(soap, NULL, NULL, "sai:SetTLSKeyAndCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificate: + return soap_in_PointerTo_sai__SetTLSKeyAndCertificate(soap, NULL, NULL, "sai:SetTLSKeyAndCertificate"); + case SOAP_TYPE_PointerTo_sai__SetRngKeyResponse: + return soap_in_PointerTo_sai__SetRngKeyResponse(soap, NULL, NULL, "sai:SetRngKeyResponse"); + case SOAP_TYPE_PointerTo_sai__SetRngKey: + return soap_in_PointerTo_sai__SetRngKey(soap, NULL, NULL, "sai:SetRngKey"); + case SOAP_TYPE_PointerTo_sai__SetTlsEnabledResponse: + return soap_in_PointerTo_sai__SetTlsEnabledResponse(soap, NULL, NULL, "sai:SetTlsEnabledResponse"); + case SOAP_TYPE_PointerTo_sai__SetTlsEnabled: + return soap_in_PointerTo_sai__SetTlsEnabled(soap, NULL, NULL, "sai:SetTlsEnabled"); + case SOAP_TYPE_PointerTo_sai__RemoveUserAclEntryResponse: + return soap_in_PointerTo_sai__RemoveUserAclEntryResponse(soap, NULL, NULL, "sai:RemoveUserAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__RemoveUserAclEntry: + return soap_in_PointerTo_sai__RemoveUserAclEntry(soap, NULL, NULL, "sai:RemoveUserAclEntry"); + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryResponse: + return soap_in_PointerTo_sai__UpdateUserAclEntryResponse(soap, NULL, NULL, "sai:UpdateUserAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntry: + return soap_in_PointerTo_sai__UpdateUserAclEntry(soap, NULL, NULL, "sai:UpdateUserAclEntry"); + case SOAP_TYPE_PointerTo_sai__GetUserAclEntryResponse: + return soap_in_PointerTo_sai__GetUserAclEntryResponse(soap, NULL, NULL, "sai:GetUserAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__GetUserAclEntry: + return soap_in_PointerTo_sai__GetUserAclEntry(soap, NULL, NULL, "sai:GetUserAclEntry"); + case SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntriesResponse: + return soap_in_PointerTo_sai__EnumerateUserAclEntriesResponse(soap, NULL, NULL, "sai:EnumerateUserAclEntriesResponse"); + case SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntries: + return soap_in_PointerTo_sai__EnumerateUserAclEntries(soap, NULL, NULL, "sai:EnumerateUserAclEntries"); + case SOAP_TYPE_PointerTo_sai__AddUserAclEntryResponse: + return soap_in_PointerTo_sai__AddUserAclEntryResponse(soap, NULL, NULL, "sai:AddUserAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__AddUserAclEntry: + return soap_in_PointerTo_sai__AddUserAclEntry(soap, NULL, NULL, "sai:AddUserAclEntry"); + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntryResponse: + return soap_in_PointerTo_sai__SetAdminAclEntryResponse(soap, NULL, NULL, "sai:SetAdminAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntry: + return soap_in_PointerTo_sai__SetAdminAclEntry(soap, NULL, NULL, "sai:SetAdminAclEntry"); + case SOAP_TYPE_PointerTo_sai__GetAdminAclEntryResponse: + return soap_in_PointerTo_sai__GetAdminAclEntryResponse(soap, NULL, NULL, "sai:GetAdminAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__GetAdminAclEntry: + return soap_in_PointerTo_sai__GetAdminAclEntry(soap, NULL, NULL, "sai:GetAdminAclEntry"); + case SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtectionResponse: + return soap_in_PointerTo_sai__ResetFlashWearOutProtectionResponse(soap, NULL, NULL, "sai:ResetFlashWearOutProtectionResponse"); + case SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtection: + return soap_in_PointerTo_sai__ResetFlashWearOutProtection(soap, NULL, NULL, "sai:ResetFlashWearOutProtection"); + case SOAP_TYPE_PointerTo_rci__GetSystemPowerStateResponse: + return soap_in_PointerTo_rci__GetSystemPowerStateResponse(soap, NULL, NULL, "rci:GetSystemPowerStateResponse"); + case SOAP_TYPE_PointerTo_rci__GetSystemPowerState: + return soap_in_PointerTo_rci__GetSystemPowerState(soap, NULL, NULL, "rci:GetSystemPowerState"); + case SOAP_TYPE_PointerTo_rci__RemoteControlResponse: + return soap_in_PointerTo_rci__RemoteControlResponse(soap, NULL, NULL, "rci:RemoteControlResponse"); + case SOAP_TYPE_PointerTo_rci__RemoteControl: + return soap_in_PointerTo_rci__RemoteControl(soap, NULL, NULL, "rci:RemoteControl"); + case SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilitiesResponse: + return soap_in_PointerTo_rci__GetRemoteControlCapabilitiesResponse(soap, NULL, NULL, "rci:GetRemoteControlCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilities: + return soap_in_PointerTo_rci__GetRemoteControlCapabilities(soap, NULL, NULL, "rci:GetRemoteControlCapabilities"); + case SOAP_TYPE_PointerTo_net__Get8021XPxeTimeoutResponse: + return soap_in_PointerTo_net__Get8021XPxeTimeoutResponse(soap, NULL, NULL, "net:Get8021XPxeTimeoutResponse"); + case SOAP_TYPE_PointerTo_net__Get8021XPxeTimeout: + return soap_in_PointerTo_net__Get8021XPxeTimeout(soap, NULL, NULL, "net:Get8021XPxeTimeout"); + case SOAP_TYPE_PointerTo_net__Set8021XPxeTimeoutResponse: + return soap_in_PointerTo_net__Set8021XPxeTimeoutResponse(soap, NULL, NULL, "net:Set8021XPxeTimeoutResponse"); + case SOAP_TYPE_PointerTo_net__Set8021XPxeTimeout: + return soap_in_PointerTo_net__Set8021XPxeTimeout(soap, NULL, NULL, "net:Set8021XPxeTimeout"); + case SOAP_TYPE_PointerTo_net__Get8021XActiveS0Response: + return soap_in_PointerTo_net__Get8021XActiveS0Response(soap, NULL, NULL, "net:Get8021XActiveS0Response"); + case SOAP_TYPE_PointerTo_net__Get8021XActiveS0: + return soap_in_PointerTo_net__Get8021XActiveS0(soap, NULL, NULL, "net:Get8021XActiveS0"); + case SOAP_TYPE_PointerTo_net__Set8021XActiveS0Response: + return soap_in_PointerTo_net__Set8021XActiveS0Response(soap, NULL, NULL, "net:Set8021XActiveS0Response"); + case SOAP_TYPE_PointerTo_net__Set8021XActiveS0: + return soap_in_PointerTo_net__Set8021XActiveS0(soap, NULL, NULL, "net:Set8021XActiveS0"); + case SOAP_TYPE_PointerTo_net__Get8021XWiredProfileResponse: + return soap_in_PointerTo_net__Get8021XWiredProfileResponse(soap, NULL, NULL, "net:Get8021XWiredProfileResponse"); + case SOAP_TYPE_PointerTo_net__Get8021XWiredProfile: + return soap_in_PointerTo_net__Get8021XWiredProfile(soap, NULL, NULL, "net:Get8021XWiredProfile"); + case SOAP_TYPE_PointerTo_net__Set8021XWiredProfileResponse: + return soap_in_PointerTo_net__Set8021XWiredProfileResponse(soap, NULL, NULL, "net:Set8021XWiredProfileResponse"); + case SOAP_TYPE_PointerTo_net__Set8021XWiredProfile: + return soap_in_PointerTo_net__Set8021XWiredProfile(soap, NULL, NULL, "net:Set8021XWiredProfile"); + case SOAP_TYPE_PointerTo_net__SetInterfaceSettingsResponse: + return soap_in_PointerTo_net__SetInterfaceSettingsResponse(soap, NULL, NULL, "net:SetInterfaceSettingsResponse"); + case SOAP_TYPE_PointerTo_net__SetInterfaceSettings: + return soap_in_PointerTo_net__SetInterfaceSettings(soap, NULL, NULL, "net:SetInterfaceSettings"); + case SOAP_TYPE_PointerTo_net__GetInterfaceSettingsResponse: + return soap_in_PointerTo_net__GetInterfaceSettingsResponse(soap, NULL, NULL, "net:GetInterfaceSettingsResponse"); + case SOAP_TYPE_PointerTo_net__GetInterfaceSettings: + return soap_in_PointerTo_net__GetInterfaceSettings(soap, NULL, NULL, "net:GetInterfaceSettings"); + case SOAP_TYPE_PointerTo_net__EnumerateInterfacesResponse: + return soap_in_PointerTo_net__EnumerateInterfacesResponse(soap, NULL, NULL, "net:EnumerateInterfacesResponse"); + case SOAP_TYPE_PointerTo_net__EnumerateInterfaces: + return soap_in_PointerTo_net__EnumerateInterfaces(soap, NULL, NULL, "net:EnumerateInterfaces"); + case SOAP_TYPE_PointerTo_net__GetPingResponseResponse: + return soap_in_PointerTo_net__GetPingResponseResponse(soap, NULL, NULL, "net:GetPingResponseResponse"); + case SOAP_TYPE_PointerTo_net__GetPingResponse: + return soap_in_PointerTo_net__GetPingResponse(soap, NULL, NULL, "net:GetPingResponse"); + case SOAP_TYPE_PointerTo_net__SetPingResponseResponse: + return soap_in_PointerTo_net__SetPingResponseResponse(soap, NULL, NULL, "net:SetPingResponseResponse"); + case SOAP_TYPE_PointerTo_net__SetPingResponse: + return soap_in_PointerTo_net__SetPingResponse(soap, NULL, NULL, "net:SetPingResponse"); + case SOAP_TYPE_PointerTo_net__GetVlanParametersResponse: + return soap_in_PointerTo_net__GetVlanParametersResponse(soap, NULL, NULL, "net:GetVlanParametersResponse"); + case SOAP_TYPE_PointerTo_net__GetVlanParameters: + return soap_in_PointerTo_net__GetVlanParameters(soap, NULL, NULL, "net:GetVlanParameters"); + case SOAP_TYPE_PointerTo_net__SetVlanParametersResponse: + return soap_in_PointerTo_net__SetVlanParametersResponse(soap, NULL, NULL, "net:SetVlanParametersResponse"); + case SOAP_TYPE_PointerTo_net__SetVlanParameters: + return soap_in_PointerTo_net__SetVlanParameters(soap, NULL, NULL, "net:SetVlanParameters"); + case SOAP_TYPE_PointerTo_net__GetTcpIpParametersResponse: + return soap_in_PointerTo_net__GetTcpIpParametersResponse(soap, NULL, NULL, "net:GetTcpIpParametersResponse"); + case SOAP_TYPE_PointerTo_net__GetTcpIpParameters: + return soap_in_PointerTo_net__GetTcpIpParameters(soap, NULL, NULL, "net:GetTcpIpParameters"); + case SOAP_TYPE_PointerTo_net__SetTcpIpParametersResponse: + return soap_in_PointerTo_net__SetTcpIpParametersResponse(soap, NULL, NULL, "net:SetTcpIpParametersResponse"); + case SOAP_TYPE_PointerTo_net__SetTcpIpParameters: + return soap_in_PointerTo_net__SetTcpIpParameters(soap, NULL, NULL, "net:SetTcpIpParameters"); + case SOAP_TYPE_PointerTo_net__GetDomainNameResponse: + return soap_in_PointerTo_net__GetDomainNameResponse(soap, NULL, NULL, "net:GetDomainNameResponse"); + case SOAP_TYPE_PointerTo_net__GetDomainName: + return soap_in_PointerTo_net__GetDomainName(soap, NULL, NULL, "net:GetDomainName"); + case SOAP_TYPE_PointerTo_net__SetDomainNameResponse: + return soap_in_PointerTo_net__SetDomainNameResponse(soap, NULL, NULL, "net:SetDomainNameResponse"); + case SOAP_TYPE_PointerTo_net__SetDomainName: + return soap_in_PointerTo_net__SetDomainName(soap, NULL, NULL, "net:SetDomainName"); + case SOAP_TYPE_PointerTo_net__GetHostNameResponse: + return soap_in_PointerTo_net__GetHostNameResponse(soap, NULL, NULL, "net:GetHostNameResponse"); + case SOAP_TYPE_PointerTo_net__GetHostName: + return soap_in_PointerTo_net__GetHostName(soap, NULL, NULL, "net:GetHostName"); + case SOAP_TYPE_PointerTo_net__SetHostNameResponse: + return soap_in_PointerTo_net__SetHostNameResponse(soap, NULL, NULL, "net:SetHostNameResponse"); + case SOAP_TYPE_PointerTo_net__SetHostName: + return soap_in_PointerTo_net__SetHostName(soap, NULL, NULL, "net:SetHostName"); + case SOAP_TYPE_PointerTo_inf__GetIderSessionLogResponse: + return soap_in_PointerTo_inf__GetIderSessionLogResponse(soap, NULL, NULL, "inf:GetIderSessionLogResponse"); + case SOAP_TYPE_PointerTo_inf__GetIderSessionLog: + return soap_in_PointerTo_inf__GetIderSessionLog(soap, NULL, NULL, "inf:GetIderSessionLog"); + case SOAP_TYPE_PointerTo_inf__GetSecurityParametersResponse: + return soap_in_PointerTo_inf__GetSecurityParametersResponse(soap, NULL, NULL, "inf:GetSecurityParametersResponse"); + case SOAP_TYPE_PointerTo_inf__GetSecurityParameters: + return soap_in_PointerTo_inf__GetSecurityParameters(soap, NULL, NULL, "inf:GetSecurityParameters"); + case SOAP_TYPE_PointerTo_inf__GetNetworkStateResponse: + return soap_in_PointerTo_inf__GetNetworkStateResponse(soap, NULL, NULL, "inf:GetNetworkStateResponse"); + case SOAP_TYPE_PointerTo_inf__GetNetworkState: + return soap_in_PointerTo_inf__GetNetworkState(soap, NULL, NULL, "inf:GetNetworkState"); + case SOAP_TYPE_PointerTo_inf__GetEnabledInterfacesResponse: + return soap_in_PointerTo_inf__GetEnabledInterfacesResponse(soap, NULL, NULL, "inf:GetEnabledInterfacesResponse"); + case SOAP_TYPE_PointerTo_inf__GetEnabledInterfaces: + return soap_in_PointerTo_inf__GetEnabledInterfaces(soap, NULL, NULL, "inf:GetEnabledInterfaces"); + case SOAP_TYPE_PointerTo_inf__GetPasswordModelResponse: + return soap_in_PointerTo_inf__GetPasswordModelResponse(soap, NULL, NULL, "inf:GetPasswordModelResponse"); + case SOAP_TYPE_PointerTo_inf__GetPasswordModel: + return soap_in_PointerTo_inf__GetPasswordModel(soap, NULL, NULL, "inf:GetPasswordModel"); + case SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatusResponse: + return soap_in_PointerTo_inf__GetAdminNetAclEntryStatusResponse(soap, NULL, NULL, "inf:GetAdminNetAclEntryStatusResponse"); + case SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatus: + return soap_in_PointerTo_inf__GetAdminNetAclEntryStatus(soap, NULL, NULL, "inf:GetAdminNetAclEntryStatus"); + case SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatusResponse: + return soap_in_PointerTo_inf__GetAdminAclEntryStatusResponse(soap, NULL, NULL, "inf:GetAdminAclEntryStatusResponse"); + case SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatus: + return soap_in_PointerTo_inf__GetAdminAclEntryStatus(soap, NULL, NULL, "inf:GetAdminAclEntryStatus"); + case SOAP_TYPE_PointerTo_inf__GetConfigServerInfoResponse: + return soap_in_PointerTo_inf__GetConfigServerInfoResponse(soap, NULL, NULL, "inf:GetConfigServerInfoResponse"); + case SOAP_TYPE_PointerTo_inf__GetConfigServerInfo: + return soap_in_PointerTo_inf__GetConfigServerInfo(soap, NULL, NULL, "inf:GetConfigServerInfo"); + case SOAP_TYPE_PointerTo_inf__GetHostNameResponse: + return soap_in_PointerTo_inf__GetHostNameResponse(soap, NULL, NULL, "inf:GetHostNameResponse"); + case SOAP_TYPE_PointerTo_inf__GetHostName: + return soap_in_PointerTo_inf__GetHostName(soap, NULL, NULL, "inf:GetHostName"); + case SOAP_TYPE_PointerTo_inf__GetVlanParametersResponse: + return soap_in_PointerTo_inf__GetVlanParametersResponse(soap, NULL, NULL, "inf:GetVlanParametersResponse"); + case SOAP_TYPE_PointerTo_inf__GetVlanParameters: + return soap_in_PointerTo_inf__GetVlanParameters(soap, NULL, NULL, "inf:GetVlanParameters"); + case SOAP_TYPE_PointerTo_inf__GetProvisioningStateResponse: + return soap_in_PointerTo_inf__GetProvisioningStateResponse(soap, NULL, NULL, "inf:GetProvisioningStateResponse"); + case SOAP_TYPE_PointerTo_inf__GetProvisioningState: + return soap_in_PointerTo_inf__GetProvisioningState(soap, NULL, NULL, "inf:GetProvisioningState"); + case SOAP_TYPE_PointerTo_inf__GetProvisioningModeResponse: + return soap_in_PointerTo_inf__GetProvisioningModeResponse(soap, NULL, NULL, "inf:GetProvisioningModeResponse"); + case SOAP_TYPE_PointerTo_inf__GetProvisioningMode: + return soap_in_PointerTo_inf__GetProvisioningMode(soap, NULL, NULL, "inf:GetProvisioningMode"); + case SOAP_TYPE_PointerTo_inf__GetCodeVersionsResponse: + return soap_in_PointerTo_inf__GetCodeVersionsResponse(soap, NULL, NULL, "inf:GetCodeVersionsResponse"); + case SOAP_TYPE_PointerTo_inf__GetCodeVersions: + return soap_in_PointerTo_inf__GetCodeVersions(soap, NULL, NULL, "inf:GetCodeVersions"); + case SOAP_TYPE_PointerTo_inf__GetCoreVersionResponse: + return soap_in_PointerTo_inf__GetCoreVersionResponse(soap, NULL, NULL, "inf:GetCoreVersionResponse"); + case SOAP_TYPE_PointerTo_inf__GetCoreVersion: + return soap_in_PointerTo_inf__GetCoreVersion(soap, NULL, NULL, "inf:GetCoreVersion"); + case SOAP_TYPE_PointerTo_idr__GetIderSessionLogResponse: + return soap_in_PointerTo_idr__GetIderSessionLogResponse(soap, NULL, NULL, "idr:GetIderSessionLogResponse"); + case SOAP_TYPE_PointerTo_idr__GetIderSessionLog: + return soap_in_PointerTo_idr__GetIderSessionLog(soap, NULL, NULL, "idr:GetIderSessionLog"); + case SOAP_TYPE_PointerTo_idr__GetRedirectionListenerStateResponse: + return soap_in_PointerTo_idr__GetRedirectionListenerStateResponse(soap, NULL, NULL, "idr:GetRedirectionListenerStateResponse"); + case SOAP_TYPE_PointerTo_idr__GetRedirectionListenerState: + return soap_in_PointerTo_idr__GetRedirectionListenerState(soap, NULL, NULL, "idr:GetRedirectionListenerState"); + case SOAP_TYPE_PointerTo_idr__SetRedirectionListenerStateResponse: + return soap_in_PointerTo_idr__SetRedirectionListenerStateResponse(soap, NULL, NULL, "idr:SetRedirectionListenerStateResponse"); + case SOAP_TYPE_PointerTo_idr__SetRedirectionListenerState: + return soap_in_PointerTo_idr__SetRedirectionListenerState(soap, NULL, NULL, "idr:SetRedirectionListenerState"); + case SOAP_TYPE_PointerTo_hwa__GetAssetDataResponse: + return soap_in_PointerTo_hwa__GetAssetDataResponse(soap, NULL, NULL, "hwa:GetAssetDataResponse"); + case SOAP_TYPE_PointerTo_hwa__GetAssetData: + return soap_in_PointerTo_hwa__GetAssetData(soap, NULL, NULL, "hwa:GetAssetData"); + case SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypesResponse: + return soap_in_PointerTo_hwa__EnumerateAssetTypesResponse(soap, NULL, NULL, "hwa:EnumerateAssetTypesResponse"); + case SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypes: + return soap_in_PointerTo_hwa__EnumerateAssetTypes(soap, NULL, NULL, "hwa:EnumerateAssetTypes"); + case SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscriptionResponse: + return soap_in_PointerTo_emi__GetGeneralAlertSubscriptionResponse(soap, NULL, NULL, "emi:GetGeneralAlertSubscriptionResponse"); + case SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscription: + return soap_in_PointerTo_emi__GetGeneralAlertSubscription(soap, NULL, NULL, "emi:GetGeneralAlertSubscription"); + case SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse: + return soap_in_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(soap, NULL, NULL, "emi:EnumerateGeneralAlertSubscriptionsResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptions: + return soap_in_PointerTo_emi__EnumerateGeneralAlertSubscriptions(soap, NULL, NULL, "emi:EnumerateGeneralAlertSubscriptions"); + case SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlertResponse: + return soap_in_PointerTo_emi__SubscribeForGeneralAlertResponse(soap, NULL, NULL, "emi:SubscribeForGeneralAlertResponse"); + case SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlert: + return soap_in_PointerTo_emi__SubscribeForGeneralAlert(soap, NULL, NULL, "emi:SubscribeForGeneralAlert"); + case SOAP_TYPE_PointerTo_emi__GetSensorAttributesResponse: + return soap_in_PointerTo_emi__GetSensorAttributesResponse(soap, NULL, NULL, "emi:GetSensorAttributesResponse"); + case SOAP_TYPE_PointerTo_emi__GetSensorAttributes: + return soap_in_PointerTo_emi__GetSensorAttributes(soap, NULL, NULL, "emi:GetSensorAttributes"); + case SOAP_TYPE_PointerTo_emi__EnumerateSensorsResponse: + return soap_in_PointerTo_emi__EnumerateSensorsResponse(soap, NULL, NULL, "emi:EnumerateSensorsResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateSensors: + return soap_in_PointerTo_emi__EnumerateSensors(soap, NULL, NULL, "emi:EnumerateSensors"); + case SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClockResponse: + return soap_in_PointerTo_emi__GetEventLogTimestampClockResponse(soap, NULL, NULL, "emi:GetEventLogTimestampClockResponse"); + case SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClock: + return soap_in_PointerTo_emi__GetEventLogTimestampClock(soap, NULL, NULL, "emi:GetEventLogTimestampClock"); + case SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClockResponse: + return soap_in_PointerTo_emi__SetEventLogTimestampClockResponse(soap, NULL, NULL, "emi:SetEventLogTimestampClockResponse"); + case SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClock: + return soap_in_PointerTo_emi__SetEventLogTimestampClock(soap, NULL, NULL, "emi:SetEventLogTimestampClock"); + case SOAP_TYPE_PointerTo_emi__FreezeEventLogResponse: + return soap_in_PointerTo_emi__FreezeEventLogResponse(soap, NULL, NULL, "emi:FreezeEventLogResponse"); + case SOAP_TYPE_PointerTo_emi__FreezeEventLog: + return soap_in_PointerTo_emi__FreezeEventLog(soap, NULL, NULL, "emi:FreezeEventLog"); + case SOAP_TYPE_PointerTo_emi__ClearEventLogResponse: + return soap_in_PointerTo_emi__ClearEventLogResponse(soap, NULL, NULL, "emi:ClearEventLogResponse"); + case SOAP_TYPE_PointerTo_emi__ClearEventLog: + return soap_in_PointerTo_emi__ClearEventLog(soap, NULL, NULL, "emi:ClearEventLog"); + case SOAP_TYPE_PointerTo_emi__ReadEventLogRecordsResponse: + return soap_in_PointerTo_emi__ReadEventLogRecordsResponse(soap, NULL, NULL, "emi:ReadEventLogRecordsResponse"); + case SOAP_TYPE_PointerTo_emi__ReadEventLogRecords: + return soap_in_PointerTo_emi__ReadEventLogRecords(soap, NULL, NULL, "emi:ReadEventLogRecords"); + case SOAP_TYPE_PointerTo_emi__GetEventLogStatusResponse: + return soap_in_PointerTo_emi__GetEventLogStatusResponse(soap, NULL, NULL, "emi:GetEventLogStatusResponse"); + case SOAP_TYPE_PointerTo_emi__GetEventLogStatus: + return soap_in_PointerTo_emi__GetEventLogStatus(soap, NULL, NULL, "emi:GetEventLogStatus"); + case SOAP_TYPE_PointerTo_emi__RemoveEventFilterResponse: + return soap_in_PointerTo_emi__RemoveEventFilterResponse(soap, NULL, NULL, "emi:RemoveEventFilterResponse"); + case SOAP_TYPE_PointerTo_emi__RemoveEventFilter: + return soap_in_PointerTo_emi__RemoveEventFilter(soap, NULL, NULL, "emi:RemoveEventFilter"); + case SOAP_TYPE_PointerTo_emi__UpdateEventFilterResponse: + return soap_in_PointerTo_emi__UpdateEventFilterResponse(soap, NULL, NULL, "emi:UpdateEventFilterResponse"); + case SOAP_TYPE_PointerTo_emi__UpdateEventFilter: + return soap_in_PointerTo_emi__UpdateEventFilter(soap, NULL, NULL, "emi:UpdateEventFilter"); + case SOAP_TYPE_PointerTo_emi__GetEventFilterResponse: + return soap_in_PointerTo_emi__GetEventFilterResponse(soap, NULL, NULL, "emi:GetEventFilterResponse"); + case SOAP_TYPE_PointerTo_emi__GetEventFilter: + return soap_in_PointerTo_emi__GetEventFilter(soap, NULL, NULL, "emi:GetEventFilter"); + case SOAP_TYPE_PointerTo_emi__CancelAlertSubscriptionResponse: + return soap_in_PointerTo_emi__CancelAlertSubscriptionResponse(soap, NULL, NULL, "emi:CancelAlertSubscriptionResponse"); + case SOAP_TYPE_PointerTo_emi__CancelAlertSubscription: + return soap_in_PointerTo_emi__CancelAlertSubscription(soap, NULL, NULL, "emi:CancelAlertSubscription"); + case SOAP_TYPE_PointerTo_emi__EnumerateAlertPoliciesResponse: + return soap_in_PointerTo_emi__EnumerateAlertPoliciesResponse(soap, NULL, NULL, "emi:EnumerateAlertPoliciesResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateAlertPolicies: + return soap_in_PointerTo_emi__EnumerateAlertPolicies(soap, NULL, NULL, "emi:EnumerateAlertPolicies"); + case SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptionsResponse: + return soap_in_PointerTo_emi__EnumerateAlertSubscriptionsResponse(soap, NULL, NULL, "emi:EnumerateAlertSubscriptionsResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptions: + return soap_in_PointerTo_emi__EnumerateAlertSubscriptions(soap, NULL, NULL, "emi:EnumerateAlertSubscriptions"); + case SOAP_TYPE_PointerTo_emi__SubscribeForAlertResponse: + return soap_in_PointerTo_emi__SubscribeForAlertResponse(soap, NULL, NULL, "emi:SubscribeForAlertResponse"); + case SOAP_TYPE_PointerTo_emi__SubscribeForAlert: + return soap_in_PointerTo_emi__SubscribeForAlert(soap, NULL, NULL, "emi:SubscribeForAlert"); + case SOAP_TYPE_PointerTo_emi__AddEventFilterResponse: + return soap_in_PointerTo_emi__AddEventFilterResponse(soap, NULL, NULL, "emi:AddEventFilterResponse"); + case SOAP_TYPE_PointerTo_emi__AddEventFilter: + return soap_in_PointerTo_emi__AddEventFilter(soap, NULL, NULL, "emi:AddEventFilter"); + case SOAP_TYPE_PointerTo_emi__GetAlertCommunityStringResponse: + return soap_in_PointerTo_emi__GetAlertCommunityStringResponse(soap, NULL, NULL, "emi:GetAlertCommunityStringResponse"); + case SOAP_TYPE_PointerTo_emi__GetAlertCommunityString: + return soap_in_PointerTo_emi__GetAlertCommunityString(soap, NULL, NULL, "emi:GetAlertCommunityString"); + case SOAP_TYPE_PointerTo_emi__SetAlertCommunityStringResponse: + return soap_in_PointerTo_emi__SetAlertCommunityStringResponse(soap, NULL, NULL, "emi:SetAlertCommunityStringResponse"); + case SOAP_TYPE_PointerTo_emi__SetAlertCommunityString: + return soap_in_PointerTo_emi__SetAlertCommunityString(soap, NULL, NULL, "emi:SetAlertCommunityString"); + case SOAP_TYPE_PointerTo_emi__GetAlertSubscriptionResponse: + return soap_in_PointerTo_emi__GetAlertSubscriptionResponse(soap, NULL, NULL, "emi:GetAlertSubscriptionResponse"); + case SOAP_TYPE_PointerTo_emi__GetAlertSubscription: + return soap_in_PointerTo_emi__GetAlertSubscription(soap, NULL, NULL, "emi:GetAlertSubscription"); + case SOAP_TYPE_PointerTo_emi__EnumerateEventFiltersResponse: + return soap_in_PointerTo_emi__EnumerateEventFiltersResponse(soap, NULL, NULL, "emi:EnumerateEventFiltersResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateEventFilters: + return soap_in_PointerTo_emi__EnumerateEventFilters(soap, NULL, NULL, "emi:EnumerateEventFilters"); + case SOAP_TYPE_PointerTo_cb__GetHcbStateResponse: + return soap_in_PointerTo_cb__GetHcbStateResponse(soap, NULL, NULL, "cb:GetHcbStateResponse"); + case SOAP_TYPE_PointerTo_cb__GetHcbState: + return soap_in_PointerTo_cb__GetHcbState(soap, NULL, NULL, "cb:GetHcbState"); + case SOAP_TYPE_PointerTo_cb__ClearHcbStateResponse: + return soap_in_PointerTo_cb__ClearHcbStateResponse(soap, NULL, NULL, "cb:ClearHcbStateResponse"); + case SOAP_TYPE_PointerTo_cb__ClearHcbState: + return soap_in_PointerTo_cb__ClearHcbState(soap, NULL, NULL, "cb:ClearHcbState"); + case SOAP_TYPE_PointerTo_cb__GetHcbOptionsResponse: + return soap_in_PointerTo_cb__GetHcbOptionsResponse(soap, NULL, NULL, "cb:GetHcbOptionsResponse"); + case SOAP_TYPE_PointerTo_cb__GetHcbOptions: + return soap_in_PointerTo_cb__GetHcbOptions(soap, NULL, NULL, "cb:GetHcbOptions"); + case SOAP_TYPE_PointerTo_cb__SetHcbOptionsResponse: + return soap_in_PointerTo_cb__SetHcbOptionsResponse(soap, NULL, NULL, "cb:SetHcbOptionsResponse"); + case SOAP_TYPE_PointerTo_cb__SetHcbOptions: + return soap_in_PointerTo_cb__SetHcbOptions(soap, NULL, NULL, "cb:SetHcbOptions"); + case SOAP_TYPE_PointerTo_cb__CbQueryCapabilitiesResponse: + return soap_in_PointerTo_cb__CbQueryCapabilitiesResponse(soap, NULL, NULL, "cb:CbQueryCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_cb__CbQueryCapabilities: + return soap_in_PointerTo_cb__CbQueryCapabilities(soap, NULL, NULL, "cb:CbQueryCapabilities"); + case SOAP_TYPE_PointerTo_cb__CbFilterEnumerateResponse: + return soap_in_PointerTo_cb__CbFilterEnumerateResponse(soap, NULL, NULL, "cb:CbFilterEnumerateResponse"); + case SOAP_TYPE_PointerTo_cb__CbFilterEnumerate: + return soap_in_PointerTo_cb__CbFilterEnumerate(soap, NULL, NULL, "cb:CbFilterEnumerate"); + case SOAP_TYPE_PointerTo_cb__CbFilterDeleteResponse: + return soap_in_PointerTo_cb__CbFilterDeleteResponse(soap, NULL, NULL, "cb:CbFilterDeleteResponse"); + case SOAP_TYPE_PointerTo_cb__CbFilterDelete: + return soap_in_PointerTo_cb__CbFilterDelete(soap, NULL, NULL, "cb:CbFilterDelete"); + case SOAP_TYPE_PointerTo_cb__CbFilterGetResponse: + return soap_in_PointerTo_cb__CbFilterGetResponse(soap, NULL, NULL, "cb:CbFilterGetResponse"); + case SOAP_TYPE_PointerTo_cb__CbFilterGet: + return soap_in_PointerTo_cb__CbFilterGet(soap, NULL, NULL, "cb:CbFilterGet"); + case SOAP_TYPE_PointerTo_cb__CbFilterCreateResponse: + return soap_in_PointerTo_cb__CbFilterCreateResponse(soap, NULL, NULL, "cb:CbFilterCreateResponse"); + case SOAP_TYPE_PointerTo_cb__CbFilterCreate: + return soap_in_PointerTo_cb__CbFilterCreate(soap, NULL, NULL, "cb:CbFilterCreate"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatisticsResponse: + return soap_in_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(soap, NULL, NULL, "cb:CbPolicyGetActiveStatisticsResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatistics: + return soap_in_PointerTo_cb__CbPolicyGetActiveStatistics(soap, NULL, NULL, "cb:CbPolicyGetActiveStatistics"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabledResponse: + return soap_in_PointerTo_cb__CbPolicyGetEnabledResponse(soap, NULL, NULL, "cb:CbPolicyGetEnabledResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabled: + return soap_in_PointerTo_cb__CbPolicyGetEnabled(soap, NULL, NULL, "cb:CbPolicyGetEnabled"); + case SOAP_TYPE_PointerTo_cb__CbPolicyDisableResponse: + return soap_in_PointerTo_cb__CbPolicyDisableResponse(soap, NULL, NULL, "cb:CbPolicyDisableResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyDisable: + return soap_in_PointerTo_cb__CbPolicyDisable(soap, NULL, NULL, "cb:CbPolicyDisable"); + case SOAP_TYPE_PointerTo_cb__CbPolicyEnableResponse: + return soap_in_PointerTo_cb__CbPolicyEnableResponse(soap, NULL, NULL, "cb:CbPolicyEnableResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyEnable: + return soap_in_PointerTo_cb__CbPolicyEnable(soap, NULL, NULL, "cb:CbPolicyEnable"); + case SOAP_TYPE_PointerTo_cb__CbPolicyEnumerateResponse: + return soap_in_PointerTo_cb__CbPolicyEnumerateResponse(soap, NULL, NULL, "cb:CbPolicyEnumerateResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyEnumerate: + return soap_in_PointerTo_cb__CbPolicyEnumerate(soap, NULL, NULL, "cb:CbPolicyEnumerate"); + case SOAP_TYPE_PointerTo_cb__CbPolicyDeleteResponse: + return soap_in_PointerTo_cb__CbPolicyDeleteResponse(soap, NULL, NULL, "cb:CbPolicyDeleteResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyDelete: + return soap_in_PointerTo_cb__CbPolicyDelete(soap, NULL, NULL, "cb:CbPolicyDelete"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetResponse: + return soap_in_PointerTo_cb__CbPolicyGetResponse(soap, NULL, NULL, "cb:CbPolicyGetResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGet: + return soap_in_PointerTo_cb__CbPolicyGet(soap, NULL, NULL, "cb:CbPolicyGet"); + case SOAP_TYPE_PointerTo_cb__CbPolicyCreateResponse: + return soap_in_PointerTo_cb__CbPolicyCreateResponse(soap, NULL, NULL, "cb:CbPolicyCreateResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyCreate: + return soap_in_PointerTo_cb__CbPolicyCreate(soap, NULL, NULL, "cb:CbPolicyCreate"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse: + return soap_in_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, NULL, NULL, "apr:ConsoleWatchdogQueryCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilities: + return soap_in_PointerTo_apr__ConsoleWatchdogQueryCapabilities(soap, NULL, NULL, "apr:ConsoleWatchdogQueryCapabilities"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse: + return soap_in_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(soap, NULL, NULL, "apr:ConsoleWatchdogGetCbPolicyResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicy: + return soap_in_PointerTo_apr__ConsoleWatchdogGetCbPolicy(soap, NULL, NULL, "apr:ConsoleWatchdogGetCbPolicy"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse: + return soap_in_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(soap, NULL, NULL, "apr:ConsoleWatchdogSetCbPolicyResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicy: + return soap_in_PointerTo_apr__ConsoleWatchdogSetCbPolicy(soap, NULL, NULL, "apr:ConsoleWatchdogSetCbPolicy"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActionsResponse: + return soap_in_PointerTo_apr__ConsoleWatchdogGetActionsResponse(soap, NULL, NULL, "apr:ConsoleWatchdogGetActionsResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActions: + return soap_in_PointerTo_apr__ConsoleWatchdogGetActions(soap, NULL, NULL, "apr:ConsoleWatchdogGetActions"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActionsResponse: + return soap_in_PointerTo_apr__ConsoleWatchdogSetActionsResponse(soap, NULL, NULL, "apr:ConsoleWatchdogSetActionsResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActions: + return soap_in_PointerTo_apr__ConsoleWatchdogSetActions(soap, NULL, NULL, "apr:ConsoleWatchdogSetActions"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerateResponse: + return soap_in_PointerTo_apr__ConsoleWatchdogEnumerateResponse(soap, NULL, NULL, "apr:ConsoleWatchdogEnumerateResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerate: + return soap_in_PointerTo_apr__ConsoleWatchdogEnumerate(soap, NULL, NULL, "apr:ConsoleWatchdogEnumerate"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDeleteResponse: + return soap_in_PointerTo_apr__ConsoleWatchdogDeleteResponse(soap, NULL, NULL, "apr:ConsoleWatchdogDeleteResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDelete: + return soap_in_PointerTo_apr__ConsoleWatchdogDelete(soap, NULL, NULL, "apr:ConsoleWatchdogDelete"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreateResponse: + return soap_in_PointerTo_apr__ConsoleWatchdogCreateResponse(soap, NULL, NULL, "apr:ConsoleWatchdogCreateResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreate: + return soap_in_PointerTo_apr__ConsoleWatchdogCreate(soap, NULL, NULL, "apr:ConsoleWatchdogCreate"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogRegisterResponse: + return soap_in_PointerTo_apl__AgentWatchdogRegisterResponse(soap, NULL, NULL, "apl:AgentWatchdogRegisterResponse"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogRegister: + return soap_in_PointerTo_apl__AgentWatchdogRegister(soap, NULL, NULL, "apl:AgentWatchdogRegister"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeatResponse: + return soap_in_PointerTo_apl__AgentWatchdogHeartbeatResponse(soap, NULL, NULL, "apl:AgentWatchdogHeartbeatResponse"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeat: + return soap_in_PointerTo_apl__AgentWatchdogHeartbeat(soap, NULL, NULL, "apl:AgentWatchdogHeartbeat"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdownResponse: + return soap_in_PointerTo_apl__AgentWatchdogShutdownResponse(soap, NULL, NULL, "apl:AgentWatchdogShutdownResponse"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdown: + return soap_in_PointerTo_apl__AgentWatchdogShutdown(soap, NULL, NULL, "apl:AgentWatchdogShutdown"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType: + return soap_in_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(soap, NULL, NULL, "cb:CircuitBreakerIPLayeredTCPFlagsType"); + case SOAP_TYPE_PointerTowcxs__WirelessSettingsType: + return soap_in_PointerTowcxs__WirelessSettingsType(soap, NULL, NULL, "wcxs:WirelessSettingsType"); + case SOAP_TYPE_PointerTowcxs__WirelessCapabilitiesType: + return soap_in_PointerTowcxs__WirelessCapabilitiesType(soap, NULL, NULL, "wcxs:WirelessCapabilitiesType"); + case SOAP_TYPE_PointerTowcxs__ProfileType: + return soap_in_PointerTowcxs__ProfileType(soap, NULL, NULL, "wcxs:ProfileType"); + case SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingsType: + return soap_in_PointerTowcxs__ProfileSecuritySettingsType(soap, NULL, NULL, "wcxs:ProfileSecuritySettingsType"); + case SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingRSNType: + return soap_in_PointerTowcxs__ProfileSecuritySettingRSNType(soap, NULL, NULL, "wcxs:ProfileSecuritySettingRSNType"); + case SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingWPAType: + return soap_in_PointerTowcxs__ProfileSecuritySettingWPAType(soap, NULL, NULL, "wcxs:ProfileSecuritySettingWPAType"); + case SOAP_TYPE_PointerTowcxs__DataEncryptionCCMPType: + return soap_in_PointerTowcxs__DataEncryptionCCMPType(soap, NULL, NULL, "wcxs:DataEncryptionCCMPType"); + case SOAP_TYPE_PointerTowcxs__DataEncryptionTKIPType: + return soap_in_PointerTowcxs__DataEncryptionTKIPType(soap, NULL, NULL, "wcxs:DataEncryptionTKIPType"); + case SOAP_TYPE_PointerTowcxs__RawKey256Type: + return soap_in_PointerTowcxs__RawKey256Type(soap, NULL, NULL, "wcxs:RawKey256Type"); + case SOAP_TYPE_PointerTowcxs__PassPhrase63Type: + return soap_in_PointerTowcxs__PassPhrase63Type(soap, NULL, NULL, "wcxs:PassPhrase63Type"); + case SOAP_TYPE_PointerTowcxs__WEP128Type: + return soap_in_PointerTowcxs__WEP128Type(soap, NULL, NULL, "wcxs:WEP128Type"); + case SOAP_TYPE_PointerTowcxs__WEP64Type: + return soap_in_PointerTowcxs__WEP64Type(soap, NULL, NULL, "wcxs:WEP64Type"); + case SOAP_TYPE_PointerTowcxs__RawKey128Type: + return soap_in_PointerTowcxs__RawKey128Type(soap, NULL, NULL, "wcxs:RawKey128Type"); + case SOAP_TYPE_PointerTowcxs__PassPhraseWEP128Type: + return soap_in_PointerTowcxs__PassPhraseWEP128Type(soap, NULL, NULL, "wcxs:PassPhraseWEP128Type"); + case SOAP_TYPE_PointerTowcxs__RawKey64Type: + return soap_in_PointerTowcxs__RawKey64Type(soap, NULL, NULL, "wcxs:RawKey64Type"); + case SOAP_TYPE_PointerTowcxs__PassPhrase5Type: + return soap_in_PointerTowcxs__PassPhrase5Type(soap, NULL, NULL, "wcxs:PassPhrase5Type"); + case SOAP_TYPE_PointerTorci__OemParametersType: + return soap_in_PointerTorci__OemParametersType(soap, NULL, NULL, "rci:OemParametersType"); + case SOAP_TYPE_PointerTorci__BootOptionsType: + return soap_in_PointerTorci__BootOptionsType(soap, NULL, NULL, "rci:BootOptionsType"); + case SOAP_TYPE_PointerTorci__SpecialCommandParameterType: + return soap_in_PointerTorci__SpecialCommandParameterType(soap, NULL, NULL, "rci:SpecialCommandParameterType"); + case SOAP_TYPE_PointerTorci__SpecialCommandType: + return soap_in_PointerTorci__SpecialCommandType(soap, NULL, NULL, "rci:SpecialCommandType"); + case SOAP_TYPE_PointerToinf__IderSessionLogEntryType: + return soap_in_PointerToinf__IderSessionLogEntryType(soap, NULL, NULL, "inf:IderSessionLogEntryType"); + case SOAP_TYPE_PointerToinf__FirmwareVersionType: + return soap_in_PointerToinf__FirmwareVersionType(soap, NULL, NULL, "inf:FirmwareVersionType"); + case SOAP_TYPE_PointerToidr__IderSessionLogEntryType: + return soap_in_PointerToidr__IderSessionLogEntryType(soap, NULL, NULL, "idr:IderSessionLogEntryType"); + case SOAP_TYPE_PointerToapl__GUID: + return soap_in_PointerToapl__GUID(soap, NULL, NULL, "apl:GUID"); + case SOAP_TYPE_PointerToapr__AgentPresenceCapabilitiesType: + return soap_in_PointerToapr__AgentPresenceCapabilitiesType(soap, NULL, NULL, "apr:AgentPresenceCapabilitiesType"); + case SOAP_TYPE_PointerToapr__CircuitBreakerHardwarePolicyType: + return soap_in_PointerToapr__CircuitBreakerHardwarePolicyType(soap, NULL, NULL, "apr:CircuitBreakerHardwarePolicyType"); + case SOAP_TYPE_PointerToapr__ConsoleWatchdogActionType: + return soap_in_PointerToapr__ConsoleWatchdogActionType(soap, NULL, NULL, "apr:ConsoleWatchdogActionType"); + case SOAP_TYPE_PointerToapr__ConsoleWatchdogEntryType: + return soap_in_PointerToapr__ConsoleWatchdogEntryType(soap, NULL, NULL, "apr:ConsoleWatchdogEntryType"); + case SOAP_TYPE_PointerToapr__CbActionType: + return soap_in_PointerToapr__CbActionType(soap, NULL, NULL, "apr:CbActionType"); + case SOAP_TYPE_PointerToapr__GUID: + return soap_in_PointerToapr__GUID(soap, NULL, NULL, "apr:GUID"); + case SOAP_TYPE_PointerTohwa__AssetDataArrayType: + return soap_in_PointerTohwa__AssetDataArrayType(soap, NULL, NULL, "hwa:AssetDataArrayType"); + case SOAP_TYPE_PointerTohwa__AssetTypeArrayType: + return soap_in_PointerTohwa__AssetTypeArrayType(soap, NULL, NULL, "hwa:AssetTypeArrayType"); + case SOAP_TYPE_PointerTohwa__GUID: + return soap_in_PointerTohwa__GUID(soap, NULL, NULL, "hwa:GUID"); + case SOAP_TYPE_PointerToxsd__base64Binary: + return soap_in_PointerToxsd__base64Binary(soap, NULL, NULL, "xsd:base64Binary"); + case SOAP_TYPE_PointerTohwa__AssetDataType: + return soap_in_PointerTohwa__AssetDataType(soap, NULL, NULL, "hwa:AssetDataType"); + case SOAP_TYPE_PointerTocb__BlockedPortInfoType: + return soap_in_PointerTocb__BlockedPortInfoType(soap, NULL, NULL, "cb:BlockedPortInfoType"); + case SOAP_TYPE_PointerTocb__HcbTriggerReasonType: + return soap_in_PointerTocb__HcbTriggerReasonType(soap, NULL, NULL, "cb:HcbTriggerReasonType"); + case SOAP_TYPE_PointerTocb__TimeType: + return soap_in_PointerTocb__TimeType(soap, NULL, NULL, "cb:TimeType"); + case SOAP_TYPE_PointerTocb__HcbOptionsType: + return soap_in_PointerTocb__HcbOptionsType(soap, NULL, NULL, "cb:HcbOptionsType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerCapabilitiesType: + return soap_in_PointerTocb__CircuitBreakerCapabilitiesType(soap, NULL, NULL, "cb:CircuitBreakerCapabilitiesType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerFilterInfoType: + return soap_in_PointerTocb__CircuitBreakerFilterInfoType(soap, NULL, NULL, "cb:CircuitBreakerFilterInfoType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerFilterStatisticsType: + return soap_in_PointerTocb__CircuitBreakerFilterStatisticsType(soap, NULL, NULL, "cb:CircuitBreakerFilterStatisticsType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerApplicationType: + return soap_in_PointerTocb__CircuitBreakerApplicationType(soap, NULL, NULL, "cb:CircuitBreakerApplicationType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerHardwarePolicyType: + return soap_in_PointerTocb__CircuitBreakerHardwarePolicyType(soap, NULL, NULL, "cb:CircuitBreakerHardwarePolicyType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPolicyInfoType: + return soap_in_PointerTocb__CircuitBreakerPolicyInfoType(soap, NULL, NULL, "cb:CircuitBreakerPolicyInfoType"); + case SOAP_TYPE_PointerTocb__TimedCounterType: + return soap_in_PointerTocb__TimedCounterType(soap, NULL, NULL, "cb:TimedCounterType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerFilterType: + return soap_in_PointerTocb__CircuitBreakerFilterType(soap, NULL, NULL, "cb:CircuitBreakerFilterType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketType: + return soap_in_PointerTocb__CircuitBreakerPacketType(soap, NULL, NULL, "cb:CircuitBreakerPacketType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketETHType: + return soap_in_PointerTocb__CircuitBreakerPacketETHType(soap, NULL, NULL, "cb:CircuitBreakerPacketETHType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketIPType: + return soap_in_PointerTocb__CircuitBreakerPacketIPType(soap, NULL, NULL, "cb:CircuitBreakerPacketIPType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketUDPType: + return soap_in_PointerTocb__CircuitBreakerPacketUDPType(soap, NULL, NULL, "cb:CircuitBreakerPacketUDPType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketTCPType: + return soap_in_PointerTocb__CircuitBreakerPacketTCPType(soap, NULL, NULL, "cb:CircuitBreakerPacketTCPType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortType: + return soap_in_PointerTocb__CircuitBreakerIPLayeredPortType(soap, NULL, NULL, "cb:CircuitBreakerIPLayeredPortType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPPacketType: + return soap_in_PointerTocb__CircuitBreakerIPPacketType(soap, NULL, NULL, "cb:CircuitBreakerIPPacketType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv6Type: + return soap_in_PointerTocb__CircuitBreakerIPv6Type(soap, NULL, NULL, "cb:CircuitBreakerIPv6Type"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv4Type: + return soap_in_PointerTocb__CircuitBreakerIPv4Type(soap, NULL, NULL, "cb:CircuitBreakerIPv4Type"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv6AddressAndMaskType: + return soap_in_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(soap, NULL, NULL, "cb:CircuitBreakerIPv6AddressAndMaskType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv4AddressAndMaskType: + return soap_in_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(soap, NULL, NULL, "cb:CircuitBreakerIPv4AddressAndMaskType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortRangeType: + return soap_in_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, NULL, NULL, "cb:CircuitBreakerIPLayeredPortRangeType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortSimpleType: + return soap_in_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(soap, NULL, NULL, "cb:CircuitBreakerIPLayeredPortSimpleType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPolicyType: + return soap_in_PointerTocb__CircuitBreakerPolicyType(soap, NULL, NULL, "cb:CircuitBreakerPolicyType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerDefaultFilterType: + return soap_in_PointerTocb__CircuitBreakerDefaultFilterType(soap, NULL, NULL, "cb:CircuitBreakerDefaultFilterType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerAntiSpoofingFilterType: + return soap_in_PointerTocb__CircuitBreakerAntiSpoofingFilterType(soap, NULL, NULL, "cb:CircuitBreakerAntiSpoofingFilterType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionGeneralType: + return soap_in_PointerToemi__AlertSubscriptionGeneralType(soap, NULL, NULL, "emi:AlertSubscriptionGeneralType"); + case SOAP_TYPE_PointerToemi__SensorAttributesType: + return soap_in_PointerToemi__SensorAttributesType(soap, NULL, NULL, "emi:SensorAttributesType"); + case SOAP_TYPE_PointerToemi__SensorHandleArrayType: + return soap_in_PointerToemi__SensorHandleArrayType(soap, NULL, NULL, "emi:SensorHandleArrayType"); + case SOAP_TYPE_PointerToemi__EventLogRecordArrayType: + return soap_in_PointerToemi__EventLogRecordArrayType(soap, NULL, NULL, "emi:EventLogRecordArrayType"); + case SOAP_TYPE_PointerToemi__EventFilterHandleArrayType: + return soap_in_PointerToemi__EventFilterHandleArrayType(soap, NULL, NULL, "emi:EventFilterHandleArrayType"); + case SOAP_TYPE_PointerToemi__EventFilterType: + return soap_in_PointerToemi__EventFilterType(soap, NULL, NULL, "emi:EventFilterType"); + case SOAP_TYPE_PointerToemi__ByteStr: + return soap_in_PointerToemi__ByteStr(soap, NULL, NULL, "emi:ByteStr"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDArrayType: + return soap_in_PointerToemi__AlertSubscriptionPolicyIDArrayType(soap, NULL, NULL, "emi:AlertSubscriptionPolicyIDArrayType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionHandleArrayType: + return soap_in_PointerToemi__AlertSubscriptionHandleArrayType(soap, NULL, NULL, "emi:AlertSubscriptionHandleArrayType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDType: + return soap_in_PointerToemi__AlertSubscriptionPolicyIDType(soap, NULL, NULL, "emi:AlertSubscriptionPolicyIDType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionType: + return soap_in_PointerToemi__AlertSubscriptionType(soap, NULL, NULL, "emi:AlertSubscriptionType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionSoapType: + return soap_in_PointerToemi__AlertSubscriptionSoapType(soap, NULL, NULL, "emi:AlertSubscriptionSoapType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionSNMPType: + return soap_in_PointerToemi__AlertSubscriptionSNMPType(soap, NULL, NULL, "emi:AlertSubscriptionSNMPType"); + case SOAP_TYPE_PointerToemi__AlertCredentialsType: + return soap_in_PointerToemi__AlertCredentialsType(soap, NULL, NULL, "emi:AlertCredentialsType"); + case SOAP_TYPE_PointerTocmn__URLType: + return soap_in_PointerTocmn__URLType(soap, NULL, NULL, "cmn:URLType"); + case SOAP_TYPE_PointerToemi__CommunityStringType: + return soap_in_PointerToemi__CommunityStringType(soap, NULL, NULL, "emi:CommunityStringType"); + case SOAP_TYPE_PointerTocmn__NodeAddressType: + return soap_in_PointerTocmn__NodeAddressType(soap, NULL, NULL, "cmn:NodeAddressType"); + case SOAP_TYPE_PointerToemi__EventLogRecordType: + return soap_in_PointerToemi__EventLogRecordType(soap, NULL, NULL, "emi:EventLogRecordType"); + case SOAP_TYPE_PointerToemi__ByteData: + return soap_in_PointerToemi__ByteData(soap, NULL, NULL, "emi:ByteData"); + case SOAP_TYPE_PointerTostra__StorageAllocEntryHandleListType: + return soap_in_PointerTostra__StorageAllocEntryHandleListType(soap, NULL, NULL, "stra:StorageAllocEntryHandleListType"); + case SOAP_TYPE_PointerTostra__StorageAllocEntryType: + return soap_in_PointerTostra__StorageAllocEntryType(soap, NULL, NULL, "stra:StorageAllocEntryType"); + case SOAP_TYPE_PointerTostra__StorageEaclEntryHandleListType: + return soap_in_PointerTostra__StorageEaclEntryHandleListType(soap, NULL, NULL, "stra:StorageEaclEntryHandleListType"); + case SOAP_TYPE_PointerTostra__StorageEaclEntryType: + return soap_in_PointerTostra__StorageEaclEntryType(soap, NULL, NULL, "stra:StorageEaclEntryType"); + case SOAP_TYPE_PointerTostra__StorageApplicationAttributesType: + return soap_in_PointerTostra__StorageApplicationAttributesType(soap, NULL, NULL, "stra:StorageApplicationAttributesType"); + case SOAP_TYPE_PointerTostra__StorageApplicationHandleListType: + return soap_in_PointerTostra__StorageApplicationHandleListType(soap, NULL, NULL, "stra:StorageApplicationHandleListType"); + case SOAP_TYPE_PointerTostra__GlobalStorageAttributesType: + return soap_in_PointerTostra__GlobalStorageAttributesType(soap, NULL, NULL, "stra:GlobalStorageAttributesType"); + case SOAP_TYPE_PointerTostra__StorageSnrpApplicationAttributeType: + return soap_in_PointerTostra__StorageSnrpApplicationAttributeType(soap, NULL, NULL, "stra:StorageSnrpApplicationAttributeType"); + case SOAP_TYPE_PointerTostra__GUID: + return soap_in_PointerTostra__GUID(soap, NULL, NULL, "stra:GUID"); + case SOAP_TYPE_PointerTostra__StorageAllocSnrpEntryType: + return soap_in_PointerTostra__StorageAllocSnrpEntryType(soap, NULL, NULL, "stra:StorageAllocSnrpEntryType"); + case SOAP_TYPE_PointerToxcfg__XProfileType: + return soap_in_PointerToxcfg__XProfileType(soap, NULL, NULL, "xcfg:XProfileType"); + case SOAP_TYPE_PointerTonet__InterfaceDescriptorSetType: + return soap_in_PointerTonet__InterfaceDescriptorSetType(soap, NULL, NULL, "net:InterfaceDescriptorSetType"); + case SOAP_TYPE_PointerTonet__InterfaceDescriptorGetType: + return soap_in_PointerTonet__InterfaceDescriptorGetType(soap, NULL, NULL, "net:InterfaceDescriptorGetType"); + case SOAP_TYPE_PointerTocmn__InterfaceHandleType: + return soap_in_PointerTocmn__InterfaceHandleType(soap, NULL, NULL, "cmn:InterfaceHandleType"); + case SOAP_TYPE_PointerTonet__StaticIPv4ParametersType: + return soap_in_PointerTonet__StaticIPv4ParametersType(soap, NULL, NULL, "net:StaticIPv4ParametersType"); + case SOAP_TYPE_PointerTonet__IPv4ParametersType: + return soap_in_PointerTonet__IPv4ParametersType(soap, NULL, NULL, "net:IPv4ParametersType"); + case SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCORETLSType: + return soap_in_PointerToxcfg__XProfileEAPFAST_USCORETLSType(soap, NULL, NULL, "xcfg:XProfileEAPFAST_TLSType"); + case SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREGTCType: + return soap_in_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(soap, NULL, NULL, "xcfg:XProfileEAPFAST_GTCType"); + case SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type: + return soap_in_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, NULL, NULL, "xcfg:XProfileEAPFAST_MSCHAPv2Type"); + case SOAP_TYPE_PointerToxcfg__XProfileEAP_USCOREGTCType: + return soap_in_PointerToxcfg__XProfileEAP_USCOREGTCType(soap, NULL, NULL, "xcfg:XProfileEAP_GTCType"); + case SOAP_TYPE_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type: + return soap_in_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, NULL, NULL, "xcfg:XProfilePEAP_MSCHAPv2Type"); + case SOAP_TYPE_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type: + return soap_in_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, NULL, NULL, "xcfg:XProfileTTLS_MSCHAPv2Type"); + case SOAP_TYPE_PointerToxcfg__XProfileTLSType: + return soap_in_PointerToxcfg__XProfileTLSType(soap, NULL, NULL, "xcfg:XProfileTLSType"); + case SOAP_TYPE_PointerToxcfg__ManualPACType: + return soap_in_PointerToxcfg__ManualPACType(soap, NULL, NULL, "xcfg:ManualPACType"); + case SOAP_TYPE_PointerToxcfg__UserCredentialsType: + return soap_in_PointerToxcfg__UserCredentialsType(soap, NULL, NULL, "xcfg:UserCredentialsType"); + case SOAP_TYPE_PointerToxcfg__ServerIdentityType: + return soap_in_PointerToxcfg__ServerIdentityType(soap, NULL, NULL, "xcfg:ServerIdentityType"); + case SOAP_TYPE_PointerToxcfg__CertificateNameType: + return soap_in_PointerToxcfg__CertificateNameType(soap, NULL, NULL, "xcfg:CertificateNameType"); + case SOAP_TYPE_PointerTosai__CertificateHandleType: + return soap_in_PointerTosai__CertificateHandleType(soap, NULL, NULL, "sai:CertificateHandleType"); + case SOAP_TYPE_PointerTocstr__KeyPairType: + return soap_in_PointerTocstr__KeyPairType(soap, NULL, NULL, "cstr:KeyPairType"); + case SOAP_TYPE_PointerTosai__GlobalPowerPolicyType: + return soap_in_PointerTosai__GlobalPowerPolicyType(soap, NULL, NULL, "sai:GlobalPowerPolicyType"); + case SOAP_TYPE_PointerTosai__EnvironmentDetectionType: + return soap_in_PointerTosai__EnvironmentDetectionType(soap, NULL, NULL, "sai:EnvironmentDetectionType"); + case SOAP_TYPE_PointerTosai__ProvisioningAuditRecordType: + return soap_in_PointerTosai__ProvisioningAuditRecordType(soap, NULL, NULL, "sai:ProvisioningAuditRecordType"); + case SOAP_TYPE_PointerTosai__CertHashEntryType: + return soap_in_PointerTosai__CertHashEntryType(soap, NULL, NULL, "sai:CertHashEntryType"); + case SOAP_TYPE_PointerTosai__ProvisioningOTPType: + return soap_in_PointerTosai__ProvisioningOTPType(soap, NULL, NULL, "sai:ProvisioningOTPType"); + case SOAP_TYPE_PointerTounsignedShort: + return soap_in_PointerTounsignedShort(soap, NULL, NULL, "xsd:unsignedShort"); + case SOAP_TYPE_PointerTosai__PowerStateType: + return soap_in_PointerTosai__PowerStateType(soap, NULL, NULL, "sai:PowerStateType"); + case SOAP_TYPE_PointerTosai__PkiCapsType: + return soap_in_PointerTosai__PkiCapsType(soap, NULL, NULL, "sai:PkiCapsType"); + case SOAP_TYPE_PointerTosai__CrlType: + return soap_in_PointerTosai__CrlType(soap, NULL, NULL, "sai:CrlType"); + case SOAP_TYPE_PointerTosai__CertificateType: + return soap_in_PointerTosai__CertificateType(soap, NULL, NULL, "sai:CertificateType"); + case SOAP_TYPE_PointerTosai__TlsOptionsType: + return soap_in_PointerTosai__TlsOptionsType(soap, NULL, NULL, "sai:TlsOptionsType"); + case SOAP_TYPE_PointerTosai__KerberosOptionsType: + return soap_in_PointerTosai__KerberosOptionsType(soap, NULL, NULL, "sai:KerberosOptionsType"); + case SOAP_TYPE_PointerTosai__AdminAclEntryExType: + return soap_in_PointerTosai__AdminAclEntryExType(soap, NULL, NULL, "sai:AdminAclEntryExType"); + case SOAP_TYPE_PointerTosai__UserAclEntryExType: + return soap_in_PointerTosai__UserAclEntryExType(soap, NULL, NULL, "sai:UserAclEntryExType"); + case SOAP_TYPE_PointerTosai__UpdateCoreUrlKeyType: + return soap_in_PointerTosai__UpdateCoreUrlKeyType(soap, NULL, NULL, "sai:UpdateCoreUrlKeyType"); + case SOAP_TYPE_PointerTosai__AmtVersion: + return soap_in_PointerTosai__AmtVersion(soap, NULL, NULL, "sai:AmtVersion"); + case SOAP_TYPE_PointerTosai__RngKeyType: + return soap_in_PointerTosai__RngKeyType(soap, NULL, NULL, "sai:RngKeyType"); + case SOAP_TYPE_PointerTosai__CertificateChainType: + return soap_in_PointerTosai__CertificateChainType(soap, NULL, NULL, "sai:CertificateChainType"); + case SOAP_TYPE_PointerTosai__RsaKeyType: + return soap_in_PointerTosai__RsaKeyType(soap, NULL, NULL, "sai:RsaKeyType"); + case SOAP_TYPE_PointerTosai__UserAclEntryHandleListType: + return soap_in_PointerTosai__UserAclEntryHandleListType(soap, NULL, NULL, "sai:UserAclEntryHandleListType"); + case SOAP_TYPE_PointerTosai__AdminAclEntryType: + return soap_in_PointerTosai__AdminAclEntryType(soap, NULL, NULL, "sai:AdminAclEntryType"); + case SOAP_TYPE_PointerTosai__UserAclEntryType: + return soap_in_PointerTosai__UserAclEntryType(soap, NULL, NULL, "sai:UserAclEntryType"); + case SOAP_TYPE_PointerTounsignedInt: + return soap_in_PointerTounsignedInt(soap, NULL, NULL, "xsd:unsignedInt"); + case SOAP_TYPE_PointerTosai__EnvironmentDetectionDomainType: + return soap_in_PointerTosai__EnvironmentDetectionDomainType(soap, NULL, NULL, "sai:EnvironmentDetectionDomainType"); + case SOAP_TYPE_PointerTobool: + return soap_in_PointerTobool(soap, NULL, NULL, "xsd:boolean"); + case SOAP_TYPE_PointerTostd__string: + return soap_in_PointerTostd__string(soap, NULL, NULL, "xsd:string"); + case SOAP_TYPE_PointerTosai__KerberosSpnType: + return soap_in_PointerTosai__KerberosSpnType(soap, NULL, NULL, "sai:KerberosSpnType"); + case SOAP_TYPE_PointerTosai__UserEntryKerberosType: + return soap_in_PointerTosai__UserEntryKerberosType(soap, NULL, NULL, "sai:UserEntryKerberosType"); + case SOAP_TYPE_PointerTosai__UserEntryDigestType: + return soap_in_PointerTosai__UserEntryDigestType(soap, NULL, NULL, "sai:UserEntryDigestType"); + case SOAP_TYPE_PointerTosai__UserAclRealmListType: + return soap_in_PointerTosai__UserAclRealmListType(soap, NULL, NULL, "sai:UserAclRealmListType"); + case SOAP_TYPE_PointerTocstr__RSAKeyPairType: + return soap_in_PointerTocstr__RSAKeyPairType(soap, NULL, NULL, "cstr:RSAKeyPairType"); + case SOAP_TYPE_PointerTocmn__IPv6AddressStringType: + return soap_in_PointerTocmn__IPv6AddressStringType(soap, NULL, NULL, "cmn:IPv6AddressStringType"); + case SOAP_TYPE_PointerTocmn__IPv4AddressStringType: + return soap_in_PointerTocmn__IPv4AddressStringType(soap, NULL, NULL, "cmn:IPv4AddressStringType"); + case SOAP_TYPE_PointerTocmn__HostNameType: + return soap_in_PointerTocmn__HostNameType(soap, NULL, NULL, "cmn:HostNameType"); + case SOAP_TYPE_PointerTounsignedByte: + return soap_in_PointerTounsignedByte(soap, NULL, NULL, "xsd:unsignedByte"); + case SOAP_TYPE_string: + { char **s; + s = soap_in_string(soap, NULL, NULL, "xsd:string"); + return s ? *s : NULL; + } + default: + { const char *t = soap->type; + if (!*t) + t = soap->tag; + if (!soap_match_tag(soap, t, "xsd:byte")) + { *type = SOAP_TYPE_byte; + return soap_in_byte(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:short")) + { *type = SOAP_TYPE_short; + return soap_in_short(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:int")) + { *type = SOAP_TYPE_int; + return soap_in_int(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:ProfilePriorityType")) + { *type = SOAP_TYPE_wcxs__ProfilePriorityType; + return soap_in_wcxs__ProfilePriorityType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:SystemCapabilitiesSupportedType")) + { *type = SOAP_TYPE_rci__SystemCapabilitiesSupportedType; + return soap_in_rci__SystemCapabilitiesSupportedType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:WatchdogState")) + { *type = SOAP_TYPE_apr__WatchdogState; + return soap_in_apr__WatchdogState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_MEMORY_TYPE")) + { *type = SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE; + return soap_in_hwa__PT_USCOREMEMORY_USCORETYPE(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_MEMORY_FORM_FACTOR")) + { *type = SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR; + return soap_in_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_PROCESSOR_UPGRADE")) + { *type = SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE; + return soap_in_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_PROCESSOR_STATUS")) + { *type = SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS; + return soap_in_hwa__PT_USCOREPROCESSOR_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_PROCESSOR_FAMILY")) + { *type = SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY; + return soap_in_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_PROCESSOR_TYPE")) + { *type = SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE; + return soap_in_hwa__PT_USCOREPROCESSOR_USCORETYPE(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertSubscriptionPolicyIDType")) + { *type = SOAP_TYPE_emi__AlertSubscriptionPolicyIDType; + return soap_in_emi__AlertSubscriptionPolicyIDType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:LinkPolicyType")) + { *type = SOAP_TYPE_net__LinkPolicyType; + return soap_in_net__LinkPolicyType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:unsignedByte")) + { *type = SOAP_TYPE_unsignedByte; + return soap_in_unsignedByte(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:OemParametersType")) + { *type = SOAP_TYPE_rci__OemParametersType; + return soap_in_rci__OemParametersType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:SpecialCommandParameterType")) + { *type = SOAP_TYPE_rci__SpecialCommandParameterType; + return soap_in_rci__SpecialCommandParameterType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:BootOptionsType")) + { *type = SOAP_TYPE_rci__BootOptionsType; + return soap_in_rci__BootOptionsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:SpecialCommandsSupportedType")) + { *type = SOAP_TYPE_rci__SpecialCommandsSupportedType; + return soap_in_rci__SpecialCommandsSupportedType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_MEMORY_TYPE_DETAIL")) + { *type = SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL; + return soap_in_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:unsignedShort")) + { *type = SOAP_TYPE_unsignedShort; + return soap_in_unsignedShort(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:OemDefinedCapabilitiesType")) + { *type = SOAP_TYPE_rci__OemDefinedCapabilitiesType; + return soap_in_rci__OemDefinedCapabilitiesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:SystemFirmwareCapabilitiesType")) + { *type = SOAP_TYPE_rci__SystemFirmwareCapabilitiesType; + return soap_in_rci__SystemFirmwareCapabilitiesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:PT_STATUS")) + { *type = SOAP_TYPE_rci__PT_USCORESTATUS; + return soap_in_rci__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:SystemPowerStateType")) + { *type = SOAP_TYPE_rci__SystemPowerStateType; + return soap_in_rci__SystemPowerStateType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:IPv4AddressType")) + { *type = SOAP_TYPE_inf__IPv4AddressType; + return soap_in_inf__IPv4AddressType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:TimeType")) + { *type = SOAP_TYPE_inf__TimeType; + return soap_in_inf__TimeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:PT_STATUS")) + { *type = SOAP_TYPE_inf__PT_USCORESTATUS; + return soap_in_inf__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "str:PT_STATUS")) + { *type = SOAP_TYPE_str__PT_USCORESTATUS; + return soap_in_str__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "tim:TimeType")) + { *type = SOAP_TYPE_tim__TimeType; + return soap_in_tim__TimeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "tim:PT_STATUS")) + { *type = SOAP_TYPE_tim__PT_USCORESTATUS; + return soap_in_tim__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:IPv4AddressType")) + { *type = SOAP_TYPE_idr__IPv4AddressType; + return soap_in_idr__IPv4AddressType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:TimeType")) + { *type = SOAP_TYPE_idr__TimeType; + return soap_in_idr__TimeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:PT_STATUS")) + { *type = SOAP_TYPE_idr__PT_USCORESTATUS; + return soap_in_idr__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apl:PT_STATUS")) + { *type = SOAP_TYPE_apl__PT_USCORESTATUS; + return soap_in_apl__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:PT_STATUS")) + { *type = SOAP_TYPE_apr__PT_USCORESTATUS; + return soap_in_apr__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_BIOS_CHARACTERISTICS")) + { *type = SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS; + return soap_in_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_STATUS")) + { *type = SOAP_TYPE_hwa__PT_USCORESTATUS; + return soap_in_hwa__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:TimeType")) + { *type = SOAP_TYPE_cb__TimeType; + return soap_in_cb__TimeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:PT_STATUS")) + { *type = SOAP_TYPE_cb__PT_USCORESTATUS; + return soap_in_cb__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SensorHandleType")) + { *type = SOAP_TYPE_emi__SensorHandleType; + return soap_in_emi__SensorHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:IPv4AddressType")) + { *type = SOAP_TYPE_emi__IPv4AddressType; + return soap_in_emi__IPv4AddressType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:PT_STATUS")) + { *type = SOAP_TYPE_emi__PT_USCORESTATUS; + return soap_in_emi__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EventFilterHandleType")) + { *type = SOAP_TYPE_emi__EventFilterHandleType; + return soap_in_emi__EventFilterHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertSubscriptionHandleType")) + { *type = SOAP_TYPE_emi__AlertSubscriptionHandleType; + return soap_in_emi__AlertSubscriptionHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:TimeType")) + { *type = SOAP_TYPE_emi__TimeType; + return soap_in_emi__TimeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageAllocEntryHandleType")) + { *type = SOAP_TYPE_stra__StorageAllocEntryHandleType; + return soap_in_stra__StorageAllocEntryHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageEaclEntryHandleType")) + { *type = SOAP_TYPE_stra__StorageEaclEntryHandleType; + return soap_in_stra__StorageEaclEntryHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageApplicationHandleType")) + { *type = SOAP_TYPE_stra__StorageApplicationHandleType; + return soap_in_stra__StorageApplicationHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:PT_STATUS")) + { *type = SOAP_TYPE_stra__PT_USCORESTATUS; + return soap_in_stra__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:InterfaceHandleType")) + { *type = SOAP_TYPE_net__InterfaceHandleType; + return soap_in_net__InterfaceHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:IPv4AddressType")) + { *type = SOAP_TYPE_net__IPv4AddressType; + return soap_in_net__IPv4AddressType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:PT_STATUS")) + { *type = SOAP_TYPE_net__PT_USCORESTATUS; + return soap_in_net__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertificateHandleType")) + { *type = SOAP_TYPE_sai__CertificateHandleType; + return soap_in_sai__CertificateHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:IPv4AddressType")) + { *type = SOAP_TYPE_sai__IPv4AddressType; + return soap_in_sai__IPv4AddressType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UserAclEntryHandleType")) + { *type = SOAP_TYPE_sai__UserAclEntryHandleType; + return soap_in_sai__UserAclEntryHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:PT_STATUS")) + { *type = SOAP_TYPE_sai__PT_USCORESTATUS; + return soap_in_sai__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cstr:KeyPairHandleType")) + { *type = SOAP_TYPE_cstr__KeyPairHandleType; + return soap_in_cstr__KeyPairHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cmn:InterfaceHandleType")) + { *type = SOAP_TYPE_cmn__InterfaceHandleType; + return soap_in_cmn__InterfaceHandleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cmn:IPv4AddressType")) + { *type = SOAP_TYPE_cmn__IPv4AddressType; + return soap_in_cmn__IPv4AddressType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cmn:PT_STATUS")) + { *type = SOAP_TYPE_cmn__PT_USCORESTATUS; + return soap_in_cmn__PT_USCORESTATUS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:unsignedInt")) + { *type = SOAP_TYPE_unsignedInt; + return soap_in_unsignedInt(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:boolean")) + { *type = SOAP_TYPE_bool; + return soap_in_bool(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:FeatureType")) + { *type = SOAP_TYPE_wcxs__FeatureType; + return soap_in_wcxs__FeatureType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:KeyIndexType")) + { *type = SOAP_TYPE_wcxs__KeyIndexType; + return soap_in_wcxs__KeyIndexType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:SpecialCommandType")) + { *type = SOAP_TYPE_rci__SpecialCommandType; + return soap_in_rci__SpecialCommandType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:RemoteControlCommandType")) + { *type = SOAP_TYPE_rci__RemoteControlCommandType; + return soap_in_rci__RemoteControlCommandType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:EnabledInterfacesType")) + { *type = SOAP_TYPE_inf__EnabledInterfacesType; + return soap_in_inf__EnabledInterfacesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:PasswordModelType")) + { *type = SOAP_TYPE_inf__PasswordModelType; + return soap_in_inf__PasswordModelType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:ProvisioningStateType")) + { *type = SOAP_TYPE_inf__ProvisioningStateType; + return soap_in_inf__ProvisioningStateType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:ProvisioningModeType")) + { *type = SOAP_TYPE_inf__ProvisioningModeType; + return soap_in_inf__ProvisioningModeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:CbActionType")) + { *type = SOAP_TYPE_apr__CbActionType; + return soap_in_apr__CbActionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:AssetTypeType")) + { *type = SOAP_TYPE_hwa__AssetTypeType; + return soap_in_hwa__AssetTypeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:HcbTriggerReasonType")) + { *type = SOAP_TYPE_cb__HcbTriggerReasonType; + return soap_in_cb__HcbTriggerReasonType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:HcbStateType")) + { *type = SOAP_TYPE_cb__HcbStateType; + return soap_in_cb__HcbStateType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerApplicationType")) + { *type = SOAP_TYPE_cb__CircuitBreakerApplicationType; + return soap_in_cb__CircuitBreakerApplicationType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerProfileType")) + { *type = SOAP_TYPE_cb__CircuitBreakerProfileType; + return soap_in_cb__CircuitBreakerProfileType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerFilterIPAddressDirectionType")) + { *type = SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType; + return soap_in_cb__CircuitBreakerFilterIPAddressDirectionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerFilterDirectionType")) + { *type = SOAP_TYPE_cb__CircuitBreakerFilterDirectionType; + return soap_in_cb__CircuitBreakerFilterDirectionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertAuthOptionsType")) + { *type = SOAP_TYPE_emi__AlertAuthOptionsType; + return soap_in_emi__AlertAuthOptionsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EventSeverityType")) + { *type = SOAP_TYPE_emi__EventSeverityType; + return soap_in_emi__EventSeverityType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:ISVS_APP_ATTR_TYPE")) + { *type = SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE; + return soap_in_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:InterfaceModeType")) + { *type = SOAP_TYPE_net__InterfaceModeType; + return soap_in_net__InterfaceModeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:DhcpModeType")) + { *type = SOAP_TYPE_net__DhcpModeType; + return soap_in_net__DhcpModeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:CertNameOptionsType")) + { *type = SOAP_TYPE_xcfg__CertNameOptionsType; + return soap_in_xcfg__CertNameOptionsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:HTTPAuthOptionType")) + { *type = SOAP_TYPE_sai__HTTPAuthOptionType; + return soap_in_sai__HTTPAuthOptionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:HashTypeType")) + { *type = SOAP_TYPE_sai__HashTypeType; + return soap_in_sai__HashTypeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:ProvisioningTLSModeType")) + { *type = SOAP_TYPE_sai__ProvisioningTLSModeType; + return soap_in_sai__ProvisioningTLSModeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:TlsAthenticationType")) + { *type = SOAP_TYPE_sai__TlsAthenticationType; + return soap_in_sai__TlsAthenticationType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:InterfaceType")) + { *type = SOAP_TYPE_sai__InterfaceType; + return soap_in_sai__InterfaceType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnabledInterfacesType")) + { *type = SOAP_TYPE_sai__EnabledInterfacesType; + return soap_in_sai__EnabledInterfacesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:PowerStateType")) + { *type = SOAP_TYPE_sai__PowerStateType; + return soap_in_sai__PowerStateType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:KerberosEncryptionType")) + { *type = SOAP_TYPE_sai__KerberosEncryptionType; + return soap_in_sai__KerberosEncryptionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:KerberosSpnProtocolType")) + { *type = SOAP_TYPE_sai__KerberosSpnProtocolType; + return soap_in_sai__KerberosSpnProtocolType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AccessPermissionType")) + { *type = SOAP_TYPE_sai__AccessPermissionType; + return soap_in_sai__AccessPermissionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:ProvisioningModeType")) + { *type = SOAP_TYPE_sai__ProvisioningModeType; + return soap_in_sai__ProvisioningModeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:RngKeyEncodingType")) + { *type = SOAP_TYPE_sai__RngKeyEncodingType; + return soap_in_sai__RngKeyEncodingType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:RsaCertificateEncodingType")) + { *type = SOAP_TYPE_sai__RsaCertificateEncodingType; + return soap_in_sai__RsaCertificateEncodingType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:RsaKeyEncodingType")) + { *type = SOAP_TYPE_sai__RsaKeyEncodingType; + return soap_in_sai__RsaKeyEncodingType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UserAclRealmType")) + { *type = SOAP_TYPE_sai__UserAclRealmType; + return soap_in_sai__UserAclRealmType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:PassPhrase63Type")) + { *type = SOAP_TYPE_wcxs__PassPhrase63Type; + return soap_in_wcxs__PassPhrase63Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:PassPhraseWEP128Type")) + { *type = SOAP_TYPE_wcxs__PassPhraseWEP128Type; + return soap_in_wcxs__PassPhraseWEP128Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:PassPhrase5Type")) + { *type = SOAP_TYPE_wcxs__PassPhrase5Type; + return soap_in_wcxs__PassPhrase5Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:RawKey256Type")) + { *type = SOAP_TYPE_wcxs__RawKey256Type; + return soap_in_wcxs__RawKey256Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:RawKey128Type")) + { *type = SOAP_TYPE_wcxs__RawKey128Type; + return soap_in_wcxs__RawKey128Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:RawKey64Type")) + { *type = SOAP_TYPE_wcxs__RawKey64Type; + return soap_in_wcxs__RawKey64Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:ProfileNameType")) + { *type = SOAP_TYPE_wcxs__ProfileNameType; + return soap_in_wcxs__ProfileNameType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:IPv6AddressStringType")) + { *type = SOAP_TYPE_cb__IPv6AddressStringType; + return soap_in_cb__IPv6AddressStringType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:IPv4AddressStringType")) + { *type = SOAP_TYPE_cb__IPv4AddressStringType; + return soap_in_cb__IPv4AddressStringType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:CommunityStringType")) + { *type = SOAP_TYPE_emi__CommunityStringType; + return soap_in_emi__CommunityStringType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:MACAddressType")) + { *type = SOAP_TYPE_net__MACAddressType; + return soap_in_net__MACAddressType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:FriendlyNameType")) + { *type = SOAP_TYPE_sai__FriendlyNameType; + return soap_in_sai__FriendlyNameType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:ProvisioningOTPType")) + { *type = SOAP_TYPE_sai__ProvisioningOTPType; + return soap_in_sai__ProvisioningOTPType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:MEBxPasswordType")) + { *type = SOAP_TYPE_sai__MEBxPasswordType; + return soap_in_sai__MEBxPasswordType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AclPasswordStringType")) + { *type = SOAP_TYPE_sai__AclPasswordStringType; + return soap_in_sai__AclPasswordStringType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AclStringType")) + { *type = SOAP_TYPE_sai__AclStringType; + return soap_in_sai__AclStringType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cmn:GuidBuf")) + { *type = SOAP_TYPE_cmn__GuidBuf; + return soap_in_cmn__GuidBuf(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cmn:IPv6AddressStringType")) + { *type = SOAP_TYPE_cmn__IPv6AddressStringType; + return soap_in_cmn__IPv6AddressStringType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cmn:IPv4AddressStringType")) + { *type = SOAP_TYPE_cmn__IPv4AddressStringType; + return soap_in_cmn__IPv4AddressStringType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cmn:HostNameType")) + { *type = SOAP_TYPE_cmn__HostNameType; + return soap_in_cmn__HostNameType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:WirelessSettingsType")) + { *type = SOAP_TYPE_wcxs__WirelessSettingsType; + return soap_in_wcxs__WirelessSettingsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:WirelessCapabilitiesType")) + { *type = SOAP_TYPE_wcxs__WirelessCapabilitiesType; + return soap_in_wcxs__WirelessCapabilitiesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:ProfileType")) + { *type = SOAP_TYPE_wcxs__ProfileType; + return soap_in_wcxs__ProfileType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:ProfileSecuritySettingsType")) + { *type = SOAP_TYPE_wcxs__ProfileSecuritySettingsType; + return soap_in_wcxs__ProfileSecuritySettingsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:ProfileSecuritySettingRSNType")) + { *type = SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType; + return soap_in_wcxs__ProfileSecuritySettingRSNType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:ProfileSecuritySettingWPAType")) + { *type = SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType; + return soap_in_wcxs__ProfileSecuritySettingWPAType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:DataEncryptionCCMPType")) + { *type = SOAP_TYPE_wcxs__DataEncryptionCCMPType; + return soap_in_wcxs__DataEncryptionCCMPType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:DataEncryptionTKIPType")) + { *type = SOAP_TYPE_wcxs__DataEncryptionTKIPType; + return soap_in_wcxs__DataEncryptionTKIPType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:DataEncryptionWEPType")) + { *type = SOAP_TYPE_wcxs__DataEncryptionWEPType; + return soap_in_wcxs__DataEncryptionWEPType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:DataEncryptionWEPXType")) + { *type = SOAP_TYPE_wcxs__DataEncryptionWEPXType; + return soap_in_wcxs__DataEncryptionWEPXType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:WEP128Type")) + { *type = SOAP_TYPE_wcxs__WEP128Type; + return soap_in_wcxs__WEP128Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:WEP64Type")) + { *type = SOAP_TYPE_wcxs__WEP64Type; + return soap_in_wcxs__WEP64Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:FirmwareVersionType")) + { *type = SOAP_TYPE_inf__FirmwareVersionType; + return soap_in_inf__FirmwareVersionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:IderSessionLogEntryType")) + { *type = SOAP_TYPE_inf__IderSessionLogEntryType; + return soap_in_inf__IderSessionLogEntryType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:FirmwareVersionType")) + { *type = SOAP_TYPE_idr__FirmwareVersionType; + return soap_in_idr__FirmwareVersionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:IderSessionLogEntryType")) + { *type = SOAP_TYPE_idr__IderSessionLogEntryType; + return soap_in_idr__IderSessionLogEntryType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apl:GUID")) + { *type = SOAP_TYPE_apl__GUID; + return soap_in_apl__GUID(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:AgentPresenceCapabilitiesType")) + { *type = SOAP_TYPE_apr__AgentPresenceCapabilitiesType; + return soap_in_apr__AgentPresenceCapabilitiesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:CircuitBreakerHardwarePolicyType")) + { *type = SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType; + return soap_in_apr__CircuitBreakerHardwarePolicyType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogActionType")) + { *type = SOAP_TYPE_apr__ConsoleWatchdogActionType; + return soap_in_apr__ConsoleWatchdogActionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogEntryType")) + { *type = SOAP_TYPE_apr__ConsoleWatchdogEntryType; + return soap_in_apr__ConsoleWatchdogEntryType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:GUID")) + { *type = SOAP_TYPE_apr__GUID; + return soap_in_apr__GUID(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_MEDIA_DEVICE")) + { *type = SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE; + return soap_in_hwa__PT_USCOREMEDIA_USCOREDEVICE(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_FRU")) + { *type = SOAP_TYPE_hwa__PT_USCOREFRU; + return soap_in_hwa__PT_USCOREFRU(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_MEMORY_MODULE")) + { *type = SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE; + return soap_in_hwa__PT_USCOREMEMORY_USCOREMODULE(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_PROCESSOR")) + { *type = SOAP_TYPE_hwa__PT_USCOREPROCESSOR; + return soap_in_hwa__PT_USCOREPROCESSOR(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_BASEBOARD")) + { *type = SOAP_TYPE_hwa__PT_USCOREBASEBOARD; + return soap_in_hwa__PT_USCOREBASEBOARD(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:GUID")) + { *type = SOAP_TYPE_hwa__GUID; + return soap_in_hwa__GUID(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_COMPUTER_SYSTEM")) + { *type = SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM; + return soap_in_hwa__PT_USCORECOMPUTER_USCORESYSTEM(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:PT_BIOS")) + { *type = SOAP_TYPE_hwa__PT_USCOREBIOS; + return soap_in_hwa__PT_USCOREBIOS(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:AssetDataType")) + { *type = SOAP_TYPE_hwa__AssetDataType; + return soap_in_hwa__AssetDataType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:AssetDataArrayType")) + { *type = SOAP_TYPE_hwa__AssetDataArrayType; + return soap_in_hwa__AssetDataArrayType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:AssetTypeArrayType")) + { *type = SOAP_TYPE_hwa__AssetTypeArrayType; + return soap_in_hwa__AssetTypeArrayType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:HcbOptionsType")) + { *type = SOAP_TYPE_cb__HcbOptionsType; + return soap_in_cb__HcbOptionsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:BlockedPortInfoType")) + { *type = SOAP_TYPE_cb__BlockedPortInfoType; + return soap_in_cb__BlockedPortInfoType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:TimedCounterType")) + { *type = SOAP_TYPE_cb__TimedCounterType; + return soap_in_cb__TimedCounterType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerHardwarePolicyType")) + { *type = SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType; + return soap_in_cb__CircuitBreakerHardwarePolicyType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerFilterStatisticsType")) + { *type = SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType; + return soap_in_cb__CircuitBreakerFilterStatisticsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerCapabilitiesType")) + { *type = SOAP_TYPE_cb__CircuitBreakerCapabilitiesType; + return soap_in_cb__CircuitBreakerCapabilitiesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerFilterInfoType")) + { *type = SOAP_TYPE_cb__CircuitBreakerFilterInfoType; + return soap_in_cb__CircuitBreakerFilterInfoType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerFilterType")) + { *type = SOAP_TYPE_cb__CircuitBreakerFilterType; + return soap_in_cb__CircuitBreakerFilterType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerPacketType")) + { *type = SOAP_TYPE_cb__CircuitBreakerPacketType; + return soap_in_cb__CircuitBreakerPacketType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerPacketETHType")) + { *type = SOAP_TYPE_cb__CircuitBreakerPacketETHType; + return soap_in_cb__CircuitBreakerPacketETHType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerPacketIPType")) + { *type = SOAP_TYPE_cb__CircuitBreakerPacketIPType; + return soap_in_cb__CircuitBreakerPacketIPType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerPacketTCPType")) + { *type = SOAP_TYPE_cb__CircuitBreakerPacketTCPType; + return soap_in_cb__CircuitBreakerPacketTCPType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerPacketUDPType")) + { *type = SOAP_TYPE_cb__CircuitBreakerPacketUDPType; + return soap_in_cb__CircuitBreakerPacketUDPType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerIPPacketType")) + { *type = SOAP_TYPE_cb__CircuitBreakerIPPacketType; + return soap_in_cb__CircuitBreakerIPPacketType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerIPv6Type")) + { *type = SOAP_TYPE_cb__CircuitBreakerIPv6Type; + return soap_in_cb__CircuitBreakerIPv6Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerIPv4Type")) + { *type = SOAP_TYPE_cb__CircuitBreakerIPv4Type; + return soap_in_cb__CircuitBreakerIPv4Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerIPLayeredTCPFlagsType")) + { *type = SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType; + return soap_in_cb__CircuitBreakerIPLayeredTCPFlagsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerIPLayeredPortType")) + { *type = SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType; + return soap_in_cb__CircuitBreakerIPLayeredPortType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerIPLayeredPortRangeType")) + { *type = SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType; + return soap_in_cb__CircuitBreakerIPLayeredPortRangeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerIPLayeredPortSimpleType")) + { *type = SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType; + return soap_in_cb__CircuitBreakerIPLayeredPortSimpleType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerIPv6AddressAndMaskType")) + { *type = SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType; + return soap_in_cb__CircuitBreakerIPv6AddressAndMaskType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerIPv4AddressAndMaskType")) + { *type = SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType; + return soap_in_cb__CircuitBreakerIPv4AddressAndMaskType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerPolicyInfoType")) + { *type = SOAP_TYPE_cb__CircuitBreakerPolicyInfoType; + return soap_in_cb__CircuitBreakerPolicyInfoType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerPolicyType")) + { *type = SOAP_TYPE_cb__CircuitBreakerPolicyType; + return soap_in_cb__CircuitBreakerPolicyType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerDefaultFilterType")) + { *type = SOAP_TYPE_cb__CircuitBreakerDefaultFilterType; + return soap_in_cb__CircuitBreakerDefaultFilterType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CircuitBreakerAntiSpoofingFilterType")) + { *type = SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType; + return soap_in_cb__CircuitBreakerAntiSpoofingFilterType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertSubscriptionGeneralType")) + { *type = SOAP_TYPE_emi__AlertSubscriptionGeneralType; + return soap_in_emi__AlertSubscriptionGeneralType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertSubscriptionSoapType")) + { *type = SOAP_TYPE_emi__AlertSubscriptionSoapType; + return soap_in_emi__AlertSubscriptionSoapType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertSubscriptionSNMPType")) + { *type = SOAP_TYPE_emi__AlertSubscriptionSNMPType; + return soap_in_emi__AlertSubscriptionSNMPType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertCredentialsType")) + { *type = SOAP_TYPE_emi__AlertCredentialsType; + return soap_in_emi__AlertCredentialsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:ByteStr")) + { *type = SOAP_TYPE_emi__ByteStr; + return soap_in_emi__ByteStr(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SensorAttributesType")) + { *type = SOAP_TYPE_emi__SensorAttributesType; + return soap_in_emi__SensorAttributesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SensorHandleArrayType")) + { *type = SOAP_TYPE_emi__SensorHandleArrayType; + return soap_in_emi__SensorHandleArrayType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EventLogRecordArrayType")) + { *type = SOAP_TYPE_emi__EventLogRecordArrayType; + return soap_in_emi__EventLogRecordArrayType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EventFilterHandleArrayType")) + { *type = SOAP_TYPE_emi__EventFilterHandleArrayType; + return soap_in_emi__EventFilterHandleArrayType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertSubscriptionHandleArrayType")) + { *type = SOAP_TYPE_emi__AlertSubscriptionHandleArrayType; + return soap_in_emi__AlertSubscriptionHandleArrayType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertSubscriptionType")) + { *type = SOAP_TYPE_emi__AlertSubscriptionType; + return soap_in_emi__AlertSubscriptionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EventFilterType")) + { *type = SOAP_TYPE_emi__EventFilterType; + return soap_in_emi__EventFilterType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EventLogRecordType")) + { *type = SOAP_TYPE_emi__EventLogRecordType; + return soap_in_emi__EventLogRecordType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:ByteData")) + { *type = SOAP_TYPE_emi__ByteData; + return soap_in_emi__ByteData(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AlertSubscriptionPolicyIDArrayType")) + { *type = SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType; + return soap_in_emi__AlertSubscriptionPolicyIDArrayType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageApplicationAttributesType")) + { *type = SOAP_TYPE_stra__StorageApplicationAttributesType; + return soap_in_stra__StorageApplicationAttributesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageSnrpApplicationAttributeType")) + { *type = SOAP_TYPE_stra__StorageSnrpApplicationAttributeType; + return soap_in_stra__StorageSnrpApplicationAttributeType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageApplicationHandleListType")) + { *type = SOAP_TYPE_stra__StorageApplicationHandleListType; + return soap_in_stra__StorageApplicationHandleListType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:GlobalStorageAttributesType")) + { *type = SOAP_TYPE_stra__GlobalStorageAttributesType; + return soap_in_stra__GlobalStorageAttributesType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:GUID")) + { *type = SOAP_TYPE_stra__GUID; + return soap_in_stra__GUID(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageAllocEntryHandleListType")) + { *type = SOAP_TYPE_stra__StorageAllocEntryHandleListType; + return soap_in_stra__StorageAllocEntryHandleListType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageAllocSnrpEntryType")) + { *type = SOAP_TYPE_stra__StorageAllocSnrpEntryType; + return soap_in_stra__StorageAllocSnrpEntryType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageAllocEntryType")) + { *type = SOAP_TYPE_stra__StorageAllocEntryType; + return soap_in_stra__StorageAllocEntryType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageEaclEntryHandleListType")) + { *type = SOAP_TYPE_stra__StorageEaclEntryHandleListType; + return soap_in_stra__StorageEaclEntryHandleListType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:StorageEaclEntryType")) + { *type = SOAP_TYPE_stra__StorageEaclEntryType; + return soap_in_stra__StorageEaclEntryType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:InterfaceDescriptorGetType")) + { *type = SOAP_TYPE_net__InterfaceDescriptorGetType; + return soap_in_net__InterfaceDescriptorGetType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:InterfaceDescriptorSetType")) + { *type = SOAP_TYPE_net__InterfaceDescriptorSetType; + return soap_in_net__InterfaceDescriptorSetType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:IPv4ParametersType")) + { *type = SOAP_TYPE_net__IPv4ParametersType; + return soap_in_net__IPv4ParametersType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:StaticIPv4ParametersType")) + { *type = SOAP_TYPE_net__StaticIPv4ParametersType; + return soap_in_net__StaticIPv4ParametersType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:XProfileType")) + { *type = SOAP_TYPE_xcfg__XProfileType; + return soap_in_xcfg__XProfileType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:XProfileEAPFAST_TLSType")) + { *type = SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType; + return soap_in_xcfg__XProfileEAPFAST_USCORETLSType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:XProfileEAPFAST_GTCType")) + { *type = SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType; + return soap_in_xcfg__XProfileEAPFAST_USCOREGTCType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:XProfileEAPFAST_MSCHAPv2Type")) + { *type = SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type; + return soap_in_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:XProfileEAP_GTCType")) + { *type = SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType; + return soap_in_xcfg__XProfileEAP_USCOREGTCType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:XProfilePEAP_MSCHAPv2Type")) + { *type = SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type; + return soap_in_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:XProfileTTLS_MSCHAPv2Type")) + { *type = SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type; + return soap_in_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:XProfileTLSType")) + { *type = SOAP_TYPE_xcfg__XProfileTLSType; + return soap_in_xcfg__XProfileTLSType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:ServerIdentityType")) + { *type = SOAP_TYPE_xcfg__ServerIdentityType; + return soap_in_xcfg__ServerIdentityType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:ManualPACType")) + { *type = SOAP_TYPE_xcfg__ManualPACType; + return soap_in_xcfg__ManualPACType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:CertificateNameType")) + { *type = SOAP_TYPE_xcfg__CertificateNameType; + return soap_in_xcfg__CertificateNameType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xcfg:UserCredentialsType")) + { *type = SOAP_TYPE_xcfg__UserCredentialsType; + return soap_in_xcfg__UserCredentialsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GlobalPowerPolicyType")) + { *type = SOAP_TYPE_sai__GlobalPowerPolicyType; + return soap_in_sai__GlobalPowerPolicyType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnvironmentDetectionType")) + { *type = SOAP_TYPE_sai__EnvironmentDetectionType; + return soap_in_sai__EnvironmentDetectionType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnvironmentDetectionDomainType")) + { *type = SOAP_TYPE_sai__EnvironmentDetectionDomainType; + return soap_in_sai__EnvironmentDetectionDomainType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:ProvisioningAuditRecordType")) + { *type = SOAP_TYPE_sai__ProvisioningAuditRecordType; + return soap_in_sai__ProvisioningAuditRecordType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertHashEntryType")) + { *type = SOAP_TYPE_sai__CertHashEntryType; + return soap_in_sai__CertHashEntryType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:PkiCapsType")) + { *type = SOAP_TYPE_sai__PkiCapsType; + return soap_in_sai__PkiCapsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CrlType")) + { *type = SOAP_TYPE_sai__CrlType; + return soap_in_sai__CrlType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertificateType")) + { *type = SOAP_TYPE_sai__CertificateType; + return soap_in_sai__CertificateType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:TlsOptionsType")) + { *type = SOAP_TYPE_sai__TlsOptionsType; + return soap_in_sai__TlsOptionsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:KerberosOptionsType")) + { *type = SOAP_TYPE_sai__KerberosOptionsType; + return soap_in_sai__KerberosOptionsType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:KerberosSpnType")) + { *type = SOAP_TYPE_sai__KerberosSpnType; + return soap_in_sai__KerberosSpnType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AdminAclEntryExType")) + { *type = SOAP_TYPE_sai__AdminAclEntryExType; + return soap_in_sai__AdminAclEntryExType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UserAclEntryExType")) + { *type = SOAP_TYPE_sai__UserAclEntryExType; + return soap_in_sai__UserAclEntryExType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UserEntryKerberosType")) + { *type = SOAP_TYPE_sai__UserEntryKerberosType; + return soap_in_sai__UserEntryKerberosType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UserEntryDigestType")) + { *type = SOAP_TYPE_sai__UserEntryDigestType; + return soap_in_sai__UserEntryDigestType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AmtVersion")) + { *type = SOAP_TYPE_sai__AmtVersion; + return soap_in_sai__AmtVersion(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UpdateCoreUrlKeyType")) + { *type = SOAP_TYPE_sai__UpdateCoreUrlKeyType; + return soap_in_sai__UpdateCoreUrlKeyType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertificateChainType")) + { *type = SOAP_TYPE_sai__CertificateChainType; + return soap_in_sai__CertificateChainType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:RngKeyType")) + { *type = SOAP_TYPE_sai__RngKeyType; + return soap_in_sai__RngKeyType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:RsaKeyType")) + { *type = SOAP_TYPE_sai__RsaKeyType; + return soap_in_sai__RsaKeyType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UserAclRealmListType")) + { *type = SOAP_TYPE_sai__UserAclRealmListType; + return soap_in_sai__UserAclRealmListType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UserAclEntryHandleListType")) + { *type = SOAP_TYPE_sai__UserAclEntryHandleListType; + return soap_in_sai__UserAclEntryHandleListType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AdminAclEntryType")) + { *type = SOAP_TYPE_sai__AdminAclEntryType; + return soap_in_sai__AdminAclEntryType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UserAclEntryType")) + { *type = SOAP_TYPE_sai__UserAclEntryType; + return soap_in_sai__UserAclEntryType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cstr:KeyPairType")) + { *type = SOAP_TYPE_cstr__KeyPairType; + return soap_in_cstr__KeyPairType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cstr:RSAKeyPairType")) + { *type = SOAP_TYPE_cstr__RSAKeyPairType; + return soap_in_cstr__RSAKeyPairType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cmn:NodeAddressType")) + { *type = SOAP_TYPE_cmn__NodeAddressType; + return soap_in_cmn__NodeAddressType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cmn:URLType")) + { *type = SOAP_TYPE_cmn__URLType; + return soap_in_cmn__URLType(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:base64Binary")) + { *type = SOAP_TYPE_xsd__base64Binary; + return soap_in_xsd__base64Binary(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:anyURI")) + { *type = SOAP_TYPE_xsd__anyURI; + return soap_in_xsd__anyURI(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:string")) + { *type = SOAP_TYPE_std__string; + return soap_in_std__string(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "xsd:string")) + { char **s; + *type = SOAP_TYPE_string; + s = soap_in_string(soap, NULL, NULL, NULL); + return s ? *s : NULL; + } + t = soap->tag; + if (!soap_match_tag(soap, t, "apr:AgentDescription")) + { *type = SOAP_TYPE__apr__AgentDescription; + return soap_in__apr__AgentDescription(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:PolicyName")) + { *type = SOAP_TYPE__cb__PolicyName; + return soap_in__cb__PolicyName(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:FilterName")) + { *type = SOAP_TYPE__cb__FilterName; + return soap_in__cb__FilterName(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:KerberosRealmName")) + { *type = SOAP_TYPE__sai__KerberosRealmName; + return soap_in__sai__KerberosRealmName(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SpnString")) + { *type = SOAP_TYPE__sai__SpnString; + return soap_in__sai__SpnString(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:GetWirelessSettingsResponse")) + { *type = SOAP_TYPE__wcxs__GetWirelessSettingsResponse; + return soap_in__wcxs__GetWirelessSettingsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:GetWirelessSettingsRequest")) + { *type = SOAP_TYPE__wcxs__GetWirelessSettingsRequest; + return soap_in__wcxs__GetWirelessSettingsRequest(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:GetWirelessCapabilitiesResponse")) + { *type = SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse; + return soap_in__wcxs__GetWirelessCapabilitiesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:GetWirelessCapabilitiesRequest")) + { *type = SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest; + return soap_in__wcxs__GetWirelessCapabilitiesRequest(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:EnumerateWirelessProfilesResponse")) + { *type = SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse; + return soap_in__wcxs__EnumerateWirelessProfilesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:EnumerateWirelessProfilesRequest")) + { *type = SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest; + return soap_in__wcxs__EnumerateWirelessProfilesRequest(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:UpdateWirelessProfileResponse")) + { *type = SOAP_TYPE__wcxs__UpdateWirelessProfileResponse; + return soap_in__wcxs__UpdateWirelessProfileResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:UpdateWirelessProfileRequest")) + { *type = SOAP_TYPE__wcxs__UpdateWirelessProfileRequest; + return soap_in__wcxs__UpdateWirelessProfileRequest(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:RemoveWirelessProfileResponse")) + { *type = SOAP_TYPE__wcxs__RemoveWirelessProfileResponse; + return soap_in__wcxs__RemoveWirelessProfileResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:RemoveWirelessProfileRequest")) + { *type = SOAP_TYPE__wcxs__RemoveWirelessProfileRequest; + return soap_in__wcxs__RemoveWirelessProfileRequest(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:GetWirelessProfileResponse")) + { *type = SOAP_TYPE__wcxs__GetWirelessProfileResponse; + return soap_in__wcxs__GetWirelessProfileResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:GetWirelessProfileRequest")) + { *type = SOAP_TYPE__wcxs__GetWirelessProfileRequest; + return soap_in__wcxs__GetWirelessProfileRequest(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:AddWirelessProfileResponse")) + { *type = SOAP_TYPE__wcxs__AddWirelessProfileResponse; + return soap_in__wcxs__AddWirelessProfileResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "wcxs:AddWirelessProfileRequest")) + { *type = SOAP_TYPE__wcxs__AddWirelessProfileRequest; + return soap_in__wcxs__AddWirelessProfileRequest(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:GetSystemPowerStateResponse")) + { *type = SOAP_TYPE__rci__GetSystemPowerStateResponse; + return soap_in__rci__GetSystemPowerStateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:GetSystemPowerState")) + { *type = SOAP_TYPE__rci__GetSystemPowerState; + return soap_in__rci__GetSystemPowerState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:RemoteControlResponse")) + { *type = SOAP_TYPE__rci__RemoteControlResponse; + return soap_in__rci__RemoteControlResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:RemoteControl")) + { *type = SOAP_TYPE__rci__RemoteControl; + return soap_in__rci__RemoteControl(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:GetRemoteControlCapabilitiesResponse")) + { *type = SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse; + return soap_in__rci__GetRemoteControlCapabilitiesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "rci:GetRemoteControlCapabilities")) + { *type = SOAP_TYPE__rci__GetRemoteControlCapabilities; + return soap_in__rci__GetRemoteControlCapabilities(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetIderSessionLogResponse")) + { *type = SOAP_TYPE__inf__GetIderSessionLogResponse; + return soap_in__inf__GetIderSessionLogResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetIderSessionLog")) + { *type = SOAP_TYPE__inf__GetIderSessionLog; + return soap_in__inf__GetIderSessionLog(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetSecurityParametersResponse")) + { *type = SOAP_TYPE__inf__GetSecurityParametersResponse; + return soap_in__inf__GetSecurityParametersResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetSecurityParameters")) + { *type = SOAP_TYPE__inf__GetSecurityParameters; + return soap_in__inf__GetSecurityParameters(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetNetworkStateResponse")) + { *type = SOAP_TYPE__inf__GetNetworkStateResponse; + return soap_in__inf__GetNetworkStateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetNetworkState")) + { *type = SOAP_TYPE__inf__GetNetworkState; + return soap_in__inf__GetNetworkState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetEnabledInterfacesResponse")) + { *type = SOAP_TYPE__inf__GetEnabledInterfacesResponse; + return soap_in__inf__GetEnabledInterfacesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetEnabledInterfaces")) + { *type = SOAP_TYPE__inf__GetEnabledInterfaces; + return soap_in__inf__GetEnabledInterfaces(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetPasswordModelResponse")) + { *type = SOAP_TYPE__inf__GetPasswordModelResponse; + return soap_in__inf__GetPasswordModelResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetPasswordModel")) + { *type = SOAP_TYPE__inf__GetPasswordModel; + return soap_in__inf__GetPasswordModel(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetAdminNetAclEntryStatusResponse")) + { *type = SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse; + return soap_in__inf__GetAdminNetAclEntryStatusResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetAdminNetAclEntryStatus")) + { *type = SOAP_TYPE__inf__GetAdminNetAclEntryStatus; + return soap_in__inf__GetAdminNetAclEntryStatus(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetAdminAclEntryStatusResponse")) + { *type = SOAP_TYPE__inf__GetAdminAclEntryStatusResponse; + return soap_in__inf__GetAdminAclEntryStatusResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetAdminAclEntryStatus")) + { *type = SOAP_TYPE__inf__GetAdminAclEntryStatus; + return soap_in__inf__GetAdminAclEntryStatus(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetConfigServerInfoResponse")) + { *type = SOAP_TYPE__inf__GetConfigServerInfoResponse; + return soap_in__inf__GetConfigServerInfoResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetConfigServerInfo")) + { *type = SOAP_TYPE__inf__GetConfigServerInfo; + return soap_in__inf__GetConfigServerInfo(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetHostNameResponse")) + { *type = SOAP_TYPE__inf__GetHostNameResponse; + return soap_in__inf__GetHostNameResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetHostName")) + { *type = SOAP_TYPE__inf__GetHostName; + return soap_in__inf__GetHostName(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetVlanParametersResponse")) + { *type = SOAP_TYPE__inf__GetVlanParametersResponse; + return soap_in__inf__GetVlanParametersResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetVlanParameters")) + { *type = SOAP_TYPE__inf__GetVlanParameters; + return soap_in__inf__GetVlanParameters(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetProvisioningStateResponse")) + { *type = SOAP_TYPE__inf__GetProvisioningStateResponse; + return soap_in__inf__GetProvisioningStateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetProvisioningState")) + { *type = SOAP_TYPE__inf__GetProvisioningState; + return soap_in__inf__GetProvisioningState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetProvisioningModeResponse")) + { *type = SOAP_TYPE__inf__GetProvisioningModeResponse; + return soap_in__inf__GetProvisioningModeResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetProvisioningMode")) + { *type = SOAP_TYPE__inf__GetProvisioningMode; + return soap_in__inf__GetProvisioningMode(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetCodeVersionsResponse")) + { *type = SOAP_TYPE__inf__GetCodeVersionsResponse; + return soap_in__inf__GetCodeVersionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetCodeVersions")) + { *type = SOAP_TYPE__inf__GetCodeVersions; + return soap_in__inf__GetCodeVersions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetCoreVersionResponse")) + { *type = SOAP_TYPE__inf__GetCoreVersionResponse; + return soap_in__inf__GetCoreVersionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "inf:GetCoreVersion")) + { *type = SOAP_TYPE__inf__GetCoreVersion; + return soap_in__inf__GetCoreVersion(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "str:ExecuteStorageOperationResponse")) + { *type = SOAP_TYPE__str__ExecuteStorageOperationResponse; + return soap_in__str__ExecuteStorageOperationResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "str:ExecuteStorageOperation")) + { *type = SOAP_TYPE__str__ExecuteStorageOperation; + return soap_in__str__ExecuteStorageOperation(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "tim:SetHighAccuracyTimeSynchResponse")) + { *type = SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse; + return soap_in__tim__SetHighAccuracyTimeSynchResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "tim:SetHighAccuracyTimeSynch")) + { *type = SOAP_TYPE__tim__SetHighAccuracyTimeSynch; + return soap_in__tim__SetHighAccuracyTimeSynch(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "tim:GetLowAccuracyTimeSynchResponse")) + { *type = SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse; + return soap_in__tim__GetLowAccuracyTimeSynchResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "tim:GetLowAccuracyTimeSynch")) + { *type = SOAP_TYPE__tim__GetLowAccuracyTimeSynch; + return soap_in__tim__GetLowAccuracyTimeSynch(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:GetIderSessionLogResponse")) + { *type = SOAP_TYPE__idr__GetIderSessionLogResponse; + return soap_in__idr__GetIderSessionLogResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:GetIderSessionLog")) + { *type = SOAP_TYPE__idr__GetIderSessionLog; + return soap_in__idr__GetIderSessionLog(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:GetRedirectionListenerStateResponse")) + { *type = SOAP_TYPE__idr__GetRedirectionListenerStateResponse; + return soap_in__idr__GetRedirectionListenerStateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:GetRedirectionListenerState")) + { *type = SOAP_TYPE__idr__GetRedirectionListenerState; + return soap_in__idr__GetRedirectionListenerState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:SetRedirectionListenerStateResponse")) + { *type = SOAP_TYPE__idr__SetRedirectionListenerStateResponse; + return soap_in__idr__SetRedirectionListenerStateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "idr:SetRedirectionListenerState")) + { *type = SOAP_TYPE__idr__SetRedirectionListenerState; + return soap_in__idr__SetRedirectionListenerState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apl:AgentWatchdogShutdownResponse")) + { *type = SOAP_TYPE__apl__AgentWatchdogShutdownResponse; + return soap_in__apl__AgentWatchdogShutdownResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apl:AgentWatchdogShutdown")) + { *type = SOAP_TYPE__apl__AgentWatchdogShutdown; + return soap_in__apl__AgentWatchdogShutdown(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apl:AgentWatchdogHeartbeatResponse")) + { *type = SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse; + return soap_in__apl__AgentWatchdogHeartbeatResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apl:AgentWatchdogHeartbeat")) + { *type = SOAP_TYPE__apl__AgentWatchdogHeartbeat; + return soap_in__apl__AgentWatchdogHeartbeat(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apl:AgentWatchdogRegisterResponse")) + { *type = SOAP_TYPE__apl__AgentWatchdogRegisterResponse; + return soap_in__apl__AgentWatchdogRegisterResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apl:AgentWatchdogRegister")) + { *type = SOAP_TYPE__apl__AgentWatchdogRegister; + return soap_in__apl__AgentWatchdogRegister(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogQueryCapabilitiesResponse")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse; + return soap_in__apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogQueryCapabilities")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities; + return soap_in__apr__ConsoleWatchdogQueryCapabilities(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogGetCbPolicyResponse")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse; + return soap_in__apr__ConsoleWatchdogGetCbPolicyResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogGetCbPolicy")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy; + return soap_in__apr__ConsoleWatchdogGetCbPolicy(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogSetCbPolicyResponse")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse; + return soap_in__apr__ConsoleWatchdogSetCbPolicyResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogSetCbPolicy")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy; + return soap_in__apr__ConsoleWatchdogSetCbPolicy(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogGetActionsResponse")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse; + return soap_in__apr__ConsoleWatchdogGetActionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogGetActions")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogGetActions; + return soap_in__apr__ConsoleWatchdogGetActions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogSetActionsResponse")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse; + return soap_in__apr__ConsoleWatchdogSetActionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogSetActions")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogSetActions; + return soap_in__apr__ConsoleWatchdogSetActions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogEnumerateResponse")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse; + return soap_in__apr__ConsoleWatchdogEnumerateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogEnumerate")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogEnumerate; + return soap_in__apr__ConsoleWatchdogEnumerate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogDeleteResponse")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse; + return soap_in__apr__ConsoleWatchdogDeleteResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogDelete")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogDelete; + return soap_in__apr__ConsoleWatchdogDelete(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogCreateResponse")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogCreateResponse; + return soap_in__apr__ConsoleWatchdogCreateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "apr:ConsoleWatchdogCreate")) + { *type = SOAP_TYPE__apr__ConsoleWatchdogCreate; + return soap_in__apr__ConsoleWatchdogCreate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:GetAssetDataResponse")) + { *type = SOAP_TYPE__hwa__GetAssetDataResponse; + return soap_in__hwa__GetAssetDataResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:GetAssetData")) + { *type = SOAP_TYPE__hwa__GetAssetData; + return soap_in__hwa__GetAssetData(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:EnumerateAssetTypesResponse")) + { *type = SOAP_TYPE__hwa__EnumerateAssetTypesResponse; + return soap_in__hwa__EnumerateAssetTypesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "hwa:EnumerateAssetTypes")) + { *type = SOAP_TYPE__hwa__EnumerateAssetTypes; + return soap_in__hwa__EnumerateAssetTypes(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:GetHcbStateResponse")) + { *type = SOAP_TYPE__cb__GetHcbStateResponse; + return soap_in__cb__GetHcbStateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:GetHcbState")) + { *type = SOAP_TYPE__cb__GetHcbState; + return soap_in__cb__GetHcbState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:ClearHcbStateResponse")) + { *type = SOAP_TYPE__cb__ClearHcbStateResponse; + return soap_in__cb__ClearHcbStateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:ClearHcbState")) + { *type = SOAP_TYPE__cb__ClearHcbState; + return soap_in__cb__ClearHcbState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:GetHcbOptionsResponse")) + { *type = SOAP_TYPE__cb__GetHcbOptionsResponse; + return soap_in__cb__GetHcbOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:GetHcbOptions")) + { *type = SOAP_TYPE__cb__GetHcbOptions; + return soap_in__cb__GetHcbOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:SetHcbOptionsResponse")) + { *type = SOAP_TYPE__cb__SetHcbOptionsResponse; + return soap_in__cb__SetHcbOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:SetHcbOptions")) + { *type = SOAP_TYPE__cb__SetHcbOptions; + return soap_in__cb__SetHcbOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbQueryCapabilitiesResponse")) + { *type = SOAP_TYPE__cb__CbQueryCapabilitiesResponse; + return soap_in__cb__CbQueryCapabilitiesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbQueryCapabilities")) + { *type = SOAP_TYPE__cb__CbQueryCapabilities; + return soap_in__cb__CbQueryCapabilities(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbFilterEnumerateResponse")) + { *type = SOAP_TYPE__cb__CbFilterEnumerateResponse; + return soap_in__cb__CbFilterEnumerateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbFilterEnumerate")) + { *type = SOAP_TYPE__cb__CbFilterEnumerate; + return soap_in__cb__CbFilterEnumerate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbFilterDeleteResponse")) + { *type = SOAP_TYPE__cb__CbFilterDeleteResponse; + return soap_in__cb__CbFilterDeleteResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbFilterDelete")) + { *type = SOAP_TYPE__cb__CbFilterDelete; + return soap_in__cb__CbFilterDelete(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbFilterGetResponse")) + { *type = SOAP_TYPE__cb__CbFilterGetResponse; + return soap_in__cb__CbFilterGetResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbFilterGet")) + { *type = SOAP_TYPE__cb__CbFilterGet; + return soap_in__cb__CbFilterGet(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbFilterCreateResponse")) + { *type = SOAP_TYPE__cb__CbFilterCreateResponse; + return soap_in__cb__CbFilterCreateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbFilterCreate")) + { *type = SOAP_TYPE__cb__CbFilterCreate; + return soap_in__cb__CbFilterCreate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyGetActiveStatisticsResponse")) + { *type = SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse; + return soap_in__cb__CbPolicyGetActiveStatisticsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyGetActiveStatistics")) + { *type = SOAP_TYPE__cb__CbPolicyGetActiveStatistics; + return soap_in__cb__CbPolicyGetActiveStatistics(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyGetEnabledResponse")) + { *type = SOAP_TYPE__cb__CbPolicyGetEnabledResponse; + return soap_in__cb__CbPolicyGetEnabledResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyGetEnabled")) + { *type = SOAP_TYPE__cb__CbPolicyGetEnabled; + return soap_in__cb__CbPolicyGetEnabled(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyDisableResponse")) + { *type = SOAP_TYPE__cb__CbPolicyDisableResponse; + return soap_in__cb__CbPolicyDisableResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyDisable")) + { *type = SOAP_TYPE__cb__CbPolicyDisable; + return soap_in__cb__CbPolicyDisable(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyEnableResponse")) + { *type = SOAP_TYPE__cb__CbPolicyEnableResponse; + return soap_in__cb__CbPolicyEnableResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyEnable")) + { *type = SOAP_TYPE__cb__CbPolicyEnable; + return soap_in__cb__CbPolicyEnable(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyEnumerateResponse")) + { *type = SOAP_TYPE__cb__CbPolicyEnumerateResponse; + return soap_in__cb__CbPolicyEnumerateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyEnumerate")) + { *type = SOAP_TYPE__cb__CbPolicyEnumerate; + return soap_in__cb__CbPolicyEnumerate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyDeleteResponse")) + { *type = SOAP_TYPE__cb__CbPolicyDeleteResponse; + return soap_in__cb__CbPolicyDeleteResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyDelete")) + { *type = SOAP_TYPE__cb__CbPolicyDelete; + return soap_in__cb__CbPolicyDelete(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyGetResponse")) + { *type = SOAP_TYPE__cb__CbPolicyGetResponse; + return soap_in__cb__CbPolicyGetResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyGet")) + { *type = SOAP_TYPE__cb__CbPolicyGet; + return soap_in__cb__CbPolicyGet(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyCreateResponse")) + { *type = SOAP_TYPE__cb__CbPolicyCreateResponse; + return soap_in__cb__CbPolicyCreateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "cb:CbPolicyCreate")) + { *type = SOAP_TYPE__cb__CbPolicyCreate; + return soap_in__cb__CbPolicyCreate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetGeneralAlertSubscriptionResponse")) + { *type = SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse; + return soap_in__emi__GetGeneralAlertSubscriptionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetGeneralAlertSubscription")) + { *type = SOAP_TYPE__emi__GetGeneralAlertSubscription; + return soap_in__emi__GetGeneralAlertSubscription(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateGeneralAlertSubscriptionsResponse")) + { *type = SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse; + return soap_in__emi__EnumerateGeneralAlertSubscriptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateGeneralAlertSubscriptions")) + { *type = SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions; + return soap_in__emi__EnumerateGeneralAlertSubscriptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SubscribeForGeneralAlertResponse")) + { *type = SOAP_TYPE__emi__SubscribeForGeneralAlertResponse; + return soap_in__emi__SubscribeForGeneralAlertResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SubscribeForGeneralAlert")) + { *type = SOAP_TYPE__emi__SubscribeForGeneralAlert; + return soap_in__emi__SubscribeForGeneralAlert(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:CancelAlertSubscriptionResponse")) + { *type = SOAP_TYPE__emi__CancelAlertSubscriptionResponse; + return soap_in__emi__CancelAlertSubscriptionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:CancelAlertSubscription")) + { *type = SOAP_TYPE__emi__CancelAlertSubscription; + return soap_in__emi__CancelAlertSubscription(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetSensorAttributesResponse")) + { *type = SOAP_TYPE__emi__GetSensorAttributesResponse; + return soap_in__emi__GetSensorAttributesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetSensorAttributes")) + { *type = SOAP_TYPE__emi__GetSensorAttributes; + return soap_in__emi__GetSensorAttributes(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateSensorsResponse")) + { *type = SOAP_TYPE__emi__EnumerateSensorsResponse; + return soap_in__emi__EnumerateSensorsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateSensors")) + { *type = SOAP_TYPE__emi__EnumerateSensors; + return soap_in__emi__EnumerateSensors(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetEventLogTimestampClockResponse")) + { *type = SOAP_TYPE__emi__GetEventLogTimestampClockResponse; + return soap_in__emi__GetEventLogTimestampClockResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetEventLogTimestampClock")) + { *type = SOAP_TYPE__emi__GetEventLogTimestampClock; + return soap_in__emi__GetEventLogTimestampClock(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SetEventLogTimestampClockResponse")) + { *type = SOAP_TYPE__emi__SetEventLogTimestampClockResponse; + return soap_in__emi__SetEventLogTimestampClockResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SetEventLogTimestampClock")) + { *type = SOAP_TYPE__emi__SetEventLogTimestampClock; + return soap_in__emi__SetEventLogTimestampClock(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:FreezeEventLogResponse")) + { *type = SOAP_TYPE__emi__FreezeEventLogResponse; + return soap_in__emi__FreezeEventLogResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:FreezeEventLog")) + { *type = SOAP_TYPE__emi__FreezeEventLog; + return soap_in__emi__FreezeEventLog(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:ClearEventLogResponse")) + { *type = SOAP_TYPE__emi__ClearEventLogResponse; + return soap_in__emi__ClearEventLogResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:ClearEventLog")) + { *type = SOAP_TYPE__emi__ClearEventLog; + return soap_in__emi__ClearEventLog(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetEventLogStatusResponse")) + { *type = SOAP_TYPE__emi__GetEventLogStatusResponse; + return soap_in__emi__GetEventLogStatusResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetEventLogStatus")) + { *type = SOAP_TYPE__emi__GetEventLogStatus; + return soap_in__emi__GetEventLogStatus(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:ReadEventLogRecordsResponse")) + { *type = SOAP_TYPE__emi__ReadEventLogRecordsResponse; + return soap_in__emi__ReadEventLogRecordsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:ReadEventLogRecords")) + { *type = SOAP_TYPE__emi__ReadEventLogRecords; + return soap_in__emi__ReadEventLogRecords(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:RemoveEventFilterResponse")) + { *type = SOAP_TYPE__emi__RemoveEventFilterResponse; + return soap_in__emi__RemoveEventFilterResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:RemoveEventFilter")) + { *type = SOAP_TYPE__emi__RemoveEventFilter; + return soap_in__emi__RemoveEventFilter(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:UpdateEventFilterResponse")) + { *type = SOAP_TYPE__emi__UpdateEventFilterResponse; + return soap_in__emi__UpdateEventFilterResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:UpdateEventFilter")) + { *type = SOAP_TYPE__emi__UpdateEventFilter; + return soap_in__emi__UpdateEventFilter(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetEventFilterResponse")) + { *type = SOAP_TYPE__emi__GetEventFilterResponse; + return soap_in__emi__GetEventFilterResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetEventFilter")) + { *type = SOAP_TYPE__emi__GetEventFilter; + return soap_in__emi__GetEventFilter(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateEventFiltersResponse")) + { *type = SOAP_TYPE__emi__EnumerateEventFiltersResponse; + return soap_in__emi__EnumerateEventFiltersResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateEventFilters")) + { *type = SOAP_TYPE__emi__EnumerateEventFilters; + return soap_in__emi__EnumerateEventFilters(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AddEventFilterResponse")) + { *type = SOAP_TYPE__emi__AddEventFilterResponse; + return soap_in__emi__AddEventFilterResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:AddEventFilter")) + { *type = SOAP_TYPE__emi__AddEventFilter; + return soap_in__emi__AddEventFilter(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetAlertCommunityStringResponse")) + { *type = SOAP_TYPE__emi__GetAlertCommunityStringResponse; + return soap_in__emi__GetAlertCommunityStringResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetAlertCommunityString")) + { *type = SOAP_TYPE__emi__GetAlertCommunityString; + return soap_in__emi__GetAlertCommunityString(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SetAlertCommunityStringResponse")) + { *type = SOAP_TYPE__emi__SetAlertCommunityStringResponse; + return soap_in__emi__SetAlertCommunityStringResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SetAlertCommunityString")) + { *type = SOAP_TYPE__emi__SetAlertCommunityString; + return soap_in__emi__SetAlertCommunityString(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateAlertPoliciesResponse")) + { *type = SOAP_TYPE__emi__EnumerateAlertPoliciesResponse; + return soap_in__emi__EnumerateAlertPoliciesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateAlertPolicies")) + { *type = SOAP_TYPE__emi__EnumerateAlertPolicies; + return soap_in__emi__EnumerateAlertPolicies(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetAlertSubscriptionResponse")) + { *type = SOAP_TYPE__emi__GetAlertSubscriptionResponse; + return soap_in__emi__GetAlertSubscriptionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:GetAlertSubscription")) + { *type = SOAP_TYPE__emi__GetAlertSubscription; + return soap_in__emi__GetAlertSubscription(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateAlertSubscriptionsResponse")) + { *type = SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse; + return soap_in__emi__EnumerateAlertSubscriptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:EnumerateAlertSubscriptions")) + { *type = SOAP_TYPE__emi__EnumerateAlertSubscriptions; + return soap_in__emi__EnumerateAlertSubscriptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SubscribeForAlertResponse")) + { *type = SOAP_TYPE__emi__SubscribeForAlertResponse; + return soap_in__emi__SubscribeForAlertResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "emi:SubscribeForAlert")) + { *type = SOAP_TYPE__emi__SubscribeForAlert; + return soap_in__emi__SubscribeForAlert(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:RemoveStorageFpaclEntryResponse")) + { *type = SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse; + return soap_in__stra__RemoveStorageFpaclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:RemoveStorageFpaclEntry")) + { *type = SOAP_TYPE__stra__RemoveStorageFpaclEntry; + return soap_in__stra__RemoveStorageFpaclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:UpdateStorageFpaclEntryResponse")) + { *type = SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse; + return soap_in__stra__UpdateStorageFpaclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:UpdateStorageFpaclEntry")) + { *type = SOAP_TYPE__stra__UpdateStorageFpaclEntry; + return soap_in__stra__UpdateStorageFpaclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:GetStorageAllocEntryResponse")) + { *type = SOAP_TYPE__stra__GetStorageAllocEntryResponse; + return soap_in__stra__GetStorageAllocEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:GetStorageAllocEntry")) + { *type = SOAP_TYPE__stra__GetStorageAllocEntry; + return soap_in__stra__GetStorageAllocEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:EnumerateStorageAllocEntriesResponse")) + { *type = SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse; + return soap_in__stra__EnumerateStorageAllocEntriesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:EnumerateStorageAllocEntries")) + { *type = SOAP_TYPE__stra__EnumerateStorageAllocEntries; + return soap_in__stra__EnumerateStorageAllocEntries(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AddStorageFpaclEntryResponse")) + { *type = SOAP_TYPE__stra__AddStorageFpaclEntryResponse; + return soap_in__stra__AddStorageFpaclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AddStorageFpaclEntry")) + { *type = SOAP_TYPE__stra__AddStorageFpaclEntry; + return soap_in__stra__AddStorageFpaclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:RemoveStorageEaclEntryResponse")) + { *type = SOAP_TYPE__stra__RemoveStorageEaclEntryResponse; + return soap_in__stra__RemoveStorageEaclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:RemoveStorageEaclEntry")) + { *type = SOAP_TYPE__stra__RemoveStorageEaclEntry; + return soap_in__stra__RemoveStorageEaclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:GetStorageEaclEntryResponse")) + { *type = SOAP_TYPE__stra__GetStorageEaclEntryResponse; + return soap_in__stra__GetStorageEaclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:GetStorageEaclEntry")) + { *type = SOAP_TYPE__stra__GetStorageEaclEntry; + return soap_in__stra__GetStorageEaclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:EnumerateStorageEaclEntriesResponse")) + { *type = SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse; + return soap_in__stra__EnumerateStorageEaclEntriesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:EnumerateStorageEaclEntries")) + { *type = SOAP_TYPE__stra__EnumerateStorageEaclEntries; + return soap_in__stra__EnumerateStorageEaclEntries(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AddStorageEaclEntryResponse")) + { *type = SOAP_TYPE__stra__AddStorageEaclEntryResponse; + return soap_in__stra__AddStorageEaclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AddStorageEaclEntry")) + { *type = SOAP_TYPE__stra__AddStorageEaclEntry; + return soap_in__stra__AddStorageEaclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AdminRemoveApplicationResponse")) + { *type = SOAP_TYPE__stra__AdminRemoveApplicationResponse; + return soap_in__stra__AdminRemoveApplicationResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AdminRemoveApplication")) + { *type = SOAP_TYPE__stra__AdminRemoveApplication; + return soap_in__stra__AdminRemoveApplication(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AdminGetApplicationAttributesResponse")) + { *type = SOAP_TYPE__stra__AdminGetApplicationAttributesResponse; + return soap_in__stra__AdminGetApplicationAttributesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AdminGetApplicationAttributes")) + { *type = SOAP_TYPE__stra__AdminGetApplicationAttributes; + return soap_in__stra__AdminGetApplicationAttributes(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AdminGetRegisteredApplicationsResponse")) + { *type = SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse; + return soap_in__stra__AdminGetRegisteredApplicationsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:AdminGetRegisteredApplications")) + { *type = SOAP_TYPE__stra__AdminGetRegisteredApplications; + return soap_in__stra__AdminGetRegisteredApplications(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:SetGlobalStorageAttributesResponse")) + { *type = SOAP_TYPE__stra__SetGlobalStorageAttributesResponse; + return soap_in__stra__SetGlobalStorageAttributesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:SetGlobalStorageAttributes")) + { *type = SOAP_TYPE__stra__SetGlobalStorageAttributes; + return soap_in__stra__SetGlobalStorageAttributes(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:GetGlobalStorageAttributesResponse")) + { *type = SOAP_TYPE__stra__GetGlobalStorageAttributesResponse; + return soap_in__stra__GetGlobalStorageAttributesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "stra:GetGlobalStorageAttributes")) + { *type = SOAP_TYPE__stra__GetGlobalStorageAttributes; + return soap_in__stra__GetGlobalStorageAttributes(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Get8021XPxeTimeoutResponse")) + { *type = SOAP_TYPE__net__Get8021XPxeTimeoutResponse; + return soap_in__net__Get8021XPxeTimeoutResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Get8021XPxeTimeout")) + { *type = SOAP_TYPE__net__Get8021XPxeTimeout; + return soap_in__net__Get8021XPxeTimeout(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Set8021XPxeTimeoutResponse")) + { *type = SOAP_TYPE__net__Set8021XPxeTimeoutResponse; + return soap_in__net__Set8021XPxeTimeoutResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Set8021XPxeTimeout")) + { *type = SOAP_TYPE__net__Set8021XPxeTimeout; + return soap_in__net__Set8021XPxeTimeout(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Get8021XActiveS0Response")) + { *type = SOAP_TYPE__net__Get8021XActiveS0Response; + return soap_in__net__Get8021XActiveS0Response(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Get8021XActiveS0")) + { *type = SOAP_TYPE__net__Get8021XActiveS0; + return soap_in__net__Get8021XActiveS0(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Set8021XActiveS0Response")) + { *type = SOAP_TYPE__net__Set8021XActiveS0Response; + return soap_in__net__Set8021XActiveS0Response(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Set8021XActiveS0")) + { *type = SOAP_TYPE__net__Set8021XActiveS0; + return soap_in__net__Set8021XActiveS0(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Set8021XWiredProfileResponse")) + { *type = SOAP_TYPE__net__Set8021XWiredProfileResponse; + return soap_in__net__Set8021XWiredProfileResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Set8021XWiredProfile")) + { *type = SOAP_TYPE__net__Set8021XWiredProfile; + return soap_in__net__Set8021XWiredProfile(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Get8021XWiredProfileResponse")) + { *type = SOAP_TYPE__net__Get8021XWiredProfileResponse; + return soap_in__net__Get8021XWiredProfileResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:Get8021XWiredProfile")) + { *type = SOAP_TYPE__net__Get8021XWiredProfile; + return soap_in__net__Get8021XWiredProfile(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetInterfaceSettingsResponse")) + { *type = SOAP_TYPE__net__SetInterfaceSettingsResponse; + return soap_in__net__SetInterfaceSettingsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetInterfaceSettings")) + { *type = SOAP_TYPE__net__SetInterfaceSettings; + return soap_in__net__SetInterfaceSettings(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetInterfaceSettingsResponse")) + { *type = SOAP_TYPE__net__GetInterfaceSettingsResponse; + return soap_in__net__GetInterfaceSettingsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetInterfaceSettings")) + { *type = SOAP_TYPE__net__GetInterfaceSettings; + return soap_in__net__GetInterfaceSettings(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:EnumerateInterfacesResponse")) + { *type = SOAP_TYPE__net__EnumerateInterfacesResponse; + return soap_in__net__EnumerateInterfacesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:EnumerateInterfaces")) + { *type = SOAP_TYPE__net__EnumerateInterfaces; + return soap_in__net__EnumerateInterfaces(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetPingResponseResponse")) + { *type = SOAP_TYPE__net__GetPingResponseResponse; + return soap_in__net__GetPingResponseResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetPingResponse")) + { *type = SOAP_TYPE__net__GetPingResponse; + return soap_in__net__GetPingResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetPingResponseResponse")) + { *type = SOAP_TYPE__net__SetPingResponseResponse; + return soap_in__net__SetPingResponseResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetPingResponse")) + { *type = SOAP_TYPE__net__SetPingResponse; + return soap_in__net__SetPingResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetVlanParametersResponse")) + { *type = SOAP_TYPE__net__GetVlanParametersResponse; + return soap_in__net__GetVlanParametersResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetVlanParameters")) + { *type = SOAP_TYPE__net__GetVlanParameters; + return soap_in__net__GetVlanParameters(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetVlanParametersResponse")) + { *type = SOAP_TYPE__net__SetVlanParametersResponse; + return soap_in__net__SetVlanParametersResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetVlanParameters")) + { *type = SOAP_TYPE__net__SetVlanParameters; + return soap_in__net__SetVlanParameters(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetTcpIpParametersResponse")) + { *type = SOAP_TYPE__net__GetTcpIpParametersResponse; + return soap_in__net__GetTcpIpParametersResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetTcpIpParameters")) + { *type = SOAP_TYPE__net__GetTcpIpParameters; + return soap_in__net__GetTcpIpParameters(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetTcpIpParametersResponse")) + { *type = SOAP_TYPE__net__SetTcpIpParametersResponse; + return soap_in__net__SetTcpIpParametersResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetTcpIpParameters")) + { *type = SOAP_TYPE__net__SetTcpIpParameters; + return soap_in__net__SetTcpIpParameters(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetDomainNameResponse")) + { *type = SOAP_TYPE__net__GetDomainNameResponse; + return soap_in__net__GetDomainNameResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetDomainName")) + { *type = SOAP_TYPE__net__GetDomainName; + return soap_in__net__GetDomainName(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetDomainNameResponse")) + { *type = SOAP_TYPE__net__SetDomainNameResponse; + return soap_in__net__SetDomainNameResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetDomainName")) + { *type = SOAP_TYPE__net__SetDomainName; + return soap_in__net__SetDomainName(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetHostNameResponse")) + { *type = SOAP_TYPE__net__GetHostNameResponse; + return soap_in__net__GetHostNameResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:GetHostName")) + { *type = SOAP_TYPE__net__GetHostName; + return soap_in__net__GetHostName(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetHostNameResponse")) + { *type = SOAP_TYPE__net__SetHostNameResponse; + return soap_in__net__SetHostNameResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "net:SetHostName")) + { *type = SOAP_TYPE__net__SetHostName; + return soap_in__net__SetHostName(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetAclEnabledStateResponse")) + { *type = SOAP_TYPE__sai__GetAclEnabledStateResponse; + return soap_in__sai__GetAclEnabledStateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetAclEnabledState")) + { *type = SOAP_TYPE__sai__GetAclEnabledState; + return soap_in__sai__GetAclEnabledState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetAclEnabledStateResponse")) + { *type = SOAP_TYPE__sai__SetAclEnabledStateResponse; + return soap_in__sai__SetAclEnabledStateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetAclEnabledState")) + { *type = SOAP_TYPE__sai__SetAclEnabledState; + return soap_in__sai__SetAclEnabledState(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetConfigurationServerFQDNResponse")) + { *type = SOAP_TYPE__sai__GetConfigurationServerFQDNResponse; + return soap_in__sai__GetConfigurationServerFQDNResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetConfigurationServerFQDN")) + { *type = SOAP_TYPE__sai__GetConfigurationServerFQDN; + return soap_in__sai__GetConfigurationServerFQDN(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetConfigurationServerFQDNResponse")) + { *type = SOAP_TYPE__sai__SetConfigurationServerFQDNResponse; + return soap_in__sai__SetConfigurationServerFQDNResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetConfigurationServerFQDN")) + { *type = SOAP_TYPE__sai__SetConfigurationServerFQDN; + return soap_in__sai__SetConfigurationServerFQDN(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnableVpnRoutingResponse")) + { *type = SOAP_TYPE__sai__EnableVpnRoutingResponse; + return soap_in__sai__EnableVpnRoutingResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnableVpnRouting")) + { *type = SOAP_TYPE__sai__EnableVpnRouting; + return soap_in__sai__EnableVpnRouting(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTLSCredentialsResponse")) + { *type = SOAP_TYPE__sai__GetTLSCredentialsResponse; + return soap_in__sai__GetTLSCredentialsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTLSCredentials")) + { *type = SOAP_TYPE__sai__GetTLSCredentials; + return soap_in__sai__GetTLSCredentials(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTLSCredentialsResponse")) + { *type = SOAP_TYPE__sai__SetTLSCredentialsResponse; + return soap_in__sai__SetTLSCredentialsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTLSCredentials")) + { *type = SOAP_TYPE__sai__SetTLSCredentials; + return soap_in__sai__SetTLSCredentials(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreUpdateCertificateResponse")) + { *type = SOAP_TYPE__sai__CertStoreUpdateCertificateResponse; + return soap_in__sai__CertStoreUpdateCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreUpdateCertificate")) + { *type = SOAP_TYPE__sai__CertStoreUpdateCertificate; + return soap_in__sai__CertStoreUpdateCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreGetPKCS10RequestResponse")) + { *type = SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse; + return soap_in__sai__CertStoreGetPKCS10RequestResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreGetPKCS10Request")) + { *type = SOAP_TYPE__sai__CertStoreGetPKCS10Request; + return soap_in__sai__CertStoreGetPKCS10Request(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreRemoveCertificateResponse")) + { *type = SOAP_TYPE__sai__CertStoreRemoveCertificateResponse; + return soap_in__sai__CertStoreRemoveCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreRemoveCertificate")) + { *type = SOAP_TYPE__sai__CertStoreRemoveCertificate; + return soap_in__sai__CertStoreRemoveCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreGetCertificateResponse")) + { *type = SOAP_TYPE__sai__CertStoreGetCertificateResponse; + return soap_in__sai__CertStoreGetCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreGetCertificate")) + { *type = SOAP_TYPE__sai__CertStoreGetCertificate; + return soap_in__sai__CertStoreGetCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreEnumerateCertificatesResponse")) + { *type = SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse; + return soap_in__sai__CertStoreEnumerateCertificatesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreEnumerateCertificates")) + { *type = SOAP_TYPE__sai__CertStoreEnumerateCertificates; + return soap_in__sai__CertStoreEnumerateCertificates(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreAddCertificateResponse")) + { *type = SOAP_TYPE__sai__CertStoreAddCertificateResponse; + return soap_in__sai__CertStoreAddCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreAddCertificate")) + { *type = SOAP_TYPE__sai__CertStoreAddCertificate; + return soap_in__sai__CertStoreAddCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreRemoveKeyResponse")) + { *type = SOAP_TYPE__sai__CertStoreRemoveKeyResponse; + return soap_in__sai__CertStoreRemoveKeyResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreRemoveKey")) + { *type = SOAP_TYPE__sai__CertStoreRemoveKey; + return soap_in__sai__CertStoreRemoveKey(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreGetKeyResponse")) + { *type = SOAP_TYPE__sai__CertStoreGetKeyResponse; + return soap_in__sai__CertStoreGetKeyResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreGetKey")) + { *type = SOAP_TYPE__sai__CertStoreGetKey; + return soap_in__sai__CertStoreGetKey(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreEnumerateKeysResponse")) + { *type = SOAP_TYPE__sai__CertStoreEnumerateKeysResponse; + return soap_in__sai__CertStoreEnumerateKeysResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreEnumerateKeys")) + { *type = SOAP_TYPE__sai__CertStoreEnumerateKeys; + return soap_in__sai__CertStoreEnumerateKeys(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreAddKeyResponse")) + { *type = SOAP_TYPE__sai__CertStoreAddKeyResponse; + return soap_in__sai__CertStoreAddKeyResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CertStoreAddKey")) + { *type = SOAP_TYPE__sai__CertStoreAddKey; + return soap_in__sai__CertStoreAddKey(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetGlobalPowerPolicyResponse")) + { *type = SOAP_TYPE__sai__GetGlobalPowerPolicyResponse; + return soap_in__sai__GetGlobalPowerPolicyResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetGlobalPowerPolicy")) + { *type = SOAP_TYPE__sai__GetGlobalPowerPolicy; + return soap_in__sai__GetGlobalPowerPolicy(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetGlobalPowerPolicyResponse")) + { *type = SOAP_TYPE__sai__SetGlobalPowerPolicyResponse; + return soap_in__sai__SetGlobalPowerPolicyResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetGlobalPowerPolicy")) + { *type = SOAP_TYPE__sai__SetGlobalPowerPolicy; + return soap_in__sai__SetGlobalPowerPolicy(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetActivePowerPackageResponse")) + { *type = SOAP_TYPE__sai__SetActivePowerPackageResponse; + return soap_in__sai__SetActivePowerPackageResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetActivePowerPackage")) + { *type = SOAP_TYPE__sai__SetActivePowerPackage; + return soap_in__sai__SetActivePowerPackage(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetPowerPackageResponse")) + { *type = SOAP_TYPE__sai__GetPowerPackageResponse; + return soap_in__sai__GetPowerPackageResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetPowerPackage")) + { *type = SOAP_TYPE__sai__GetPowerPackage; + return soap_in__sai__GetPowerPackage(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetActivePowerPackageResponse")) + { *type = SOAP_TYPE__sai__GetActivePowerPackageResponse; + return soap_in__sai__GetActivePowerPackageResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetActivePowerPackage")) + { *type = SOAP_TYPE__sai__GetActivePowerPackage; + return soap_in__sai__GetActivePowerPackage(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnumeratePowerPackagesResponse")) + { *type = SOAP_TYPE__sai__EnumeratePowerPackagesResponse; + return soap_in__sai__EnumeratePowerPackagesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnumeratePowerPackages")) + { *type = SOAP_TYPE__sai__EnumeratePowerPackages; + return soap_in__sai__EnumeratePowerPackages(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetEnvironmentDetectionResponse")) + { *type = SOAP_TYPE__sai__GetEnvironmentDetectionResponse; + return soap_in__sai__GetEnvironmentDetectionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetEnvironmentDetection")) + { *type = SOAP_TYPE__sai__GetEnvironmentDetection; + return soap_in__sai__GetEnvironmentDetection(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetEnvironmentDetectionResponse")) + { *type = SOAP_TYPE__sai__SetEnvironmentDetectionResponse; + return soap_in__sai__SetEnvironmentDetectionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetEnvironmentDetection")) + { *type = SOAP_TYPE__sai__SetEnvironmentDetection; + return soap_in__sai__SetEnvironmentDetection(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetRealmAuthOptionsResponse")) + { *type = SOAP_TYPE__sai__SetRealmAuthOptionsResponse; + return soap_in__sai__SetRealmAuthOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetRealmAuthOptions")) + { *type = SOAP_TYPE__sai__SetRealmAuthOptions; + return soap_in__sai__SetRealmAuthOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetRealmAuthOptionsResponse")) + { *type = SOAP_TYPE__sai__GetRealmAuthOptionsResponse; + return soap_in__sai__GetRealmAuthOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetRealmAuthOptions")) + { *type = SOAP_TYPE__sai__GetRealmAuthOptions; + return soap_in__sai__GetRealmAuthOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:ExtendProvisioningPeriodResponse")) + { *type = SOAP_TYPE__sai__ExtendProvisioningPeriodResponse; + return soap_in__sai__ExtendProvisioningPeriodResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:ExtendProvisioningPeriod")) + { *type = SOAP_TYPE__sai__ExtendProvisioningPeriod; + return soap_in__sai__ExtendProvisioningPeriod(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetProvisioningPIDResponse")) + { *type = SOAP_TYPE__sai__GetProvisioningPIDResponse; + return soap_in__sai__GetProvisioningPIDResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetProvisioningPID")) + { *type = SOAP_TYPE__sai__GetProvisioningPID; + return soap_in__sai__GetProvisioningPID(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetProvisioningAuditRecordResponse")) + { *type = SOAP_TYPE__sai__GetProvisioningAuditRecordResponse; + return soap_in__sai__GetProvisioningAuditRecordResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetProvisioningAuditRecord")) + { *type = SOAP_TYPE__sai__GetProvisioningAuditRecord; + return soap_in__sai__GetProvisioningAuditRecord(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetZeroTouchConfigurationModeResponse")) + { *type = SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse; + return soap_in__sai__SetZeroTouchConfigurationModeResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetZeroTouchConfigurationMode")) + { *type = SOAP_TYPE__sai__SetZeroTouchConfigurationMode; + return soap_in__sai__SetZeroTouchConfigurationMode(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetZeroTouchConfigurationModeResponse")) + { *type = SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse; + return soap_in__sai__GetZeroTouchConfigurationModeResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetZeroTouchConfigurationMode")) + { *type = SOAP_TYPE__sai__GetZeroTouchConfigurationMode; + return soap_in__sai__GetZeroTouchConfigurationMode(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnableCertificateHashEntryResponse")) + { *type = SOAP_TYPE__sai__EnableCertificateHashEntryResponse; + return soap_in__sai__EnableCertificateHashEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnableCertificateHashEntry")) + { *type = SOAP_TYPE__sai__EnableCertificateHashEntry; + return soap_in__sai__EnableCertificateHashEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:DeleteCertificateHashEntryResponse")) + { *type = SOAP_TYPE__sai__DeleteCertificateHashEntryResponse; + return soap_in__sai__DeleteCertificateHashEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:DeleteCertificateHashEntry")) + { *type = SOAP_TYPE__sai__DeleteCertificateHashEntry; + return soap_in__sai__DeleteCertificateHashEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AddCertificateHashEntryResponse")) + { *type = SOAP_TYPE__sai__AddCertificateHashEntryResponse; + return soap_in__sai__AddCertificateHashEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AddCertificateHashEntry")) + { *type = SOAP_TYPE__sai__AddCertificateHashEntry; + return soap_in__sai__AddCertificateHashEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetCertificateHashEntryResponse")) + { *type = SOAP_TYPE__sai__GetCertificateHashEntryResponse; + return soap_in__sai__GetCertificateHashEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetCertificateHashEntry")) + { *type = SOAP_TYPE__sai__GetCertificateHashEntry; + return soap_in__sai__GetCertificateHashEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnumerateCertificateHashEntriesResponse")) + { *type = SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse; + return soap_in__sai__EnumerateCertificateHashEntriesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnumerateCertificateHashEntries")) + { *type = SOAP_TYPE__sai__EnumerateCertificateHashEntries; + return soap_in__sai__EnumerateCertificateHashEntries(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetProvisioningServerOTPResponse")) + { *type = SOAP_TYPE__sai__GetProvisioningServerOTPResponse; + return soap_in__sai__GetProvisioningServerOTPResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetProvisioningServerOTP")) + { *type = SOAP_TYPE__sai__GetProvisioningServerOTP; + return soap_in__sai__GetProvisioningServerOTP(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetProvisioningServerOTPResponse")) + { *type = SOAP_TYPE__sai__SetProvisioningServerOTPResponse; + return soap_in__sai__SetProvisioningServerOTPResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetProvisioningServerOTP")) + { *type = SOAP_TYPE__sai__SetProvisioningServerOTP; + return soap_in__sai__SetProvisioningServerOTP(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetMEBxPasswordResponse")) + { *type = SOAP_TYPE__sai__SetMEBxPasswordResponse; + return soap_in__sai__SetMEBxPasswordResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetMEBxPassword")) + { *type = SOAP_TYPE__sai__SetMEBxPassword; + return soap_in__sai__SetMEBxPassword(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:PartialUnprovisionResponse")) + { *type = SOAP_TYPE__sai__PartialUnprovisionResponse; + return soap_in__sai__PartialUnprovisionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:PartialUnprovision")) + { *type = SOAP_TYPE__sai__PartialUnprovision; + return soap_in__sai__PartialUnprovision(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTLSPSKResponse")) + { *type = SOAP_TYPE__sai__SetTLSPSKResponse; + return soap_in__sai__SetTLSPSKResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTLSPSK")) + { *type = SOAP_TYPE__sai__SetTLSPSK; + return soap_in__sai__SetTLSPSK(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetPowerSavingOptionsResponse")) + { *type = SOAP_TYPE__sai__GetPowerSavingOptionsResponse; + return soap_in__sai__GetPowerSavingOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetPowerSavingOptions")) + { *type = SOAP_TYPE__sai__GetPowerSavingOptions; + return soap_in__sai__GetPowerSavingOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetPowerSavingOptionsResponse")) + { *type = SOAP_TYPE__sai__SetPowerSavingOptionsResponse; + return soap_in__sai__SetPowerSavingOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetPowerSavingOptions")) + { *type = SOAP_TYPE__sai__SetPowerSavingOptions; + return soap_in__sai__SetPowerSavingOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetPkiCapabilitiesResponse")) + { *type = SOAP_TYPE__sai__GetPkiCapabilitiesResponse; + return soap_in__sai__GetPkiCapabilitiesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetPkiCapabilities")) + { *type = SOAP_TYPE__sai__GetPkiCapabilities; + return soap_in__sai__GetPkiCapabilities(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetServerCertificateReqResponse")) + { *type = SOAP_TYPE__sai__GetServerCertificateReqResponse; + return soap_in__sai__GetServerCertificateReqResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetServerCertificateReq")) + { *type = SOAP_TYPE__sai__GetServerCertificateReq; + return soap_in__sai__GetServerCertificateReq(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetCRLResponse")) + { *type = SOAP_TYPE__sai__GetCRLResponse; + return soap_in__sai__GetCRLResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetCRL")) + { *type = SOAP_TYPE__sai__GetCRL; + return soap_in__sai__GetCRL(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetCRLResponse")) + { *type = SOAP_TYPE__sai__SetCRLResponse; + return soap_in__sai__SetCRLResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetCRL")) + { *type = SOAP_TYPE__sai__SetCRL; + return soap_in__sai__SetCRL(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTrustedFqdnCNResponse")) + { *type = SOAP_TYPE__sai__GetTrustedFqdnCNResponse; + return soap_in__sai__GetTrustedFqdnCNResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTrustedFqdnCN")) + { *type = SOAP_TYPE__sai__GetTrustedFqdnCN; + return soap_in__sai__GetTrustedFqdnCN(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTrustedFqdnCNResponse")) + { *type = SOAP_TYPE__sai__SetTrustedFqdnCNResponse; + return soap_in__sai__SetTrustedFqdnCNResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTrustedFqdnCN")) + { *type = SOAP_TYPE__sai__SetTrustedFqdnCN; + return soap_in__sai__SetTrustedFqdnCN(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnumerateTrustedRootCertificatesResponse")) + { *type = SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse; + return soap_in__sai__EnumerateTrustedRootCertificatesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnumerateTrustedRootCertificates")) + { *type = SOAP_TYPE__sai__EnumerateTrustedRootCertificates; + return soap_in__sai__EnumerateTrustedRootCertificates(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:DeleteTrustedRootCertificateResponse")) + { *type = SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse; + return soap_in__sai__DeleteTrustedRootCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:DeleteTrustedRootCertificate")) + { *type = SOAP_TYPE__sai__DeleteTrustedRootCertificate; + return soap_in__sai__DeleteTrustedRootCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTrustedRootCertificateResponse")) + { *type = SOAP_TYPE__sai__GetTrustedRootCertificateResponse; + return soap_in__sai__GetTrustedRootCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTrustedRootCertificate")) + { *type = SOAP_TYPE__sai__GetTrustedRootCertificate; + return soap_in__sai__GetTrustedRootCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AddTrustedRootCertificateResponse")) + { *type = SOAP_TYPE__sai__AddTrustedRootCertificateResponse; + return soap_in__sai__AddTrustedRootCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AddTrustedRootCertificate")) + { *type = SOAP_TYPE__sai__AddTrustedRootCertificate; + return soap_in__sai__AddTrustedRootCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTlsOptionsResponse")) + { *type = SOAP_TYPE__sai__GetTlsOptionsResponse; + return soap_in__sai__GetTlsOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTlsOptions")) + { *type = SOAP_TYPE__sai__GetTlsOptions; + return soap_in__sai__GetTlsOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTlsOptionsResponse")) + { *type = SOAP_TYPE__sai__SetTlsOptionsResponse; + return soap_in__sai__SetTlsOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTlsOptions")) + { *type = SOAP_TYPE__sai__SetTlsOptions; + return soap_in__sai__SetTlsOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetEnabledInterfacesResponse")) + { *type = SOAP_TYPE__sai__GetEnabledInterfacesResponse; + return soap_in__sai__GetEnabledInterfacesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetEnabledInterfaces")) + { *type = SOAP_TYPE__sai__GetEnabledInterfaces; + return soap_in__sai__GetEnabledInterfaces(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetEnabledInterfacesResponse")) + { *type = SOAP_TYPE__sai__SetEnabledInterfacesResponse; + return soap_in__sai__SetEnabledInterfacesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetEnabledInterfaces")) + { *type = SOAP_TYPE__sai__SetEnabledInterfaces; + return soap_in__sai__SetEnabledInterfaces(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetKerberosOptionsResponse")) + { *type = SOAP_TYPE__sai__GetKerberosOptionsResponse; + return soap_in__sai__GetKerberosOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetKerberosOptions")) + { *type = SOAP_TYPE__sai__GetKerberosOptions; + return soap_in__sai__GetKerberosOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetKerberosOptionsResponse")) + { *type = SOAP_TYPE__sai__SetKerberosOptionsResponse; + return soap_in__sai__SetKerberosOptionsResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetKerberosOptions")) + { *type = SOAP_TYPE__sai__SetKerberosOptions; + return soap_in__sai__SetKerberosOptions(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetDigestRealmResponse")) + { *type = SOAP_TYPE__sai__GetDigestRealmResponse; + return soap_in__sai__GetDigestRealmResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetDigestRealm")) + { *type = SOAP_TYPE__sai__GetDigestRealm; + return soap_in__sai__GetDigestRealm(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetAdminAclEntryExResponse")) + { *type = SOAP_TYPE__sai__SetAdminAclEntryExResponse; + return soap_in__sai__SetAdminAclEntryExResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetAdminAclEntryEx")) + { *type = SOAP_TYPE__sai__SetAdminAclEntryEx; + return soap_in__sai__SetAdminAclEntryEx(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UpdateUserAclEntryExResponse")) + { *type = SOAP_TYPE__sai__UpdateUserAclEntryExResponse; + return soap_in__sai__UpdateUserAclEntryExResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UpdateUserAclEntryEx")) + { *type = SOAP_TYPE__sai__UpdateUserAclEntryEx; + return soap_in__sai__UpdateUserAclEntryEx(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetUserAclEntryExResponse")) + { *type = SOAP_TYPE__sai__GetUserAclEntryExResponse; + return soap_in__sai__GetUserAclEntryExResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetUserAclEntryEx")) + { *type = SOAP_TYPE__sai__GetUserAclEntryEx; + return soap_in__sai__GetUserAclEntryEx(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AddUserAclEntryExResponse")) + { *type = SOAP_TYPE__sai__AddUserAclEntryExResponse; + return soap_in__sai__AddUserAclEntryExResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AddUserAclEntryEx")) + { *type = SOAP_TYPE__sai__AddUserAclEntryEx; + return soap_in__sai__AddUserAclEntryEx(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetCoreVersionResponse")) + { *type = SOAP_TYPE__sai__GetCoreVersionResponse; + return soap_in__sai__GetCoreVersionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetCoreVersion")) + { *type = SOAP_TYPE__sai__GetCoreVersion; + return soap_in__sai__GetCoreVersion(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:ResetFlashWearOutProtectionResponse")) + { *type = SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse; + return soap_in__sai__ResetFlashWearOutProtectionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:ResetFlashWearOutProtection")) + { *type = SOAP_TYPE__sai__ResetFlashWearOutProtection; + return soap_in__sai__ResetFlashWearOutProtection(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CommitChangesResponse")) + { *type = SOAP_TYPE__sai__CommitChangesResponse; + return soap_in__sai__CommitChangesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:CommitChanges")) + { *type = SOAP_TYPE__sai__CommitChanges; + return soap_in__sai__CommitChanges(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UnprovisionResponse")) + { *type = SOAP_TYPE__sai__UnprovisionResponse; + return soap_in__sai__UnprovisionResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:Unprovision")) + { *type = SOAP_TYPE__sai__Unprovision; + return soap_in__sai__Unprovision(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetProvisioningModeResponse")) + { *type = SOAP_TYPE__sai__SetProvisioningModeResponse; + return soap_in__sai__SetProvisioningModeResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetProvisioningMode")) + { *type = SOAP_TYPE__sai__SetProvisioningMode; + return soap_in__sai__SetProvisioningMode(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetProvisioningModeResponse")) + { *type = SOAP_TYPE__sai__GetProvisioningModeResponse; + return soap_in__sai__GetProvisioningModeResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetProvisioningMode")) + { *type = SOAP_TYPE__sai__GetProvisioningMode; + return soap_in__sai__GetProvisioningMode(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UpdateCoreFromUrlResponse")) + { *type = SOAP_TYPE__sai__UpdateCoreFromUrlResponse; + return soap_in__sai__UpdateCoreFromUrlResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UpdateCoreFromUrl")) + { *type = SOAP_TYPE__sai__UpdateCoreFromUrl; + return soap_in__sai__UpdateCoreFromUrl(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTLSCertificateResponse")) + { *type = SOAP_TYPE__sai__GetTLSCertificateResponse; + return soap_in__sai__GetTLSCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetTLSCertificate")) + { *type = SOAP_TYPE__sai__GetTLSCertificate; + return soap_in__sai__GetTLSCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTLSCertificateResponse")) + { *type = SOAP_TYPE__sai__SetTLSCertificateResponse; + return soap_in__sai__SetTLSCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTLSCertificate")) + { *type = SOAP_TYPE__sai__SetTLSCertificate; + return soap_in__sai__SetTLSCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetRngKeyResponse")) + { *type = SOAP_TYPE__sai__SetRngKeyResponse; + return soap_in__sai__SetRngKeyResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetRngKey")) + { *type = SOAP_TYPE__sai__SetRngKey; + return soap_in__sai__SetRngKey(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTLSKeyAndCertificateResponse")) + { *type = SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse; + return soap_in__sai__SetTLSKeyAndCertificateResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTLSKeyAndCertificate")) + { *type = SOAP_TYPE__sai__SetTLSKeyAndCertificate; + return soap_in__sai__SetTLSKeyAndCertificate(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTlsEnabledResponse")) + { *type = SOAP_TYPE__sai__SetTlsEnabledResponse; + return soap_in__sai__SetTlsEnabledResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetTlsEnabled")) + { *type = SOAP_TYPE__sai__SetTlsEnabled; + return soap_in__sai__SetTlsEnabled(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:RemoveUserAclEntryResponse")) + { *type = SOAP_TYPE__sai__RemoveUserAclEntryResponse; + return soap_in__sai__RemoveUserAclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:RemoveUserAclEntry")) + { *type = SOAP_TYPE__sai__RemoveUserAclEntry; + return soap_in__sai__RemoveUserAclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UpdateUserAclEntryResponse")) + { *type = SOAP_TYPE__sai__UpdateUserAclEntryResponse; + return soap_in__sai__UpdateUserAclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:UpdateUserAclEntry")) + { *type = SOAP_TYPE__sai__UpdateUserAclEntry; + return soap_in__sai__UpdateUserAclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetAdminAclEntryResponse")) + { *type = SOAP_TYPE__sai__GetAdminAclEntryResponse; + return soap_in__sai__GetAdminAclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetAdminAclEntry")) + { *type = SOAP_TYPE__sai__GetAdminAclEntry; + return soap_in__sai__GetAdminAclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetUserAclEntryResponse")) + { *type = SOAP_TYPE__sai__GetUserAclEntryResponse; + return soap_in__sai__GetUserAclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:GetUserAclEntry")) + { *type = SOAP_TYPE__sai__GetUserAclEntry; + return soap_in__sai__GetUserAclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnumerateUserAclEntriesResponse")) + { *type = SOAP_TYPE__sai__EnumerateUserAclEntriesResponse; + return soap_in__sai__EnumerateUserAclEntriesResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:EnumerateUserAclEntries")) + { *type = SOAP_TYPE__sai__EnumerateUserAclEntries; + return soap_in__sai__EnumerateUserAclEntries(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetAdminAclEntryResponse")) + { *type = SOAP_TYPE__sai__SetAdminAclEntryResponse; + return soap_in__sai__SetAdminAclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:SetAdminAclEntry")) + { *type = SOAP_TYPE__sai__SetAdminAclEntry; + return soap_in__sai__SetAdminAclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AddUserAclEntryResponse")) + { *type = SOAP_TYPE__sai__AddUserAclEntryResponse; + return soap_in__sai__AddUserAclEntryResponse(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "sai:AddUserAclEntry")) + { *type = SOAP_TYPE__sai__AddUserAclEntry; + return soap_in__sai__AddUserAclEntry(soap, NULL, NULL, NULL); + } + if (!soap_match_tag(soap, t, "QName")) + { char **s; + *type = SOAP_TYPE__QName; + s = soap_in__QName(soap, NULL, NULL, NULL); + return s ? *s : NULL; + } + } + } + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} +#endif + +SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap) +{ + if (!soap_peek_element(soap)) + { int t; + if (soap->mustUnderstand && !soap->other) + return soap->error = SOAP_MUSTUNDERSTAND; + if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:")) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag)); + return soap->error = SOAP_TAG_MISMATCH; + } + if (!*soap->id || !soap_getelement(soap, &t)) + { soap->peeked = 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unknown element '%s' (level=%u, %d)\n", soap->tag, soap->level, soap->body)); + if (soap->fignore) + soap->error = soap->fignore(soap, soap->tag); + else + soap->error = SOAP_OK; + DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag)); + if (!soap->error && soap->body) + { soap->level++; + while (!soap_ignore_element(soap)) + ; + if (soap->error == SOAP_NO_TAG) + soap->error = soap_element_end_in(soap, NULL); + } + } + } + return soap->error; +} + +#ifndef WITH_NOIDREF +SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap) +{ + int i; + struct soap_plist *pp; + if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH))) + for (i = 0; i < SOAP_PTRHASH; i++) + for (pp = soap->pht[i]; pp; pp = pp->next) + if (pp->mark1 == 2 || pp->mark2 == 2) + if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type)) + return soap->error; + return SOAP_OK; +} +#endif + +#ifndef WITH_NOIDREF +SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type) +{ + switch (type) + { + case SOAP_TYPE_byte: + return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte"); + case SOAP_TYPE_short: + return soap_out_short(soap, tag, id, (const short *)ptr, "xsd:short"); + case SOAP_TYPE_int: + return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int"); + case SOAP_TYPE_wcxs__ProfilePriorityType: + return soap_out_wcxs__ProfilePriorityType(soap, tag, id, (const unsigned char *)ptr, "wcxs:ProfilePriorityType"); + case SOAP_TYPE_rci__SystemCapabilitiesSupportedType: + return soap_out_rci__SystemCapabilitiesSupportedType(soap, tag, id, (const unsigned char *)ptr, "rci:SystemCapabilitiesSupportedType"); + case SOAP_TYPE_apr__WatchdogState: + return soap_out_apr__WatchdogState(soap, tag, id, (const unsigned char *)ptr, "apr:WatchdogState"); + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE: + return soap_out_hwa__PT_USCOREMEMORY_USCORETYPE(soap, tag, id, (const unsigned char *)ptr, "hwa:PT_MEMORY_TYPE"); + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR: + return soap_out_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(soap, tag, id, (const unsigned char *)ptr, "hwa:PT_MEMORY_FORM_FACTOR"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE: + return soap_out_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(soap, tag, id, (const unsigned char *)ptr, "hwa:PT_PROCESSOR_UPGRADE"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS: + return soap_out_hwa__PT_USCOREPROCESSOR_USCORESTATUS(soap, tag, id, (const unsigned char *)ptr, "hwa:PT_PROCESSOR_STATUS"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY: + return soap_out_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(soap, tag, id, (const unsigned char *)ptr, "hwa:PT_PROCESSOR_FAMILY"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE: + return soap_out_hwa__PT_USCOREPROCESSOR_USCORETYPE(soap, tag, id, (const unsigned char *)ptr, "hwa:PT_PROCESSOR_TYPE"); + case SOAP_TYPE_emi__AlertSubscriptionPolicyIDType: + return soap_out_emi__AlertSubscriptionPolicyIDType(soap, tag, id, (const unsigned char *)ptr, "emi:AlertSubscriptionPolicyIDType"); + case SOAP_TYPE_net__LinkPolicyType: + return soap_out_net__LinkPolicyType(soap, tag, id, (const unsigned char *)ptr, "net:LinkPolicyType"); + case SOAP_TYPE_unsignedByte: + return soap_out_unsignedByte(soap, tag, id, (const unsigned char *)ptr, "xsd:unsignedByte"); + case SOAP_TYPE_rci__OemParametersType: + return soap_out_rci__OemParametersType(soap, tag, id, (const unsigned short *)ptr, "rci:OemParametersType"); + case SOAP_TYPE_rci__SpecialCommandParameterType: + return soap_out_rci__SpecialCommandParameterType(soap, tag, id, (const unsigned short *)ptr, "rci:SpecialCommandParameterType"); + case SOAP_TYPE_rci__BootOptionsType: + return soap_out_rci__BootOptionsType(soap, tag, id, (const unsigned short *)ptr, "rci:BootOptionsType"); + case SOAP_TYPE_rci__SpecialCommandsSupportedType: + return soap_out_rci__SpecialCommandsSupportedType(soap, tag, id, (const unsigned short *)ptr, "rci:SpecialCommandsSupportedType"); + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL: + return soap_out_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(soap, tag, id, (const unsigned short *)ptr, "hwa:PT_MEMORY_TYPE_DETAIL"); + case SOAP_TYPE_unsignedShort: + return soap_out_unsignedShort(soap, tag, id, (const unsigned short *)ptr, "xsd:unsignedShort"); + case SOAP_TYPE_rci__OemDefinedCapabilitiesType: + return soap_out_rci__OemDefinedCapabilitiesType(soap, tag, id, (const unsigned int *)ptr, "rci:OemDefinedCapabilitiesType"); + case SOAP_TYPE_rci__SystemFirmwareCapabilitiesType: + return soap_out_rci__SystemFirmwareCapabilitiesType(soap, tag, id, (const unsigned int *)ptr, "rci:SystemFirmwareCapabilitiesType"); + case SOAP_TYPE_rci__PT_USCORESTATUS: + return soap_out_rci__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "rci:PT_STATUS"); + case SOAP_TYPE_rci__SystemPowerStateType: + return soap_out_rci__SystemPowerStateType(soap, tag, id, (const unsigned int *)ptr, "rci:SystemPowerStateType"); + case SOAP_TYPE_inf__IPv4AddressType: + return soap_out_inf__IPv4AddressType(soap, tag, id, (const unsigned int *)ptr, "inf:IPv4AddressType"); + case SOAP_TYPE_inf__TimeType: + return soap_out_inf__TimeType(soap, tag, id, (const unsigned int *)ptr, "inf:TimeType"); + case SOAP_TYPE_inf__PT_USCORESTATUS: + return soap_out_inf__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "inf:PT_STATUS"); + case SOAP_TYPE_str__PT_USCORESTATUS: + return soap_out_str__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "str:PT_STATUS"); + case SOAP_TYPE_tim__TimeType: + return soap_out_tim__TimeType(soap, tag, id, (const unsigned int *)ptr, "tim:TimeType"); + case SOAP_TYPE_tim__PT_USCORESTATUS: + return soap_out_tim__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "tim:PT_STATUS"); + case SOAP_TYPE_idr__IPv4AddressType: + return soap_out_idr__IPv4AddressType(soap, tag, id, (const unsigned int *)ptr, "idr:IPv4AddressType"); + case SOAP_TYPE_idr__TimeType: + return soap_out_idr__TimeType(soap, tag, id, (const unsigned int *)ptr, "idr:TimeType"); + case SOAP_TYPE_idr__PT_USCORESTATUS: + return soap_out_idr__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "idr:PT_STATUS"); + case SOAP_TYPE_apl__PT_USCORESTATUS: + return soap_out_apl__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "apl:PT_STATUS"); + case SOAP_TYPE_apr__PT_USCORESTATUS: + return soap_out_apr__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "apr:PT_STATUS"); + case SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS: + return soap_out_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(soap, tag, id, (const unsigned int *)ptr, "hwa:PT_BIOS_CHARACTERISTICS"); + case SOAP_TYPE_hwa__PT_USCORESTATUS: + return soap_out_hwa__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "hwa:PT_STATUS"); + case SOAP_TYPE_cb__TimeType: + return soap_out_cb__TimeType(soap, tag, id, (const unsigned int *)ptr, "cb:TimeType"); + case SOAP_TYPE_cb__PT_USCORESTATUS: + return soap_out_cb__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "cb:PT_STATUS"); + case SOAP_TYPE_emi__SensorHandleType: + return soap_out_emi__SensorHandleType(soap, tag, id, (const unsigned int *)ptr, "emi:SensorHandleType"); + case SOAP_TYPE_emi__IPv4AddressType: + return soap_out_emi__IPv4AddressType(soap, tag, id, (const unsigned int *)ptr, "emi:IPv4AddressType"); + case SOAP_TYPE_emi__PT_USCORESTATUS: + return soap_out_emi__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "emi:PT_STATUS"); + case SOAP_TYPE_emi__EventFilterHandleType: + return soap_out_emi__EventFilterHandleType(soap, tag, id, (const unsigned int *)ptr, "emi:EventFilterHandleType"); + case SOAP_TYPE_emi__AlertSubscriptionHandleType: + return soap_out_emi__AlertSubscriptionHandleType(soap, tag, id, (const unsigned int *)ptr, "emi:AlertSubscriptionHandleType"); + case SOAP_TYPE_emi__TimeType: + return soap_out_emi__TimeType(soap, tag, id, (const unsigned int *)ptr, "emi:TimeType"); + case SOAP_TYPE_stra__StorageAllocEntryHandleType: + return soap_out_stra__StorageAllocEntryHandleType(soap, tag, id, (const unsigned int *)ptr, "stra:StorageAllocEntryHandleType"); + case SOAP_TYPE_stra__StorageEaclEntryHandleType: + return soap_out_stra__StorageEaclEntryHandleType(soap, tag, id, (const unsigned int *)ptr, "stra:StorageEaclEntryHandleType"); + case SOAP_TYPE_stra__StorageApplicationHandleType: + return soap_out_stra__StorageApplicationHandleType(soap, tag, id, (const unsigned int *)ptr, "stra:StorageApplicationHandleType"); + case SOAP_TYPE_stra__PT_USCORESTATUS: + return soap_out_stra__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "stra:PT_STATUS"); + case SOAP_TYPE_net__InterfaceHandleType: + return soap_out_net__InterfaceHandleType(soap, tag, id, (const unsigned int *)ptr, "net:InterfaceHandleType"); + case SOAP_TYPE_net__IPv4AddressType: + return soap_out_net__IPv4AddressType(soap, tag, id, (const unsigned int *)ptr, "net:IPv4AddressType"); + case SOAP_TYPE_net__PT_USCORESTATUS: + return soap_out_net__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "net:PT_STATUS"); + case SOAP_TYPE_sai__CertificateHandleType: + return soap_out_sai__CertificateHandleType(soap, tag, id, (const unsigned int *)ptr, "sai:CertificateHandleType"); + case SOAP_TYPE_sai__IPv4AddressType: + return soap_out_sai__IPv4AddressType(soap, tag, id, (const unsigned int *)ptr, "sai:IPv4AddressType"); + case SOAP_TYPE_sai__UserAclEntryHandleType: + return soap_out_sai__UserAclEntryHandleType(soap, tag, id, (const unsigned int *)ptr, "sai:UserAclEntryHandleType"); + case SOAP_TYPE_sai__PT_USCORESTATUS: + return soap_out_sai__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "sai:PT_STATUS"); + case SOAP_TYPE_cstr__KeyPairHandleType: + return soap_out_cstr__KeyPairHandleType(soap, tag, id, (const unsigned int *)ptr, "cstr:KeyPairHandleType"); + case SOAP_TYPE_cmn__InterfaceHandleType: + return soap_out_cmn__InterfaceHandleType(soap, tag, id, (const unsigned int *)ptr, "cmn:InterfaceHandleType"); + case SOAP_TYPE_cmn__IPv4AddressType: + return soap_out_cmn__IPv4AddressType(soap, tag, id, (const unsigned int *)ptr, "cmn:IPv4AddressType"); + case SOAP_TYPE_cmn__PT_USCORESTATUS: + return soap_out_cmn__PT_USCORESTATUS(soap, tag, id, (const unsigned int *)ptr, "cmn:PT_STATUS"); + case SOAP_TYPE_unsignedInt: + return soap_out_unsignedInt(soap, tag, id, (const unsigned int *)ptr, "xsd:unsignedInt"); + case SOAP_TYPE_bool: + return soap_out_bool(soap, tag, id, (const bool *)ptr, "xsd:boolean"); + case SOAP_TYPE_wcxs__FeatureType: + return soap_out_wcxs__FeatureType(soap, tag, id, (const enum wcxs__FeatureType *)ptr, "wcxs:FeatureType"); + case SOAP_TYPE_wcxs__KeyIndexType: + return soap_out_wcxs__KeyIndexType(soap, tag, id, (const enum wcxs__KeyIndexType *)ptr, "wcxs:KeyIndexType"); + case SOAP_TYPE_rci__SpecialCommandType: + return soap_out_rci__SpecialCommandType(soap, tag, id, (const enum rci__SpecialCommandType *)ptr, "rci:SpecialCommandType"); + case SOAP_TYPE_rci__RemoteControlCommandType: + return soap_out_rci__RemoteControlCommandType(soap, tag, id, (const enum rci__RemoteControlCommandType *)ptr, "rci:RemoteControlCommandType"); + case SOAP_TYPE_inf__EnabledInterfacesType: + return soap_out_inf__EnabledInterfacesType(soap, tag, id, (const enum inf__EnabledInterfacesType *)ptr, "inf:EnabledInterfacesType"); + case SOAP_TYPE_inf__PasswordModelType: + return soap_out_inf__PasswordModelType(soap, tag, id, (const enum inf__PasswordModelType *)ptr, "inf:PasswordModelType"); + case SOAP_TYPE_inf__ProvisioningStateType: + return soap_out_inf__ProvisioningStateType(soap, tag, id, (const enum inf__ProvisioningStateType *)ptr, "inf:ProvisioningStateType"); + case SOAP_TYPE_inf__ProvisioningModeType: + return soap_out_inf__ProvisioningModeType(soap, tag, id, (const enum inf__ProvisioningModeType *)ptr, "inf:ProvisioningModeType"); + case SOAP_TYPE_apr__CbActionType: + return soap_out_apr__CbActionType(soap, tag, id, (const enum apr__CbActionType *)ptr, "apr:CbActionType"); + case SOAP_TYPE_hwa__AssetTypeType: + return soap_out_hwa__AssetTypeType(soap, tag, id, (const enum hwa__AssetTypeType *)ptr, "hwa:AssetTypeType"); + case SOAP_TYPE_cb__HcbTriggerReasonType: + return soap_out_cb__HcbTriggerReasonType(soap, tag, id, (const enum cb__HcbTriggerReasonType *)ptr, "cb:HcbTriggerReasonType"); + case SOAP_TYPE_cb__HcbStateType: + return soap_out_cb__HcbStateType(soap, tag, id, (const enum cb__HcbStateType *)ptr, "cb:HcbStateType"); + case SOAP_TYPE_cb__CircuitBreakerApplicationType: + return soap_out_cb__CircuitBreakerApplicationType(soap, tag, id, (const enum cb__CircuitBreakerApplicationType *)ptr, "cb:CircuitBreakerApplicationType"); + case SOAP_TYPE_cb__CircuitBreakerProfileType: + return soap_out_cb__CircuitBreakerProfileType(soap, tag, id, (const enum cb__CircuitBreakerProfileType *)ptr, "cb:CircuitBreakerProfileType"); + case SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType: + return soap_out_cb__CircuitBreakerFilterIPAddressDirectionType(soap, tag, id, (const enum cb__CircuitBreakerFilterIPAddressDirectionType *)ptr, "cb:CircuitBreakerFilterIPAddressDirectionType"); + case SOAP_TYPE_cb__CircuitBreakerFilterDirectionType: + return soap_out_cb__CircuitBreakerFilterDirectionType(soap, tag, id, (const enum cb__CircuitBreakerFilterDirectionType *)ptr, "cb:CircuitBreakerFilterDirectionType"); + case SOAP_TYPE_emi__AlertAuthOptionsType: + return soap_out_emi__AlertAuthOptionsType(soap, tag, id, (const enum emi__AlertAuthOptionsType *)ptr, "emi:AlertAuthOptionsType"); + case SOAP_TYPE_emi__EventSeverityType: + return soap_out_emi__EventSeverityType(soap, tag, id, (const enum emi__EventSeverityType *)ptr, "emi:EventSeverityType"); + case SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE: + return soap_out_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, tag, id, (const enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *)ptr, "stra:ISVS_APP_ATTR_TYPE"); + case SOAP_TYPE_net__InterfaceModeType: + return soap_out_net__InterfaceModeType(soap, tag, id, (const enum net__InterfaceModeType *)ptr, "net:InterfaceModeType"); + case SOAP_TYPE_net__DhcpModeType: + return soap_out_net__DhcpModeType(soap, tag, id, (const enum net__DhcpModeType *)ptr, "net:DhcpModeType"); + case SOAP_TYPE_xcfg__CertNameOptionsType: + return soap_out_xcfg__CertNameOptionsType(soap, tag, id, (const enum xcfg__CertNameOptionsType *)ptr, "xcfg:CertNameOptionsType"); + case SOAP_TYPE_sai__HTTPAuthOptionType: + return soap_out_sai__HTTPAuthOptionType(soap, tag, id, (const enum sai__HTTPAuthOptionType *)ptr, "sai:HTTPAuthOptionType"); + case SOAP_TYPE_sai__HashTypeType: + return soap_out_sai__HashTypeType(soap, tag, id, (const enum sai__HashTypeType *)ptr, "sai:HashTypeType"); + case SOAP_TYPE_sai__ProvisioningTLSModeType: + return soap_out_sai__ProvisioningTLSModeType(soap, tag, id, (const enum sai__ProvisioningTLSModeType *)ptr, "sai:ProvisioningTLSModeType"); + case SOAP_TYPE_sai__TlsAthenticationType: + return soap_out_sai__TlsAthenticationType(soap, tag, id, (const enum sai__TlsAthenticationType *)ptr, "sai:TlsAthenticationType"); + case SOAP_TYPE_sai__InterfaceType: + return soap_out_sai__InterfaceType(soap, tag, id, (const enum sai__InterfaceType *)ptr, "sai:InterfaceType"); + case SOAP_TYPE_sai__EnabledInterfacesType: + return soap_out_sai__EnabledInterfacesType(soap, tag, id, (const enum sai__EnabledInterfacesType *)ptr, "sai:EnabledInterfacesType"); + case SOAP_TYPE_sai__PowerStateType: + return soap_out_sai__PowerStateType(soap, tag, id, (const enum sai__PowerStateType *)ptr, "sai:PowerStateType"); + case SOAP_TYPE_sai__KerberosEncryptionType: + return soap_out_sai__KerberosEncryptionType(soap, tag, id, (const enum sai__KerberosEncryptionType *)ptr, "sai:KerberosEncryptionType"); + case SOAP_TYPE_sai__KerberosSpnProtocolType: + return soap_out_sai__KerberosSpnProtocolType(soap, tag, id, (const enum sai__KerberosSpnProtocolType *)ptr, "sai:KerberosSpnProtocolType"); + case SOAP_TYPE_sai__AccessPermissionType: + return soap_out_sai__AccessPermissionType(soap, tag, id, (const enum sai__AccessPermissionType *)ptr, "sai:AccessPermissionType"); + case SOAP_TYPE_sai__ProvisioningModeType: + return soap_out_sai__ProvisioningModeType(soap, tag, id, (const enum sai__ProvisioningModeType *)ptr, "sai:ProvisioningModeType"); + case SOAP_TYPE_sai__RngKeyEncodingType: + return soap_out_sai__RngKeyEncodingType(soap, tag, id, (const enum sai__RngKeyEncodingType *)ptr, "sai:RngKeyEncodingType"); + case SOAP_TYPE_sai__RsaCertificateEncodingType: + return soap_out_sai__RsaCertificateEncodingType(soap, tag, id, (const enum sai__RsaCertificateEncodingType *)ptr, "sai:RsaCertificateEncodingType"); + case SOAP_TYPE_sai__RsaKeyEncodingType: + return soap_out_sai__RsaKeyEncodingType(soap, tag, id, (const enum sai__RsaKeyEncodingType *)ptr, "sai:RsaKeyEncodingType"); + case SOAP_TYPE_sai__UserAclRealmType: + return soap_out_sai__UserAclRealmType(soap, tag, id, (const enum sai__UserAclRealmType *)ptr, "sai:UserAclRealmType"); + case SOAP_TYPE_wcxs__PassPhrase63Type: + return soap_out_wcxs__PassPhrase63Type(soap, tag, id, (const std::string *)ptr, "wcxs:PassPhrase63Type"); + case SOAP_TYPE_wcxs__PassPhraseWEP128Type: + return soap_out_wcxs__PassPhraseWEP128Type(soap, tag, id, (const std::string *)ptr, "wcxs:PassPhraseWEP128Type"); + case SOAP_TYPE_wcxs__PassPhrase5Type: + return soap_out_wcxs__PassPhrase5Type(soap, tag, id, (const std::string *)ptr, "wcxs:PassPhrase5Type"); + case SOAP_TYPE_wcxs__RawKey256Type: + return soap_out_wcxs__RawKey256Type(soap, tag, id, (const xsd__base64Binary *)ptr, "wcxs:RawKey256Type"); + case SOAP_TYPE_wcxs__RawKey128Type: + return soap_out_wcxs__RawKey128Type(soap, tag, id, (const xsd__base64Binary *)ptr, "wcxs:RawKey128Type"); + case SOAP_TYPE_wcxs__RawKey64Type: + return soap_out_wcxs__RawKey64Type(soap, tag, id, (const xsd__base64Binary *)ptr, "wcxs:RawKey64Type"); + case SOAP_TYPE_wcxs__ProfileNameType: + return soap_out_wcxs__ProfileNameType(soap, tag, id, (const std::string *)ptr, "wcxs:ProfileNameType"); + case SOAP_TYPE__apr__AgentDescription: + return soap_out__apr__AgentDescription(soap, "apr:AgentDescription", id, (const std::string *)ptr, NULL); + case SOAP_TYPE__cb__PolicyName: + return soap_out__cb__PolicyName(soap, "cb:PolicyName", id, (const std::string *)ptr, NULL); + case SOAP_TYPE__cb__FilterName: + return soap_out__cb__FilterName(soap, "cb:FilterName", id, (const std::string *)ptr, NULL); + case SOAP_TYPE_cb__IPv6AddressStringType: + return soap_out_cb__IPv6AddressStringType(soap, tag, id, (const std::string *)ptr, "cb:IPv6AddressStringType"); + case SOAP_TYPE_cb__IPv4AddressStringType: + return soap_out_cb__IPv4AddressStringType(soap, tag, id, (const std::string *)ptr, "cb:IPv4AddressStringType"); + case SOAP_TYPE_emi__CommunityStringType: + return soap_out_emi__CommunityStringType(soap, tag, id, (const std::string *)ptr, "emi:CommunityStringType"); + case SOAP_TYPE_net__MACAddressType: + return soap_out_net__MACAddressType(soap, tag, id, (const std::string *)ptr, "net:MACAddressType"); + case SOAP_TYPE__sai__KerberosRealmName: + return soap_out__sai__KerberosRealmName(soap, "sai:KerberosRealmName", id, (const std::string *)ptr, NULL); + case SOAP_TYPE__sai__SpnString: + return soap_out__sai__SpnString(soap, "sai:SpnString", id, (const std::string *)ptr, NULL); + case SOAP_TYPE_sai__FriendlyNameType: + return soap_out_sai__FriendlyNameType(soap, tag, id, (const std::string *)ptr, "sai:FriendlyNameType"); + case SOAP_TYPE_sai__ProvisioningOTPType: + return soap_out_sai__ProvisioningOTPType(soap, tag, id, (const xsd__base64Binary *)ptr, "sai:ProvisioningOTPType"); + case SOAP_TYPE_sai__MEBxPasswordType: + return soap_out_sai__MEBxPasswordType(soap, tag, id, (const std::string *)ptr, "sai:MEBxPasswordType"); + case SOAP_TYPE_sai__AclPasswordStringType: + return soap_out_sai__AclPasswordStringType(soap, tag, id, (const std::string *)ptr, "sai:AclPasswordStringType"); + case SOAP_TYPE_sai__AclStringType: + return soap_out_sai__AclStringType(soap, tag, id, (const std::string *)ptr, "sai:AclStringType"); + case SOAP_TYPE_cmn__GuidBuf: + return soap_out_cmn__GuidBuf(soap, tag, id, (const xsd__base64Binary *)ptr, "cmn:GuidBuf"); + case SOAP_TYPE_cmn__IPv6AddressStringType: + return soap_out_cmn__IPv6AddressStringType(soap, tag, id, (const std::string *)ptr, "cmn:IPv6AddressStringType"); + case SOAP_TYPE_cmn__IPv4AddressStringType: + return soap_out_cmn__IPv4AddressStringType(soap, tag, id, (const std::string *)ptr, "cmn:IPv4AddressStringType"); + case SOAP_TYPE_cmn__HostNameType: + return soap_out_cmn__HostNameType(soap, tag, id, (const std::string *)ptr, "cmn:HostNameType"); + case SOAP_TYPE__wcxs__GetWirelessSettingsResponse: + return ((_wcxs__GetWirelessSettingsResponse *)ptr)->soap_out(soap, "wcxs:GetWirelessSettingsResponse", id, NULL); + case SOAP_TYPE__wcxs__GetWirelessSettingsRequest: + return ((_wcxs__GetWirelessSettingsRequest *)ptr)->soap_out(soap, "wcxs:GetWirelessSettingsRequest", id, NULL); + case SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse: + return ((_wcxs__GetWirelessCapabilitiesResponse *)ptr)->soap_out(soap, "wcxs:GetWirelessCapabilitiesResponse", id, NULL); + case SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest: + return ((_wcxs__GetWirelessCapabilitiesRequest *)ptr)->soap_out(soap, "wcxs:GetWirelessCapabilitiesRequest", id, NULL); + case SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse: + return ((_wcxs__EnumerateWirelessProfilesResponse *)ptr)->soap_out(soap, "wcxs:EnumerateWirelessProfilesResponse", id, NULL); + case SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest: + return ((_wcxs__EnumerateWirelessProfilesRequest *)ptr)->soap_out(soap, "wcxs:EnumerateWirelessProfilesRequest", id, NULL); + case SOAP_TYPE__wcxs__UpdateWirelessProfileResponse: + return ((_wcxs__UpdateWirelessProfileResponse *)ptr)->soap_out(soap, "wcxs:UpdateWirelessProfileResponse", id, NULL); + case SOAP_TYPE__wcxs__UpdateWirelessProfileRequest: + return ((_wcxs__UpdateWirelessProfileRequest *)ptr)->soap_out(soap, "wcxs:UpdateWirelessProfileRequest", id, NULL); + case SOAP_TYPE__wcxs__RemoveWirelessProfileResponse: + return ((_wcxs__RemoveWirelessProfileResponse *)ptr)->soap_out(soap, "wcxs:RemoveWirelessProfileResponse", id, NULL); + case SOAP_TYPE__wcxs__RemoveWirelessProfileRequest: + return ((_wcxs__RemoveWirelessProfileRequest *)ptr)->soap_out(soap, "wcxs:RemoveWirelessProfileRequest", id, NULL); + case SOAP_TYPE__wcxs__GetWirelessProfileResponse: + return ((_wcxs__GetWirelessProfileResponse *)ptr)->soap_out(soap, "wcxs:GetWirelessProfileResponse", id, NULL); + case SOAP_TYPE__wcxs__GetWirelessProfileRequest: + return ((_wcxs__GetWirelessProfileRequest *)ptr)->soap_out(soap, "wcxs:GetWirelessProfileRequest", id, NULL); + case SOAP_TYPE__wcxs__AddWirelessProfileResponse: + return ((_wcxs__AddWirelessProfileResponse *)ptr)->soap_out(soap, "wcxs:AddWirelessProfileResponse", id, NULL); + case SOAP_TYPE__wcxs__AddWirelessProfileRequest: + return ((_wcxs__AddWirelessProfileRequest *)ptr)->soap_out(soap, "wcxs:AddWirelessProfileRequest", id, NULL); + case SOAP_TYPE_wcxs__WirelessSettingsType: + return ((wcxs__WirelessSettingsType *)ptr)->soap_out(soap, tag, id, "wcxs:WirelessSettingsType"); + case SOAP_TYPE_wcxs__WirelessCapabilitiesType: + return ((wcxs__WirelessCapabilitiesType *)ptr)->soap_out(soap, tag, id, "wcxs:WirelessCapabilitiesType"); + case SOAP_TYPE_wcxs__ProfileType: + return ((wcxs__ProfileType *)ptr)->soap_out(soap, tag, id, "wcxs:ProfileType"); + case SOAP_TYPE_wcxs__ProfileSecuritySettingsType: + return ((wcxs__ProfileSecuritySettingsType *)ptr)->soap_out(soap, tag, id, "wcxs:ProfileSecuritySettingsType"); + case SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType: + return ((wcxs__ProfileSecuritySettingRSNType *)ptr)->soap_out(soap, tag, id, "wcxs:ProfileSecuritySettingRSNType"); + case SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType: + return ((wcxs__ProfileSecuritySettingWPAType *)ptr)->soap_out(soap, tag, id, "wcxs:ProfileSecuritySettingWPAType"); + case SOAP_TYPE_wcxs__DataEncryptionCCMPType: + return ((wcxs__DataEncryptionCCMPType *)ptr)->soap_out(soap, tag, id, "wcxs:DataEncryptionCCMPType"); + case SOAP_TYPE_wcxs__DataEncryptionTKIPType: + return ((wcxs__DataEncryptionTKIPType *)ptr)->soap_out(soap, tag, id, "wcxs:DataEncryptionTKIPType"); + case SOAP_TYPE_wcxs__DataEncryptionWEPType: + return ((wcxs__DataEncryptionWEPType *)ptr)->soap_out(soap, tag, id, "wcxs:DataEncryptionWEPType"); + case SOAP_TYPE_wcxs__DataEncryptionWEPXType: + return ((wcxs__DataEncryptionWEPXType *)ptr)->soap_out(soap, tag, id, "wcxs:DataEncryptionWEPXType"); + case SOAP_TYPE_wcxs__WEP128Type: + return ((wcxs__WEP128Type *)ptr)->soap_out(soap, tag, id, "wcxs:WEP128Type"); + case SOAP_TYPE_wcxs__WEP64Type: + return ((wcxs__WEP64Type *)ptr)->soap_out(soap, tag, id, "wcxs:WEP64Type"); + case SOAP_TYPE__rci__GetSystemPowerStateResponse: + return ((_rci__GetSystemPowerStateResponse *)ptr)->soap_out(soap, "rci:GetSystemPowerStateResponse", id, NULL); + case SOAP_TYPE__rci__GetSystemPowerState: + return ((_rci__GetSystemPowerState *)ptr)->soap_out(soap, "rci:GetSystemPowerState", id, NULL); + case SOAP_TYPE__rci__RemoteControlResponse: + return ((_rci__RemoteControlResponse *)ptr)->soap_out(soap, "rci:RemoteControlResponse", id, NULL); + case SOAP_TYPE__rci__RemoteControl: + return ((_rci__RemoteControl *)ptr)->soap_out(soap, "rci:RemoteControl", id, NULL); + case SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse: + return ((_rci__GetRemoteControlCapabilitiesResponse *)ptr)->soap_out(soap, "rci:GetRemoteControlCapabilitiesResponse", id, NULL); + case SOAP_TYPE__rci__GetRemoteControlCapabilities: + return ((_rci__GetRemoteControlCapabilities *)ptr)->soap_out(soap, "rci:GetRemoteControlCapabilities", id, NULL); + case SOAP_TYPE__inf__GetIderSessionLogResponse: + return ((_inf__GetIderSessionLogResponse *)ptr)->soap_out(soap, "inf:GetIderSessionLogResponse", id, NULL); + case SOAP_TYPE__inf__GetIderSessionLog: + return ((_inf__GetIderSessionLog *)ptr)->soap_out(soap, "inf:GetIderSessionLog", id, NULL); + case SOAP_TYPE__inf__GetSecurityParametersResponse: + return ((_inf__GetSecurityParametersResponse *)ptr)->soap_out(soap, "inf:GetSecurityParametersResponse", id, NULL); + case SOAP_TYPE__inf__GetSecurityParameters: + return ((_inf__GetSecurityParameters *)ptr)->soap_out(soap, "inf:GetSecurityParameters", id, NULL); + case SOAP_TYPE__inf__GetNetworkStateResponse: + return ((_inf__GetNetworkStateResponse *)ptr)->soap_out(soap, "inf:GetNetworkStateResponse", id, NULL); + case SOAP_TYPE__inf__GetNetworkState: + return ((_inf__GetNetworkState *)ptr)->soap_out(soap, "inf:GetNetworkState", id, NULL); + case SOAP_TYPE__inf__GetEnabledInterfacesResponse: + return ((_inf__GetEnabledInterfacesResponse *)ptr)->soap_out(soap, "inf:GetEnabledInterfacesResponse", id, NULL); + case SOAP_TYPE__inf__GetEnabledInterfaces: + return ((_inf__GetEnabledInterfaces *)ptr)->soap_out(soap, "inf:GetEnabledInterfaces", id, NULL); + case SOAP_TYPE__inf__GetPasswordModelResponse: + return ((_inf__GetPasswordModelResponse *)ptr)->soap_out(soap, "inf:GetPasswordModelResponse", id, NULL); + case SOAP_TYPE__inf__GetPasswordModel: + return ((_inf__GetPasswordModel *)ptr)->soap_out(soap, "inf:GetPasswordModel", id, NULL); + case SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse: + return ((_inf__GetAdminNetAclEntryStatusResponse *)ptr)->soap_out(soap, "inf:GetAdminNetAclEntryStatusResponse", id, NULL); + case SOAP_TYPE__inf__GetAdminNetAclEntryStatus: + return ((_inf__GetAdminNetAclEntryStatus *)ptr)->soap_out(soap, "inf:GetAdminNetAclEntryStatus", id, NULL); + case SOAP_TYPE__inf__GetAdminAclEntryStatusResponse: + return ((_inf__GetAdminAclEntryStatusResponse *)ptr)->soap_out(soap, "inf:GetAdminAclEntryStatusResponse", id, NULL); + case SOAP_TYPE__inf__GetAdminAclEntryStatus: + return ((_inf__GetAdminAclEntryStatus *)ptr)->soap_out(soap, "inf:GetAdminAclEntryStatus", id, NULL); + case SOAP_TYPE__inf__GetConfigServerInfoResponse: + return ((_inf__GetConfigServerInfoResponse *)ptr)->soap_out(soap, "inf:GetConfigServerInfoResponse", id, NULL); + case SOAP_TYPE__inf__GetConfigServerInfo: + return ((_inf__GetConfigServerInfo *)ptr)->soap_out(soap, "inf:GetConfigServerInfo", id, NULL); + case SOAP_TYPE__inf__GetHostNameResponse: + return ((_inf__GetHostNameResponse *)ptr)->soap_out(soap, "inf:GetHostNameResponse", id, NULL); + case SOAP_TYPE__inf__GetHostName: + return ((_inf__GetHostName *)ptr)->soap_out(soap, "inf:GetHostName", id, NULL); + case SOAP_TYPE__inf__GetVlanParametersResponse: + return ((_inf__GetVlanParametersResponse *)ptr)->soap_out(soap, "inf:GetVlanParametersResponse", id, NULL); + case SOAP_TYPE__inf__GetVlanParameters: + return ((_inf__GetVlanParameters *)ptr)->soap_out(soap, "inf:GetVlanParameters", id, NULL); + case SOAP_TYPE__inf__GetProvisioningStateResponse: + return ((_inf__GetProvisioningStateResponse *)ptr)->soap_out(soap, "inf:GetProvisioningStateResponse", id, NULL); + case SOAP_TYPE__inf__GetProvisioningState: + return ((_inf__GetProvisioningState *)ptr)->soap_out(soap, "inf:GetProvisioningState", id, NULL); + case SOAP_TYPE__inf__GetProvisioningModeResponse: + return ((_inf__GetProvisioningModeResponse *)ptr)->soap_out(soap, "inf:GetProvisioningModeResponse", id, NULL); + case SOAP_TYPE__inf__GetProvisioningMode: + return ((_inf__GetProvisioningMode *)ptr)->soap_out(soap, "inf:GetProvisioningMode", id, NULL); + case SOAP_TYPE__inf__GetCodeVersionsResponse: + return ((_inf__GetCodeVersionsResponse *)ptr)->soap_out(soap, "inf:GetCodeVersionsResponse", id, NULL); + case SOAP_TYPE__inf__GetCodeVersions: + return ((_inf__GetCodeVersions *)ptr)->soap_out(soap, "inf:GetCodeVersions", id, NULL); + case SOAP_TYPE__inf__GetCoreVersionResponse: + return ((_inf__GetCoreVersionResponse *)ptr)->soap_out(soap, "inf:GetCoreVersionResponse", id, NULL); + case SOAP_TYPE__inf__GetCoreVersion: + return ((_inf__GetCoreVersion *)ptr)->soap_out(soap, "inf:GetCoreVersion", id, NULL); + case SOAP_TYPE_inf__FirmwareVersionType: + return ((inf__FirmwareVersionType *)ptr)->soap_out(soap, tag, id, "inf:FirmwareVersionType"); + case SOAP_TYPE_inf__IderSessionLogEntryType: + return ((inf__IderSessionLogEntryType *)ptr)->soap_out(soap, tag, id, "inf:IderSessionLogEntryType"); + case SOAP_TYPE__str__ExecuteStorageOperationResponse: + return ((_str__ExecuteStorageOperationResponse *)ptr)->soap_out(soap, "str:ExecuteStorageOperationResponse", id, NULL); + case SOAP_TYPE__str__ExecuteStorageOperation: + return ((_str__ExecuteStorageOperation *)ptr)->soap_out(soap, "str:ExecuteStorageOperation", id, NULL); + case SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse: + return ((_tim__SetHighAccuracyTimeSynchResponse *)ptr)->soap_out(soap, "tim:SetHighAccuracyTimeSynchResponse", id, NULL); + case SOAP_TYPE__tim__SetHighAccuracyTimeSynch: + return ((_tim__SetHighAccuracyTimeSynch *)ptr)->soap_out(soap, "tim:SetHighAccuracyTimeSynch", id, NULL); + case SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse: + return ((_tim__GetLowAccuracyTimeSynchResponse *)ptr)->soap_out(soap, "tim:GetLowAccuracyTimeSynchResponse", id, NULL); + case SOAP_TYPE__tim__GetLowAccuracyTimeSynch: + return ((_tim__GetLowAccuracyTimeSynch *)ptr)->soap_out(soap, "tim:GetLowAccuracyTimeSynch", id, NULL); + case SOAP_TYPE__idr__GetIderSessionLogResponse: + return ((_idr__GetIderSessionLogResponse *)ptr)->soap_out(soap, "idr:GetIderSessionLogResponse", id, NULL); + case SOAP_TYPE__idr__GetIderSessionLog: + return ((_idr__GetIderSessionLog *)ptr)->soap_out(soap, "idr:GetIderSessionLog", id, NULL); + case SOAP_TYPE__idr__GetRedirectionListenerStateResponse: + return ((_idr__GetRedirectionListenerStateResponse *)ptr)->soap_out(soap, "idr:GetRedirectionListenerStateResponse", id, NULL); + case SOAP_TYPE__idr__GetRedirectionListenerState: + return ((_idr__GetRedirectionListenerState *)ptr)->soap_out(soap, "idr:GetRedirectionListenerState", id, NULL); + case SOAP_TYPE__idr__SetRedirectionListenerStateResponse: + return ((_idr__SetRedirectionListenerStateResponse *)ptr)->soap_out(soap, "idr:SetRedirectionListenerStateResponse", id, NULL); + case SOAP_TYPE__idr__SetRedirectionListenerState: + return ((_idr__SetRedirectionListenerState *)ptr)->soap_out(soap, "idr:SetRedirectionListenerState", id, NULL); + case SOAP_TYPE_idr__FirmwareVersionType: + return ((idr__FirmwareVersionType *)ptr)->soap_out(soap, tag, id, "idr:FirmwareVersionType"); + case SOAP_TYPE_idr__IderSessionLogEntryType: + return ((idr__IderSessionLogEntryType *)ptr)->soap_out(soap, tag, id, "idr:IderSessionLogEntryType"); + case SOAP_TYPE__apl__AgentWatchdogShutdownResponse: + return ((_apl__AgentWatchdogShutdownResponse *)ptr)->soap_out(soap, "apl:AgentWatchdogShutdownResponse", id, NULL); + case SOAP_TYPE__apl__AgentWatchdogShutdown: + return ((_apl__AgentWatchdogShutdown *)ptr)->soap_out(soap, "apl:AgentWatchdogShutdown", id, NULL); + case SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse: + return ((_apl__AgentWatchdogHeartbeatResponse *)ptr)->soap_out(soap, "apl:AgentWatchdogHeartbeatResponse", id, NULL); + case SOAP_TYPE__apl__AgentWatchdogHeartbeat: + return ((_apl__AgentWatchdogHeartbeat *)ptr)->soap_out(soap, "apl:AgentWatchdogHeartbeat", id, NULL); + case SOAP_TYPE__apl__AgentWatchdogRegisterResponse: + return ((_apl__AgentWatchdogRegisterResponse *)ptr)->soap_out(soap, "apl:AgentWatchdogRegisterResponse", id, NULL); + case SOAP_TYPE__apl__AgentWatchdogRegister: + return ((_apl__AgentWatchdogRegister *)ptr)->soap_out(soap, "apl:AgentWatchdogRegister", id, NULL); + case SOAP_TYPE_apl__GUID: + return ((apl__GUID *)ptr)->soap_out(soap, tag, id, "apl:GUID"); + case SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse: + return ((_apr__ConsoleWatchdogQueryCapabilitiesResponse *)ptr)->soap_out(soap, "apr:ConsoleWatchdogQueryCapabilitiesResponse", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities: + return ((_apr__ConsoleWatchdogQueryCapabilities *)ptr)->soap_out(soap, "apr:ConsoleWatchdogQueryCapabilities", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse: + return ((_apr__ConsoleWatchdogGetCbPolicyResponse *)ptr)->soap_out(soap, "apr:ConsoleWatchdogGetCbPolicyResponse", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy: + return ((_apr__ConsoleWatchdogGetCbPolicy *)ptr)->soap_out(soap, "apr:ConsoleWatchdogGetCbPolicy", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse: + return ((_apr__ConsoleWatchdogSetCbPolicyResponse *)ptr)->soap_out(soap, "apr:ConsoleWatchdogSetCbPolicyResponse", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy: + return ((_apr__ConsoleWatchdogSetCbPolicy *)ptr)->soap_out(soap, "apr:ConsoleWatchdogSetCbPolicy", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse: + return ((_apr__ConsoleWatchdogGetActionsResponse *)ptr)->soap_out(soap, "apr:ConsoleWatchdogGetActionsResponse", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogGetActions: + return ((_apr__ConsoleWatchdogGetActions *)ptr)->soap_out(soap, "apr:ConsoleWatchdogGetActions", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse: + return ((_apr__ConsoleWatchdogSetActionsResponse *)ptr)->soap_out(soap, "apr:ConsoleWatchdogSetActionsResponse", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogSetActions: + return ((_apr__ConsoleWatchdogSetActions *)ptr)->soap_out(soap, "apr:ConsoleWatchdogSetActions", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse: + return ((_apr__ConsoleWatchdogEnumerateResponse *)ptr)->soap_out(soap, "apr:ConsoleWatchdogEnumerateResponse", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogEnumerate: + return ((_apr__ConsoleWatchdogEnumerate *)ptr)->soap_out(soap, "apr:ConsoleWatchdogEnumerate", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse: + return ((_apr__ConsoleWatchdogDeleteResponse *)ptr)->soap_out(soap, "apr:ConsoleWatchdogDeleteResponse", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogDelete: + return ((_apr__ConsoleWatchdogDelete *)ptr)->soap_out(soap, "apr:ConsoleWatchdogDelete", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogCreateResponse: + return ((_apr__ConsoleWatchdogCreateResponse *)ptr)->soap_out(soap, "apr:ConsoleWatchdogCreateResponse", id, NULL); + case SOAP_TYPE__apr__ConsoleWatchdogCreate: + return ((_apr__ConsoleWatchdogCreate *)ptr)->soap_out(soap, "apr:ConsoleWatchdogCreate", id, NULL); + case SOAP_TYPE_apr__AgentPresenceCapabilitiesType: + return ((apr__AgentPresenceCapabilitiesType *)ptr)->soap_out(soap, tag, id, "apr:AgentPresenceCapabilitiesType"); + case SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType: + return ((apr__CircuitBreakerHardwarePolicyType *)ptr)->soap_out(soap, tag, id, "apr:CircuitBreakerHardwarePolicyType"); + case SOAP_TYPE_apr__ConsoleWatchdogActionType: + return ((apr__ConsoleWatchdogActionType *)ptr)->soap_out(soap, tag, id, "apr:ConsoleWatchdogActionType"); + case SOAP_TYPE_apr__ConsoleWatchdogEntryType: + return ((apr__ConsoleWatchdogEntryType *)ptr)->soap_out(soap, tag, id, "apr:ConsoleWatchdogEntryType"); + case SOAP_TYPE_apr__GUID: + return ((apr__GUID *)ptr)->soap_out(soap, tag, id, "apr:GUID"); + case SOAP_TYPE__hwa__GetAssetDataResponse: + return ((_hwa__GetAssetDataResponse *)ptr)->soap_out(soap, "hwa:GetAssetDataResponse", id, NULL); + case SOAP_TYPE__hwa__GetAssetData: + return ((_hwa__GetAssetData *)ptr)->soap_out(soap, "hwa:GetAssetData", id, NULL); + case SOAP_TYPE__hwa__EnumerateAssetTypesResponse: + return ((_hwa__EnumerateAssetTypesResponse *)ptr)->soap_out(soap, "hwa:EnumerateAssetTypesResponse", id, NULL); + case SOAP_TYPE__hwa__EnumerateAssetTypes: + return ((_hwa__EnumerateAssetTypes *)ptr)->soap_out(soap, "hwa:EnumerateAssetTypes", id, NULL); + case SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE: + return ((hwa__PT_USCOREMEDIA_USCOREDEVICE *)ptr)->soap_out(soap, tag, id, "hwa:PT_MEDIA_DEVICE"); + case SOAP_TYPE_hwa__PT_USCOREFRU: + return ((hwa__PT_USCOREFRU *)ptr)->soap_out(soap, tag, id, "hwa:PT_FRU"); + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE: + return ((hwa__PT_USCOREMEMORY_USCOREMODULE *)ptr)->soap_out(soap, tag, id, "hwa:PT_MEMORY_MODULE"); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR: + return ((hwa__PT_USCOREPROCESSOR *)ptr)->soap_out(soap, tag, id, "hwa:PT_PROCESSOR"); + case SOAP_TYPE_hwa__PT_USCOREBASEBOARD: + return ((hwa__PT_USCOREBASEBOARD *)ptr)->soap_out(soap, tag, id, "hwa:PT_BASEBOARD"); + case SOAP_TYPE_hwa__GUID: + return ((hwa__GUID *)ptr)->soap_out(soap, tag, id, "hwa:GUID"); + case SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM: + return ((hwa__PT_USCORECOMPUTER_USCORESYSTEM *)ptr)->soap_out(soap, tag, id, "hwa:PT_COMPUTER_SYSTEM"); + case SOAP_TYPE_hwa__PT_USCOREBIOS: + return ((hwa__PT_USCOREBIOS *)ptr)->soap_out(soap, tag, id, "hwa:PT_BIOS"); + case SOAP_TYPE_hwa__AssetDataType: + return ((hwa__AssetDataType *)ptr)->soap_out(soap, tag, id, "hwa:AssetDataType"); + case SOAP_TYPE_hwa__AssetDataArrayType: + return ((hwa__AssetDataArrayType *)ptr)->soap_out(soap, tag, id, "hwa:AssetDataArrayType"); + case SOAP_TYPE_hwa__AssetTypeArrayType: + return ((hwa__AssetTypeArrayType *)ptr)->soap_out(soap, tag, id, "hwa:AssetTypeArrayType"); + case SOAP_TYPE__cb__GetHcbStateResponse: + return ((_cb__GetHcbStateResponse *)ptr)->soap_out(soap, "cb:GetHcbStateResponse", id, NULL); + case SOAP_TYPE__cb__GetHcbState: + return ((_cb__GetHcbState *)ptr)->soap_out(soap, "cb:GetHcbState", id, NULL); + case SOAP_TYPE__cb__ClearHcbStateResponse: + return ((_cb__ClearHcbStateResponse *)ptr)->soap_out(soap, "cb:ClearHcbStateResponse", id, NULL); + case SOAP_TYPE__cb__ClearHcbState: + return ((_cb__ClearHcbState *)ptr)->soap_out(soap, "cb:ClearHcbState", id, NULL); + case SOAP_TYPE__cb__GetHcbOptionsResponse: + return ((_cb__GetHcbOptionsResponse *)ptr)->soap_out(soap, "cb:GetHcbOptionsResponse", id, NULL); + case SOAP_TYPE__cb__GetHcbOptions: + return ((_cb__GetHcbOptions *)ptr)->soap_out(soap, "cb:GetHcbOptions", id, NULL); + case SOAP_TYPE__cb__SetHcbOptionsResponse: + return ((_cb__SetHcbOptionsResponse *)ptr)->soap_out(soap, "cb:SetHcbOptionsResponse", id, NULL); + case SOAP_TYPE__cb__SetHcbOptions: + return ((_cb__SetHcbOptions *)ptr)->soap_out(soap, "cb:SetHcbOptions", id, NULL); + case SOAP_TYPE__cb__CbQueryCapabilitiesResponse: + return ((_cb__CbQueryCapabilitiesResponse *)ptr)->soap_out(soap, "cb:CbQueryCapabilitiesResponse", id, NULL); + case SOAP_TYPE__cb__CbQueryCapabilities: + return ((_cb__CbQueryCapabilities *)ptr)->soap_out(soap, "cb:CbQueryCapabilities", id, NULL); + case SOAP_TYPE__cb__CbFilterEnumerateResponse: + return ((_cb__CbFilterEnumerateResponse *)ptr)->soap_out(soap, "cb:CbFilterEnumerateResponse", id, NULL); + case SOAP_TYPE__cb__CbFilterEnumerate: + return ((_cb__CbFilterEnumerate *)ptr)->soap_out(soap, "cb:CbFilterEnumerate", id, NULL); + case SOAP_TYPE__cb__CbFilterDeleteResponse: + return ((_cb__CbFilterDeleteResponse *)ptr)->soap_out(soap, "cb:CbFilterDeleteResponse", id, NULL); + case SOAP_TYPE__cb__CbFilterDelete: + return ((_cb__CbFilterDelete *)ptr)->soap_out(soap, "cb:CbFilterDelete", id, NULL); + case SOAP_TYPE__cb__CbFilterGetResponse: + return ((_cb__CbFilterGetResponse *)ptr)->soap_out(soap, "cb:CbFilterGetResponse", id, NULL); + case SOAP_TYPE__cb__CbFilterGet: + return ((_cb__CbFilterGet *)ptr)->soap_out(soap, "cb:CbFilterGet", id, NULL); + case SOAP_TYPE__cb__CbFilterCreateResponse: + return ((_cb__CbFilterCreateResponse *)ptr)->soap_out(soap, "cb:CbFilterCreateResponse", id, NULL); + case SOAP_TYPE__cb__CbFilterCreate: + return ((_cb__CbFilterCreate *)ptr)->soap_out(soap, "cb:CbFilterCreate", id, NULL); + case SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse: + return ((_cb__CbPolicyGetActiveStatisticsResponse *)ptr)->soap_out(soap, "cb:CbPolicyGetActiveStatisticsResponse", id, NULL); + case SOAP_TYPE__cb__CbPolicyGetActiveStatistics: + return ((_cb__CbPolicyGetActiveStatistics *)ptr)->soap_out(soap, "cb:CbPolicyGetActiveStatistics", id, NULL); + case SOAP_TYPE__cb__CbPolicyGetEnabledResponse: + return ((_cb__CbPolicyGetEnabledResponse *)ptr)->soap_out(soap, "cb:CbPolicyGetEnabledResponse", id, NULL); + case SOAP_TYPE__cb__CbPolicyGetEnabled: + return ((_cb__CbPolicyGetEnabled *)ptr)->soap_out(soap, "cb:CbPolicyGetEnabled", id, NULL); + case SOAP_TYPE__cb__CbPolicyDisableResponse: + return ((_cb__CbPolicyDisableResponse *)ptr)->soap_out(soap, "cb:CbPolicyDisableResponse", id, NULL); + case SOAP_TYPE__cb__CbPolicyDisable: + return ((_cb__CbPolicyDisable *)ptr)->soap_out(soap, "cb:CbPolicyDisable", id, NULL); + case SOAP_TYPE__cb__CbPolicyEnableResponse: + return ((_cb__CbPolicyEnableResponse *)ptr)->soap_out(soap, "cb:CbPolicyEnableResponse", id, NULL); + case SOAP_TYPE__cb__CbPolicyEnable: + return ((_cb__CbPolicyEnable *)ptr)->soap_out(soap, "cb:CbPolicyEnable", id, NULL); + case SOAP_TYPE__cb__CbPolicyEnumerateResponse: + return ((_cb__CbPolicyEnumerateResponse *)ptr)->soap_out(soap, "cb:CbPolicyEnumerateResponse", id, NULL); + case SOAP_TYPE__cb__CbPolicyEnumerate: + return ((_cb__CbPolicyEnumerate *)ptr)->soap_out(soap, "cb:CbPolicyEnumerate", id, NULL); + case SOAP_TYPE__cb__CbPolicyDeleteResponse: + return ((_cb__CbPolicyDeleteResponse *)ptr)->soap_out(soap, "cb:CbPolicyDeleteResponse", id, NULL); + case SOAP_TYPE__cb__CbPolicyDelete: + return ((_cb__CbPolicyDelete *)ptr)->soap_out(soap, "cb:CbPolicyDelete", id, NULL); + case SOAP_TYPE__cb__CbPolicyGetResponse: + return ((_cb__CbPolicyGetResponse *)ptr)->soap_out(soap, "cb:CbPolicyGetResponse", id, NULL); + case SOAP_TYPE__cb__CbPolicyGet: + return ((_cb__CbPolicyGet *)ptr)->soap_out(soap, "cb:CbPolicyGet", id, NULL); + case SOAP_TYPE__cb__CbPolicyCreateResponse: + return ((_cb__CbPolicyCreateResponse *)ptr)->soap_out(soap, "cb:CbPolicyCreateResponse", id, NULL); + case SOAP_TYPE__cb__CbPolicyCreate: + return ((_cb__CbPolicyCreate *)ptr)->soap_out(soap, "cb:CbPolicyCreate", id, NULL); + case SOAP_TYPE_cb__HcbOptionsType: + return ((cb__HcbOptionsType *)ptr)->soap_out(soap, tag, id, "cb:HcbOptionsType"); + case SOAP_TYPE_cb__BlockedPortInfoType: + return ((cb__BlockedPortInfoType *)ptr)->soap_out(soap, tag, id, "cb:BlockedPortInfoType"); + case SOAP_TYPE_cb__TimedCounterType: + return ((cb__TimedCounterType *)ptr)->soap_out(soap, tag, id, "cb:TimedCounterType"); + case SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType: + return ((cb__CircuitBreakerHardwarePolicyType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerHardwarePolicyType"); + case SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType: + return ((cb__CircuitBreakerFilterStatisticsType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerFilterStatisticsType"); + case SOAP_TYPE_cb__CircuitBreakerCapabilitiesType: + return ((cb__CircuitBreakerCapabilitiesType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerCapabilitiesType"); + case SOAP_TYPE_cb__CircuitBreakerFilterInfoType: + return ((cb__CircuitBreakerFilterInfoType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerFilterInfoType"); + case SOAP_TYPE_cb__CircuitBreakerFilterType: + return ((cb__CircuitBreakerFilterType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerFilterType"); + case SOAP_TYPE_cb__CircuitBreakerPacketType: + return ((cb__CircuitBreakerPacketType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerPacketType"); + case SOAP_TYPE_cb__CircuitBreakerPacketETHType: + return ((cb__CircuitBreakerPacketETHType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerPacketETHType"); + case SOAP_TYPE_cb__CircuitBreakerPacketIPType: + return ((cb__CircuitBreakerPacketIPType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerPacketIPType"); + case SOAP_TYPE_cb__CircuitBreakerPacketTCPType: + return ((cb__CircuitBreakerPacketTCPType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerPacketTCPType"); + case SOAP_TYPE_cb__CircuitBreakerPacketUDPType: + return ((cb__CircuitBreakerPacketUDPType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerPacketUDPType"); + case SOAP_TYPE_cb__CircuitBreakerIPPacketType: + return ((cb__CircuitBreakerIPPacketType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerIPPacketType"); + case SOAP_TYPE_cb__CircuitBreakerIPv6Type: + return ((cb__CircuitBreakerIPv6Type *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerIPv6Type"); + case SOAP_TYPE_cb__CircuitBreakerIPv4Type: + return ((cb__CircuitBreakerIPv4Type *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerIPv4Type"); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType: + return ((cb__CircuitBreakerIPLayeredTCPFlagsType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerIPLayeredTCPFlagsType"); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType: + return ((cb__CircuitBreakerIPLayeredPortType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerIPLayeredPortType"); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType: + return ((cb__CircuitBreakerIPLayeredPortRangeType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerIPLayeredPortRangeType"); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType: + return ((cb__CircuitBreakerIPLayeredPortSimpleType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerIPLayeredPortSimpleType"); + case SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType: + return ((cb__CircuitBreakerIPv6AddressAndMaskType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerIPv6AddressAndMaskType"); + case SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType: + return ((cb__CircuitBreakerIPv4AddressAndMaskType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerIPv4AddressAndMaskType"); + case SOAP_TYPE_cb__CircuitBreakerPolicyInfoType: + return ((cb__CircuitBreakerPolicyInfoType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerPolicyInfoType"); + case SOAP_TYPE_cb__CircuitBreakerPolicyType: + return ((cb__CircuitBreakerPolicyType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerPolicyType"); + case SOAP_TYPE_cb__CircuitBreakerDefaultFilterType: + return ((cb__CircuitBreakerDefaultFilterType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerDefaultFilterType"); + case SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType: + return ((cb__CircuitBreakerAntiSpoofingFilterType *)ptr)->soap_out(soap, tag, id, "cb:CircuitBreakerAntiSpoofingFilterType"); + case SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse: + return ((_emi__GetGeneralAlertSubscriptionResponse *)ptr)->soap_out(soap, "emi:GetGeneralAlertSubscriptionResponse", id, NULL); + case SOAP_TYPE__emi__GetGeneralAlertSubscription: + return ((_emi__GetGeneralAlertSubscription *)ptr)->soap_out(soap, "emi:GetGeneralAlertSubscription", id, NULL); + case SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse: + return ((_emi__EnumerateGeneralAlertSubscriptionsResponse *)ptr)->soap_out(soap, "emi:EnumerateGeneralAlertSubscriptionsResponse", id, NULL); + case SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions: + return ((_emi__EnumerateGeneralAlertSubscriptions *)ptr)->soap_out(soap, "emi:EnumerateGeneralAlertSubscriptions", id, NULL); + case SOAP_TYPE__emi__SubscribeForGeneralAlertResponse: + return ((_emi__SubscribeForGeneralAlertResponse *)ptr)->soap_out(soap, "emi:SubscribeForGeneralAlertResponse", id, NULL); + case SOAP_TYPE__emi__SubscribeForGeneralAlert: + return ((_emi__SubscribeForGeneralAlert *)ptr)->soap_out(soap, "emi:SubscribeForGeneralAlert", id, NULL); + case SOAP_TYPE__emi__CancelAlertSubscriptionResponse: + return ((_emi__CancelAlertSubscriptionResponse *)ptr)->soap_out(soap, "emi:CancelAlertSubscriptionResponse", id, NULL); + case SOAP_TYPE__emi__CancelAlertSubscription: + return ((_emi__CancelAlertSubscription *)ptr)->soap_out(soap, "emi:CancelAlertSubscription", id, NULL); + case SOAP_TYPE__emi__GetSensorAttributesResponse: + return ((_emi__GetSensorAttributesResponse *)ptr)->soap_out(soap, "emi:GetSensorAttributesResponse", id, NULL); + case SOAP_TYPE__emi__GetSensorAttributes: + return ((_emi__GetSensorAttributes *)ptr)->soap_out(soap, "emi:GetSensorAttributes", id, NULL); + case SOAP_TYPE__emi__EnumerateSensorsResponse: + return ((_emi__EnumerateSensorsResponse *)ptr)->soap_out(soap, "emi:EnumerateSensorsResponse", id, NULL); + case SOAP_TYPE__emi__EnumerateSensors: + return ((_emi__EnumerateSensors *)ptr)->soap_out(soap, "emi:EnumerateSensors", id, NULL); + case SOAP_TYPE__emi__GetEventLogTimestampClockResponse: + return ((_emi__GetEventLogTimestampClockResponse *)ptr)->soap_out(soap, "emi:GetEventLogTimestampClockResponse", id, NULL); + case SOAP_TYPE__emi__GetEventLogTimestampClock: + return ((_emi__GetEventLogTimestampClock *)ptr)->soap_out(soap, "emi:GetEventLogTimestampClock", id, NULL); + case SOAP_TYPE__emi__SetEventLogTimestampClockResponse: + return ((_emi__SetEventLogTimestampClockResponse *)ptr)->soap_out(soap, "emi:SetEventLogTimestampClockResponse", id, NULL); + case SOAP_TYPE__emi__SetEventLogTimestampClock: + return ((_emi__SetEventLogTimestampClock *)ptr)->soap_out(soap, "emi:SetEventLogTimestampClock", id, NULL); + case SOAP_TYPE__emi__FreezeEventLogResponse: + return ((_emi__FreezeEventLogResponse *)ptr)->soap_out(soap, "emi:FreezeEventLogResponse", id, NULL); + case SOAP_TYPE__emi__FreezeEventLog: + return ((_emi__FreezeEventLog *)ptr)->soap_out(soap, "emi:FreezeEventLog", id, NULL); + case SOAP_TYPE__emi__ClearEventLogResponse: + return ((_emi__ClearEventLogResponse *)ptr)->soap_out(soap, "emi:ClearEventLogResponse", id, NULL); + case SOAP_TYPE__emi__ClearEventLog: + return ((_emi__ClearEventLog *)ptr)->soap_out(soap, "emi:ClearEventLog", id, NULL); + case SOAP_TYPE__emi__GetEventLogStatusResponse: + return ((_emi__GetEventLogStatusResponse *)ptr)->soap_out(soap, "emi:GetEventLogStatusResponse", id, NULL); + case SOAP_TYPE__emi__GetEventLogStatus: + return ((_emi__GetEventLogStatus *)ptr)->soap_out(soap, "emi:GetEventLogStatus", id, NULL); + case SOAP_TYPE__emi__ReadEventLogRecordsResponse: + return ((_emi__ReadEventLogRecordsResponse *)ptr)->soap_out(soap, "emi:ReadEventLogRecordsResponse", id, NULL); + case SOAP_TYPE__emi__ReadEventLogRecords: + return ((_emi__ReadEventLogRecords *)ptr)->soap_out(soap, "emi:ReadEventLogRecords", id, NULL); + case SOAP_TYPE__emi__RemoveEventFilterResponse: + return ((_emi__RemoveEventFilterResponse *)ptr)->soap_out(soap, "emi:RemoveEventFilterResponse", id, NULL); + case SOAP_TYPE__emi__RemoveEventFilter: + return ((_emi__RemoveEventFilter *)ptr)->soap_out(soap, "emi:RemoveEventFilter", id, NULL); + case SOAP_TYPE__emi__UpdateEventFilterResponse: + return ((_emi__UpdateEventFilterResponse *)ptr)->soap_out(soap, "emi:UpdateEventFilterResponse", id, NULL); + case SOAP_TYPE__emi__UpdateEventFilter: + return ((_emi__UpdateEventFilter *)ptr)->soap_out(soap, "emi:UpdateEventFilter", id, NULL); + case SOAP_TYPE__emi__GetEventFilterResponse: + return ((_emi__GetEventFilterResponse *)ptr)->soap_out(soap, "emi:GetEventFilterResponse", id, NULL); + case SOAP_TYPE__emi__GetEventFilter: + return ((_emi__GetEventFilter *)ptr)->soap_out(soap, "emi:GetEventFilter", id, NULL); + case SOAP_TYPE__emi__EnumerateEventFiltersResponse: + return ((_emi__EnumerateEventFiltersResponse *)ptr)->soap_out(soap, "emi:EnumerateEventFiltersResponse", id, NULL); + case SOAP_TYPE__emi__EnumerateEventFilters: + return ((_emi__EnumerateEventFilters *)ptr)->soap_out(soap, "emi:EnumerateEventFilters", id, NULL); + case SOAP_TYPE__emi__AddEventFilterResponse: + return ((_emi__AddEventFilterResponse *)ptr)->soap_out(soap, "emi:AddEventFilterResponse", id, NULL); + case SOAP_TYPE__emi__AddEventFilter: + return ((_emi__AddEventFilter *)ptr)->soap_out(soap, "emi:AddEventFilter", id, NULL); + case SOAP_TYPE__emi__GetAlertCommunityStringResponse: + return ((_emi__GetAlertCommunityStringResponse *)ptr)->soap_out(soap, "emi:GetAlertCommunityStringResponse", id, NULL); + case SOAP_TYPE__emi__GetAlertCommunityString: + return ((_emi__GetAlertCommunityString *)ptr)->soap_out(soap, "emi:GetAlertCommunityString", id, NULL); + case SOAP_TYPE__emi__SetAlertCommunityStringResponse: + return ((_emi__SetAlertCommunityStringResponse *)ptr)->soap_out(soap, "emi:SetAlertCommunityStringResponse", id, NULL); + case SOAP_TYPE__emi__SetAlertCommunityString: + return ((_emi__SetAlertCommunityString *)ptr)->soap_out(soap, "emi:SetAlertCommunityString", id, NULL); + case SOAP_TYPE__emi__EnumerateAlertPoliciesResponse: + return ((_emi__EnumerateAlertPoliciesResponse *)ptr)->soap_out(soap, "emi:EnumerateAlertPoliciesResponse", id, NULL); + case SOAP_TYPE__emi__EnumerateAlertPolicies: + return ((_emi__EnumerateAlertPolicies *)ptr)->soap_out(soap, "emi:EnumerateAlertPolicies", id, NULL); + case SOAP_TYPE__emi__GetAlertSubscriptionResponse: + return ((_emi__GetAlertSubscriptionResponse *)ptr)->soap_out(soap, "emi:GetAlertSubscriptionResponse", id, NULL); + case SOAP_TYPE__emi__GetAlertSubscription: + return ((_emi__GetAlertSubscription *)ptr)->soap_out(soap, "emi:GetAlertSubscription", id, NULL); + case SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse: + return ((_emi__EnumerateAlertSubscriptionsResponse *)ptr)->soap_out(soap, "emi:EnumerateAlertSubscriptionsResponse", id, NULL); + case SOAP_TYPE__emi__EnumerateAlertSubscriptions: + return ((_emi__EnumerateAlertSubscriptions *)ptr)->soap_out(soap, "emi:EnumerateAlertSubscriptions", id, NULL); + case SOAP_TYPE__emi__SubscribeForAlertResponse: + return ((_emi__SubscribeForAlertResponse *)ptr)->soap_out(soap, "emi:SubscribeForAlertResponse", id, NULL); + case SOAP_TYPE__emi__SubscribeForAlert: + return ((_emi__SubscribeForAlert *)ptr)->soap_out(soap, "emi:SubscribeForAlert", id, NULL); + case SOAP_TYPE_emi__AlertSubscriptionGeneralType: + return ((emi__AlertSubscriptionGeneralType *)ptr)->soap_out(soap, tag, id, "emi:AlertSubscriptionGeneralType"); + case SOAP_TYPE_emi__AlertSubscriptionSoapType: + return ((emi__AlertSubscriptionSoapType *)ptr)->soap_out(soap, tag, id, "emi:AlertSubscriptionSoapType"); + case SOAP_TYPE_emi__AlertSubscriptionSNMPType: + return ((emi__AlertSubscriptionSNMPType *)ptr)->soap_out(soap, tag, id, "emi:AlertSubscriptionSNMPType"); + case SOAP_TYPE_emi__AlertCredentialsType: + return ((emi__AlertCredentialsType *)ptr)->soap_out(soap, tag, id, "emi:AlertCredentialsType"); + case SOAP_TYPE_emi__ByteStr: + return ((emi__ByteStr *)ptr)->soap_out(soap, tag, id, "emi:ByteStr"); + case SOAP_TYPE_emi__SensorAttributesType: + return ((emi__SensorAttributesType *)ptr)->soap_out(soap, tag, id, "emi:SensorAttributesType"); + case SOAP_TYPE_emi__SensorHandleArrayType: + return ((emi__SensorHandleArrayType *)ptr)->soap_out(soap, tag, id, "emi:SensorHandleArrayType"); + case SOAP_TYPE_emi__EventLogRecordArrayType: + return ((emi__EventLogRecordArrayType *)ptr)->soap_out(soap, tag, id, "emi:EventLogRecordArrayType"); + case SOAP_TYPE_emi__EventFilterHandleArrayType: + return ((emi__EventFilterHandleArrayType *)ptr)->soap_out(soap, tag, id, "emi:EventFilterHandleArrayType"); + case SOAP_TYPE_emi__AlertSubscriptionHandleArrayType: + return ((emi__AlertSubscriptionHandleArrayType *)ptr)->soap_out(soap, tag, id, "emi:AlertSubscriptionHandleArrayType"); + case SOAP_TYPE_emi__AlertSubscriptionType: + return ((emi__AlertSubscriptionType *)ptr)->soap_out(soap, tag, id, "emi:AlertSubscriptionType"); + case SOAP_TYPE_emi__EventFilterType: + return ((emi__EventFilterType *)ptr)->soap_out(soap, tag, id, "emi:EventFilterType"); + case SOAP_TYPE_emi__EventLogRecordType: + return ((emi__EventLogRecordType *)ptr)->soap_out(soap, tag, id, "emi:EventLogRecordType"); + case SOAP_TYPE_emi__ByteData: + return ((emi__ByteData *)ptr)->soap_out(soap, tag, id, "emi:ByteData"); + case SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType: + return ((emi__AlertSubscriptionPolicyIDArrayType *)ptr)->soap_out(soap, tag, id, "emi:AlertSubscriptionPolicyIDArrayType"); + case SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse: + return ((_stra__RemoveStorageFpaclEntryResponse *)ptr)->soap_out(soap, "stra:RemoveStorageFpaclEntryResponse", id, NULL); + case SOAP_TYPE__stra__RemoveStorageFpaclEntry: + return ((_stra__RemoveStorageFpaclEntry *)ptr)->soap_out(soap, "stra:RemoveStorageFpaclEntry", id, NULL); + case SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse: + return ((_stra__UpdateStorageFpaclEntryResponse *)ptr)->soap_out(soap, "stra:UpdateStorageFpaclEntryResponse", id, NULL); + case SOAP_TYPE__stra__UpdateStorageFpaclEntry: + return ((_stra__UpdateStorageFpaclEntry *)ptr)->soap_out(soap, "stra:UpdateStorageFpaclEntry", id, NULL); + case SOAP_TYPE__stra__GetStorageAllocEntryResponse: + return ((_stra__GetStorageAllocEntryResponse *)ptr)->soap_out(soap, "stra:GetStorageAllocEntryResponse", id, NULL); + case SOAP_TYPE__stra__GetStorageAllocEntry: + return ((_stra__GetStorageAllocEntry *)ptr)->soap_out(soap, "stra:GetStorageAllocEntry", id, NULL); + case SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse: + return ((_stra__EnumerateStorageAllocEntriesResponse *)ptr)->soap_out(soap, "stra:EnumerateStorageAllocEntriesResponse", id, NULL); + case SOAP_TYPE__stra__EnumerateStorageAllocEntries: + return ((_stra__EnumerateStorageAllocEntries *)ptr)->soap_out(soap, "stra:EnumerateStorageAllocEntries", id, NULL); + case SOAP_TYPE__stra__AddStorageFpaclEntryResponse: + return ((_stra__AddStorageFpaclEntryResponse *)ptr)->soap_out(soap, "stra:AddStorageFpaclEntryResponse", id, NULL); + case SOAP_TYPE__stra__AddStorageFpaclEntry: + return ((_stra__AddStorageFpaclEntry *)ptr)->soap_out(soap, "stra:AddStorageFpaclEntry", id, NULL); + case SOAP_TYPE__stra__RemoveStorageEaclEntryResponse: + return ((_stra__RemoveStorageEaclEntryResponse *)ptr)->soap_out(soap, "stra:RemoveStorageEaclEntryResponse", id, NULL); + case SOAP_TYPE__stra__RemoveStorageEaclEntry: + return ((_stra__RemoveStorageEaclEntry *)ptr)->soap_out(soap, "stra:RemoveStorageEaclEntry", id, NULL); + case SOAP_TYPE__stra__GetStorageEaclEntryResponse: + return ((_stra__GetStorageEaclEntryResponse *)ptr)->soap_out(soap, "stra:GetStorageEaclEntryResponse", id, NULL); + case SOAP_TYPE__stra__GetStorageEaclEntry: + return ((_stra__GetStorageEaclEntry *)ptr)->soap_out(soap, "stra:GetStorageEaclEntry", id, NULL); + case SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse: + return ((_stra__EnumerateStorageEaclEntriesResponse *)ptr)->soap_out(soap, "stra:EnumerateStorageEaclEntriesResponse", id, NULL); + case SOAP_TYPE__stra__EnumerateStorageEaclEntries: + return ((_stra__EnumerateStorageEaclEntries *)ptr)->soap_out(soap, "stra:EnumerateStorageEaclEntries", id, NULL); + case SOAP_TYPE__stra__AddStorageEaclEntryResponse: + return ((_stra__AddStorageEaclEntryResponse *)ptr)->soap_out(soap, "stra:AddStorageEaclEntryResponse", id, NULL); + case SOAP_TYPE__stra__AddStorageEaclEntry: + return ((_stra__AddStorageEaclEntry *)ptr)->soap_out(soap, "stra:AddStorageEaclEntry", id, NULL); + case SOAP_TYPE__stra__AdminRemoveApplicationResponse: + return ((_stra__AdminRemoveApplicationResponse *)ptr)->soap_out(soap, "stra:AdminRemoveApplicationResponse", id, NULL); + case SOAP_TYPE__stra__AdminRemoveApplication: + return ((_stra__AdminRemoveApplication *)ptr)->soap_out(soap, "stra:AdminRemoveApplication", id, NULL); + case SOAP_TYPE__stra__AdminGetApplicationAttributesResponse: + return ((_stra__AdminGetApplicationAttributesResponse *)ptr)->soap_out(soap, "stra:AdminGetApplicationAttributesResponse", id, NULL); + case SOAP_TYPE__stra__AdminGetApplicationAttributes: + return ((_stra__AdminGetApplicationAttributes *)ptr)->soap_out(soap, "stra:AdminGetApplicationAttributes", id, NULL); + case SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse: + return ((_stra__AdminGetRegisteredApplicationsResponse *)ptr)->soap_out(soap, "stra:AdminGetRegisteredApplicationsResponse", id, NULL); + case SOAP_TYPE__stra__AdminGetRegisteredApplications: + return ((_stra__AdminGetRegisteredApplications *)ptr)->soap_out(soap, "stra:AdminGetRegisteredApplications", id, NULL); + case SOAP_TYPE__stra__SetGlobalStorageAttributesResponse: + return ((_stra__SetGlobalStorageAttributesResponse *)ptr)->soap_out(soap, "stra:SetGlobalStorageAttributesResponse", id, NULL); + case SOAP_TYPE__stra__SetGlobalStorageAttributes: + return ((_stra__SetGlobalStorageAttributes *)ptr)->soap_out(soap, "stra:SetGlobalStorageAttributes", id, NULL); + case SOAP_TYPE__stra__GetGlobalStorageAttributesResponse: + return ((_stra__GetGlobalStorageAttributesResponse *)ptr)->soap_out(soap, "stra:GetGlobalStorageAttributesResponse", id, NULL); + case SOAP_TYPE__stra__GetGlobalStorageAttributes: + return ((_stra__GetGlobalStorageAttributes *)ptr)->soap_out(soap, "stra:GetGlobalStorageAttributes", id, NULL); + case SOAP_TYPE_stra__StorageApplicationAttributesType: + return ((stra__StorageApplicationAttributesType *)ptr)->soap_out(soap, tag, id, "stra:StorageApplicationAttributesType"); + case SOAP_TYPE_stra__StorageSnrpApplicationAttributeType: + return ((stra__StorageSnrpApplicationAttributeType *)ptr)->soap_out(soap, tag, id, "stra:StorageSnrpApplicationAttributeType"); + case SOAP_TYPE_stra__StorageApplicationHandleListType: + return ((stra__StorageApplicationHandleListType *)ptr)->soap_out(soap, tag, id, "stra:StorageApplicationHandleListType"); + case SOAP_TYPE_stra__GlobalStorageAttributesType: + return ((stra__GlobalStorageAttributesType *)ptr)->soap_out(soap, tag, id, "stra:GlobalStorageAttributesType"); + case SOAP_TYPE_stra__GUID: + return ((stra__GUID *)ptr)->soap_out(soap, tag, id, "stra:GUID"); + case SOAP_TYPE_stra__StorageAllocEntryHandleListType: + return ((stra__StorageAllocEntryHandleListType *)ptr)->soap_out(soap, tag, id, "stra:StorageAllocEntryHandleListType"); + case SOAP_TYPE_stra__StorageAllocSnrpEntryType: + return ((stra__StorageAllocSnrpEntryType *)ptr)->soap_out(soap, tag, id, "stra:StorageAllocSnrpEntryType"); + case SOAP_TYPE_stra__StorageAllocEntryType: + return ((stra__StorageAllocEntryType *)ptr)->soap_out(soap, tag, id, "stra:StorageAllocEntryType"); + case SOAP_TYPE_stra__StorageEaclEntryHandleListType: + return ((stra__StorageEaclEntryHandleListType *)ptr)->soap_out(soap, tag, id, "stra:StorageEaclEntryHandleListType"); + case SOAP_TYPE_stra__StorageEaclEntryType: + return ((stra__StorageEaclEntryType *)ptr)->soap_out(soap, tag, id, "stra:StorageEaclEntryType"); + case SOAP_TYPE__net__Get8021XPxeTimeoutResponse: + return ((_net__Get8021XPxeTimeoutResponse *)ptr)->soap_out(soap, "net:Get8021XPxeTimeoutResponse", id, NULL); + case SOAP_TYPE__net__Get8021XPxeTimeout: + return ((_net__Get8021XPxeTimeout *)ptr)->soap_out(soap, "net:Get8021XPxeTimeout", id, NULL); + case SOAP_TYPE__net__Set8021XPxeTimeoutResponse: + return ((_net__Set8021XPxeTimeoutResponse *)ptr)->soap_out(soap, "net:Set8021XPxeTimeoutResponse", id, NULL); + case SOAP_TYPE__net__Set8021XPxeTimeout: + return ((_net__Set8021XPxeTimeout *)ptr)->soap_out(soap, "net:Set8021XPxeTimeout", id, NULL); + case SOAP_TYPE__net__Get8021XActiveS0Response: + return ((_net__Get8021XActiveS0Response *)ptr)->soap_out(soap, "net:Get8021XActiveS0Response", id, NULL); + case SOAP_TYPE__net__Get8021XActiveS0: + return ((_net__Get8021XActiveS0 *)ptr)->soap_out(soap, "net:Get8021XActiveS0", id, NULL); + case SOAP_TYPE__net__Set8021XActiveS0Response: + return ((_net__Set8021XActiveS0Response *)ptr)->soap_out(soap, "net:Set8021XActiveS0Response", id, NULL); + case SOAP_TYPE__net__Set8021XActiveS0: + return ((_net__Set8021XActiveS0 *)ptr)->soap_out(soap, "net:Set8021XActiveS0", id, NULL); + case SOAP_TYPE__net__Set8021XWiredProfileResponse: + return ((_net__Set8021XWiredProfileResponse *)ptr)->soap_out(soap, "net:Set8021XWiredProfileResponse", id, NULL); + case SOAP_TYPE__net__Set8021XWiredProfile: + return ((_net__Set8021XWiredProfile *)ptr)->soap_out(soap, "net:Set8021XWiredProfile", id, NULL); + case SOAP_TYPE__net__Get8021XWiredProfileResponse: + return ((_net__Get8021XWiredProfileResponse *)ptr)->soap_out(soap, "net:Get8021XWiredProfileResponse", id, NULL); + case SOAP_TYPE__net__Get8021XWiredProfile: + return ((_net__Get8021XWiredProfile *)ptr)->soap_out(soap, "net:Get8021XWiredProfile", id, NULL); + case SOAP_TYPE__net__SetInterfaceSettingsResponse: + return ((_net__SetInterfaceSettingsResponse *)ptr)->soap_out(soap, "net:SetInterfaceSettingsResponse", id, NULL); + case SOAP_TYPE__net__SetInterfaceSettings: + return ((_net__SetInterfaceSettings *)ptr)->soap_out(soap, "net:SetInterfaceSettings", id, NULL); + case SOAP_TYPE__net__GetInterfaceSettingsResponse: + return ((_net__GetInterfaceSettingsResponse *)ptr)->soap_out(soap, "net:GetInterfaceSettingsResponse", id, NULL); + case SOAP_TYPE__net__GetInterfaceSettings: + return ((_net__GetInterfaceSettings *)ptr)->soap_out(soap, "net:GetInterfaceSettings", id, NULL); + case SOAP_TYPE__net__EnumerateInterfacesResponse: + return ((_net__EnumerateInterfacesResponse *)ptr)->soap_out(soap, "net:EnumerateInterfacesResponse", id, NULL); + case SOAP_TYPE__net__EnumerateInterfaces: + return ((_net__EnumerateInterfaces *)ptr)->soap_out(soap, "net:EnumerateInterfaces", id, NULL); + case SOAP_TYPE__net__GetPingResponseResponse: + return ((_net__GetPingResponseResponse *)ptr)->soap_out(soap, "net:GetPingResponseResponse", id, NULL); + case SOAP_TYPE__net__GetPingResponse: + return ((_net__GetPingResponse *)ptr)->soap_out(soap, "net:GetPingResponse", id, NULL); + case SOAP_TYPE__net__SetPingResponseResponse: + return ((_net__SetPingResponseResponse *)ptr)->soap_out(soap, "net:SetPingResponseResponse", id, NULL); + case SOAP_TYPE__net__SetPingResponse: + return ((_net__SetPingResponse *)ptr)->soap_out(soap, "net:SetPingResponse", id, NULL); + case SOAP_TYPE__net__GetVlanParametersResponse: + return ((_net__GetVlanParametersResponse *)ptr)->soap_out(soap, "net:GetVlanParametersResponse", id, NULL); + case SOAP_TYPE__net__GetVlanParameters: + return ((_net__GetVlanParameters *)ptr)->soap_out(soap, "net:GetVlanParameters", id, NULL); + case SOAP_TYPE__net__SetVlanParametersResponse: + return ((_net__SetVlanParametersResponse *)ptr)->soap_out(soap, "net:SetVlanParametersResponse", id, NULL); + case SOAP_TYPE__net__SetVlanParameters: + return ((_net__SetVlanParameters *)ptr)->soap_out(soap, "net:SetVlanParameters", id, NULL); + case SOAP_TYPE__net__GetTcpIpParametersResponse: + return ((_net__GetTcpIpParametersResponse *)ptr)->soap_out(soap, "net:GetTcpIpParametersResponse", id, NULL); + case SOAP_TYPE__net__GetTcpIpParameters: + return ((_net__GetTcpIpParameters *)ptr)->soap_out(soap, "net:GetTcpIpParameters", id, NULL); + case SOAP_TYPE__net__SetTcpIpParametersResponse: + return ((_net__SetTcpIpParametersResponse *)ptr)->soap_out(soap, "net:SetTcpIpParametersResponse", id, NULL); + case SOAP_TYPE__net__SetTcpIpParameters: + return ((_net__SetTcpIpParameters *)ptr)->soap_out(soap, "net:SetTcpIpParameters", id, NULL); + case SOAP_TYPE__net__GetDomainNameResponse: + return ((_net__GetDomainNameResponse *)ptr)->soap_out(soap, "net:GetDomainNameResponse", id, NULL); + case SOAP_TYPE__net__GetDomainName: + return ((_net__GetDomainName *)ptr)->soap_out(soap, "net:GetDomainName", id, NULL); + case SOAP_TYPE__net__SetDomainNameResponse: + return ((_net__SetDomainNameResponse *)ptr)->soap_out(soap, "net:SetDomainNameResponse", id, NULL); + case SOAP_TYPE__net__SetDomainName: + return ((_net__SetDomainName *)ptr)->soap_out(soap, "net:SetDomainName", id, NULL); + case SOAP_TYPE__net__GetHostNameResponse: + return ((_net__GetHostNameResponse *)ptr)->soap_out(soap, "net:GetHostNameResponse", id, NULL); + case SOAP_TYPE__net__GetHostName: + return ((_net__GetHostName *)ptr)->soap_out(soap, "net:GetHostName", id, NULL); + case SOAP_TYPE__net__SetHostNameResponse: + return ((_net__SetHostNameResponse *)ptr)->soap_out(soap, "net:SetHostNameResponse", id, NULL); + case SOAP_TYPE__net__SetHostName: + return ((_net__SetHostName *)ptr)->soap_out(soap, "net:SetHostName", id, NULL); + case SOAP_TYPE_net__InterfaceDescriptorGetType: + return ((net__InterfaceDescriptorGetType *)ptr)->soap_out(soap, tag, id, "net:InterfaceDescriptorGetType"); + case SOAP_TYPE_net__InterfaceDescriptorSetType: + return ((net__InterfaceDescriptorSetType *)ptr)->soap_out(soap, tag, id, "net:InterfaceDescriptorSetType"); + case SOAP_TYPE_net__IPv4ParametersType: + return ((net__IPv4ParametersType *)ptr)->soap_out(soap, tag, id, "net:IPv4ParametersType"); + case SOAP_TYPE_net__StaticIPv4ParametersType: + return ((net__StaticIPv4ParametersType *)ptr)->soap_out(soap, tag, id, "net:StaticIPv4ParametersType"); + case SOAP_TYPE_xcfg__XProfileType: + return ((xcfg__XProfileType *)ptr)->soap_out(soap, tag, id, "xcfg:XProfileType"); + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType: + return ((xcfg__XProfileEAPFAST_USCORETLSType *)ptr)->soap_out(soap, tag, id, "xcfg:XProfileEAPFAST_TLSType"); + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType: + return ((xcfg__XProfileEAPFAST_USCOREGTCType *)ptr)->soap_out(soap, tag, id, "xcfg:XProfileEAPFAST_GTCType"); + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type: + return ((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *)ptr)->soap_out(soap, tag, id, "xcfg:XProfileEAPFAST_MSCHAPv2Type"); + case SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType: + return ((xcfg__XProfileEAP_USCOREGTCType *)ptr)->soap_out(soap, tag, id, "xcfg:XProfileEAP_GTCType"); + case SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type: + return ((xcfg__XProfilePEAP_USCOREMSCHAPv2Type *)ptr)->soap_out(soap, tag, id, "xcfg:XProfilePEAP_MSCHAPv2Type"); + case SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type: + return ((xcfg__XProfileTTLS_USCOREMSCHAPv2Type *)ptr)->soap_out(soap, tag, id, "xcfg:XProfileTTLS_MSCHAPv2Type"); + case SOAP_TYPE_xcfg__XProfileTLSType: + return ((xcfg__XProfileTLSType *)ptr)->soap_out(soap, tag, id, "xcfg:XProfileTLSType"); + case SOAP_TYPE_xcfg__ServerIdentityType: + return ((xcfg__ServerIdentityType *)ptr)->soap_out(soap, tag, id, "xcfg:ServerIdentityType"); + case SOAP_TYPE_xcfg__ManualPACType: + return ((xcfg__ManualPACType *)ptr)->soap_out(soap, tag, id, "xcfg:ManualPACType"); + case SOAP_TYPE_xcfg__CertificateNameType: + return ((xcfg__CertificateNameType *)ptr)->soap_out(soap, tag, id, "xcfg:CertificateNameType"); + case SOAP_TYPE_xcfg__UserCredentialsType: + return ((xcfg__UserCredentialsType *)ptr)->soap_out(soap, tag, id, "xcfg:UserCredentialsType"); + case SOAP_TYPE__sai__GetAclEnabledStateResponse: + return ((_sai__GetAclEnabledStateResponse *)ptr)->soap_out(soap, "sai:GetAclEnabledStateResponse", id, NULL); + case SOAP_TYPE__sai__GetAclEnabledState: + return ((_sai__GetAclEnabledState *)ptr)->soap_out(soap, "sai:GetAclEnabledState", id, NULL); + case SOAP_TYPE__sai__SetAclEnabledStateResponse: + return ((_sai__SetAclEnabledStateResponse *)ptr)->soap_out(soap, "sai:SetAclEnabledStateResponse", id, NULL); + case SOAP_TYPE__sai__SetAclEnabledState: + return ((_sai__SetAclEnabledState *)ptr)->soap_out(soap, "sai:SetAclEnabledState", id, NULL); + case SOAP_TYPE__sai__GetConfigurationServerFQDNResponse: + return ((_sai__GetConfigurationServerFQDNResponse *)ptr)->soap_out(soap, "sai:GetConfigurationServerFQDNResponse", id, NULL); + case SOAP_TYPE__sai__GetConfigurationServerFQDN: + return ((_sai__GetConfigurationServerFQDN *)ptr)->soap_out(soap, "sai:GetConfigurationServerFQDN", id, NULL); + case SOAP_TYPE__sai__SetConfigurationServerFQDNResponse: + return ((_sai__SetConfigurationServerFQDNResponse *)ptr)->soap_out(soap, "sai:SetConfigurationServerFQDNResponse", id, NULL); + case SOAP_TYPE__sai__SetConfigurationServerFQDN: + return ((_sai__SetConfigurationServerFQDN *)ptr)->soap_out(soap, "sai:SetConfigurationServerFQDN", id, NULL); + case SOAP_TYPE__sai__EnableVpnRoutingResponse: + return ((_sai__EnableVpnRoutingResponse *)ptr)->soap_out(soap, "sai:EnableVpnRoutingResponse", id, NULL); + case SOAP_TYPE__sai__EnableVpnRouting: + return ((_sai__EnableVpnRouting *)ptr)->soap_out(soap, "sai:EnableVpnRouting", id, NULL); + case SOAP_TYPE__sai__GetTLSCredentialsResponse: + return ((_sai__GetTLSCredentialsResponse *)ptr)->soap_out(soap, "sai:GetTLSCredentialsResponse", id, NULL); + case SOAP_TYPE__sai__GetTLSCredentials: + return ((_sai__GetTLSCredentials *)ptr)->soap_out(soap, "sai:GetTLSCredentials", id, NULL); + case SOAP_TYPE__sai__SetTLSCredentialsResponse: + return ((_sai__SetTLSCredentialsResponse *)ptr)->soap_out(soap, "sai:SetTLSCredentialsResponse", id, NULL); + case SOAP_TYPE__sai__SetTLSCredentials: + return ((_sai__SetTLSCredentials *)ptr)->soap_out(soap, "sai:SetTLSCredentials", id, NULL); + case SOAP_TYPE__sai__CertStoreUpdateCertificateResponse: + return ((_sai__CertStoreUpdateCertificateResponse *)ptr)->soap_out(soap, "sai:CertStoreUpdateCertificateResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreUpdateCertificate: + return ((_sai__CertStoreUpdateCertificate *)ptr)->soap_out(soap, "sai:CertStoreUpdateCertificate", id, NULL); + case SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse: + return ((_sai__CertStoreGetPKCS10RequestResponse *)ptr)->soap_out(soap, "sai:CertStoreGetPKCS10RequestResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreGetPKCS10Request: + return ((_sai__CertStoreGetPKCS10Request *)ptr)->soap_out(soap, "sai:CertStoreGetPKCS10Request", id, NULL); + case SOAP_TYPE__sai__CertStoreRemoveCertificateResponse: + return ((_sai__CertStoreRemoveCertificateResponse *)ptr)->soap_out(soap, "sai:CertStoreRemoveCertificateResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreRemoveCertificate: + return ((_sai__CertStoreRemoveCertificate *)ptr)->soap_out(soap, "sai:CertStoreRemoveCertificate", id, NULL); + case SOAP_TYPE__sai__CertStoreGetCertificateResponse: + return ((_sai__CertStoreGetCertificateResponse *)ptr)->soap_out(soap, "sai:CertStoreGetCertificateResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreGetCertificate: + return ((_sai__CertStoreGetCertificate *)ptr)->soap_out(soap, "sai:CertStoreGetCertificate", id, NULL); + case SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse: + return ((_sai__CertStoreEnumerateCertificatesResponse *)ptr)->soap_out(soap, "sai:CertStoreEnumerateCertificatesResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreEnumerateCertificates: + return ((_sai__CertStoreEnumerateCertificates *)ptr)->soap_out(soap, "sai:CertStoreEnumerateCertificates", id, NULL); + case SOAP_TYPE__sai__CertStoreAddCertificateResponse: + return ((_sai__CertStoreAddCertificateResponse *)ptr)->soap_out(soap, "sai:CertStoreAddCertificateResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreAddCertificate: + return ((_sai__CertStoreAddCertificate *)ptr)->soap_out(soap, "sai:CertStoreAddCertificate", id, NULL); + case SOAP_TYPE__sai__CertStoreRemoveKeyResponse: + return ((_sai__CertStoreRemoveKeyResponse *)ptr)->soap_out(soap, "sai:CertStoreRemoveKeyResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreRemoveKey: + return ((_sai__CertStoreRemoveKey *)ptr)->soap_out(soap, "sai:CertStoreRemoveKey", id, NULL); + case SOAP_TYPE__sai__CertStoreGetKeyResponse: + return ((_sai__CertStoreGetKeyResponse *)ptr)->soap_out(soap, "sai:CertStoreGetKeyResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreGetKey: + return ((_sai__CertStoreGetKey *)ptr)->soap_out(soap, "sai:CertStoreGetKey", id, NULL); + case SOAP_TYPE__sai__CertStoreEnumerateKeysResponse: + return ((_sai__CertStoreEnumerateKeysResponse *)ptr)->soap_out(soap, "sai:CertStoreEnumerateKeysResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreEnumerateKeys: + return ((_sai__CertStoreEnumerateKeys *)ptr)->soap_out(soap, "sai:CertStoreEnumerateKeys", id, NULL); + case SOAP_TYPE__sai__CertStoreAddKeyResponse: + return ((_sai__CertStoreAddKeyResponse *)ptr)->soap_out(soap, "sai:CertStoreAddKeyResponse", id, NULL); + case SOAP_TYPE__sai__CertStoreAddKey: + return ((_sai__CertStoreAddKey *)ptr)->soap_out(soap, "sai:CertStoreAddKey", id, NULL); + case SOAP_TYPE__sai__GetGlobalPowerPolicyResponse: + return ((_sai__GetGlobalPowerPolicyResponse *)ptr)->soap_out(soap, "sai:GetGlobalPowerPolicyResponse", id, NULL); + case SOAP_TYPE__sai__GetGlobalPowerPolicy: + return ((_sai__GetGlobalPowerPolicy *)ptr)->soap_out(soap, "sai:GetGlobalPowerPolicy", id, NULL); + case SOAP_TYPE__sai__SetGlobalPowerPolicyResponse: + return ((_sai__SetGlobalPowerPolicyResponse *)ptr)->soap_out(soap, "sai:SetGlobalPowerPolicyResponse", id, NULL); + case SOAP_TYPE__sai__SetGlobalPowerPolicy: + return ((_sai__SetGlobalPowerPolicy *)ptr)->soap_out(soap, "sai:SetGlobalPowerPolicy", id, NULL); + case SOAP_TYPE__sai__SetActivePowerPackageResponse: + return ((_sai__SetActivePowerPackageResponse *)ptr)->soap_out(soap, "sai:SetActivePowerPackageResponse", id, NULL); + case SOAP_TYPE__sai__SetActivePowerPackage: + return ((_sai__SetActivePowerPackage *)ptr)->soap_out(soap, "sai:SetActivePowerPackage", id, NULL); + case SOAP_TYPE__sai__GetPowerPackageResponse: + return ((_sai__GetPowerPackageResponse *)ptr)->soap_out(soap, "sai:GetPowerPackageResponse", id, NULL); + case SOAP_TYPE__sai__GetPowerPackage: + return ((_sai__GetPowerPackage *)ptr)->soap_out(soap, "sai:GetPowerPackage", id, NULL); + case SOAP_TYPE__sai__GetActivePowerPackageResponse: + return ((_sai__GetActivePowerPackageResponse *)ptr)->soap_out(soap, "sai:GetActivePowerPackageResponse", id, NULL); + case SOAP_TYPE__sai__GetActivePowerPackage: + return ((_sai__GetActivePowerPackage *)ptr)->soap_out(soap, "sai:GetActivePowerPackage", id, NULL); + case SOAP_TYPE__sai__EnumeratePowerPackagesResponse: + return ((_sai__EnumeratePowerPackagesResponse *)ptr)->soap_out(soap, "sai:EnumeratePowerPackagesResponse", id, NULL); + case SOAP_TYPE__sai__EnumeratePowerPackages: + return ((_sai__EnumeratePowerPackages *)ptr)->soap_out(soap, "sai:EnumeratePowerPackages", id, NULL); + case SOAP_TYPE__sai__GetEnvironmentDetectionResponse: + return ((_sai__GetEnvironmentDetectionResponse *)ptr)->soap_out(soap, "sai:GetEnvironmentDetectionResponse", id, NULL); + case SOAP_TYPE__sai__GetEnvironmentDetection: + return ((_sai__GetEnvironmentDetection *)ptr)->soap_out(soap, "sai:GetEnvironmentDetection", id, NULL); + case SOAP_TYPE__sai__SetEnvironmentDetectionResponse: + return ((_sai__SetEnvironmentDetectionResponse *)ptr)->soap_out(soap, "sai:SetEnvironmentDetectionResponse", id, NULL); + case SOAP_TYPE__sai__SetEnvironmentDetection: + return ((_sai__SetEnvironmentDetection *)ptr)->soap_out(soap, "sai:SetEnvironmentDetection", id, NULL); + case SOAP_TYPE__sai__SetRealmAuthOptionsResponse: + return ((_sai__SetRealmAuthOptionsResponse *)ptr)->soap_out(soap, "sai:SetRealmAuthOptionsResponse", id, NULL); + case SOAP_TYPE__sai__SetRealmAuthOptions: + return ((_sai__SetRealmAuthOptions *)ptr)->soap_out(soap, "sai:SetRealmAuthOptions", id, NULL); + case SOAP_TYPE__sai__GetRealmAuthOptionsResponse: + return ((_sai__GetRealmAuthOptionsResponse *)ptr)->soap_out(soap, "sai:GetRealmAuthOptionsResponse", id, NULL); + case SOAP_TYPE__sai__GetRealmAuthOptions: + return ((_sai__GetRealmAuthOptions *)ptr)->soap_out(soap, "sai:GetRealmAuthOptions", id, NULL); + case SOAP_TYPE__sai__ExtendProvisioningPeriodResponse: + return ((_sai__ExtendProvisioningPeriodResponse *)ptr)->soap_out(soap, "sai:ExtendProvisioningPeriodResponse", id, NULL); + case SOAP_TYPE__sai__ExtendProvisioningPeriod: + return ((_sai__ExtendProvisioningPeriod *)ptr)->soap_out(soap, "sai:ExtendProvisioningPeriod", id, NULL); + case SOAP_TYPE__sai__GetProvisioningPIDResponse: + return ((_sai__GetProvisioningPIDResponse *)ptr)->soap_out(soap, "sai:GetProvisioningPIDResponse", id, NULL); + case SOAP_TYPE__sai__GetProvisioningPID: + return ((_sai__GetProvisioningPID *)ptr)->soap_out(soap, "sai:GetProvisioningPID", id, NULL); + case SOAP_TYPE__sai__GetProvisioningAuditRecordResponse: + return ((_sai__GetProvisioningAuditRecordResponse *)ptr)->soap_out(soap, "sai:GetProvisioningAuditRecordResponse", id, NULL); + case SOAP_TYPE__sai__GetProvisioningAuditRecord: + return ((_sai__GetProvisioningAuditRecord *)ptr)->soap_out(soap, "sai:GetProvisioningAuditRecord", id, NULL); + case SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse: + return ((_sai__SetZeroTouchConfigurationModeResponse *)ptr)->soap_out(soap, "sai:SetZeroTouchConfigurationModeResponse", id, NULL); + case SOAP_TYPE__sai__SetZeroTouchConfigurationMode: + return ((_sai__SetZeroTouchConfigurationMode *)ptr)->soap_out(soap, "sai:SetZeroTouchConfigurationMode", id, NULL); + case SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse: + return ((_sai__GetZeroTouchConfigurationModeResponse *)ptr)->soap_out(soap, "sai:GetZeroTouchConfigurationModeResponse", id, NULL); + case SOAP_TYPE__sai__GetZeroTouchConfigurationMode: + return ((_sai__GetZeroTouchConfigurationMode *)ptr)->soap_out(soap, "sai:GetZeroTouchConfigurationMode", id, NULL); + case SOAP_TYPE__sai__EnableCertificateHashEntryResponse: + return ((_sai__EnableCertificateHashEntryResponse *)ptr)->soap_out(soap, "sai:EnableCertificateHashEntryResponse", id, NULL); + case SOAP_TYPE__sai__EnableCertificateHashEntry: + return ((_sai__EnableCertificateHashEntry *)ptr)->soap_out(soap, "sai:EnableCertificateHashEntry", id, NULL); + case SOAP_TYPE__sai__DeleteCertificateHashEntryResponse: + return ((_sai__DeleteCertificateHashEntryResponse *)ptr)->soap_out(soap, "sai:DeleteCertificateHashEntryResponse", id, NULL); + case SOAP_TYPE__sai__DeleteCertificateHashEntry: + return ((_sai__DeleteCertificateHashEntry *)ptr)->soap_out(soap, "sai:DeleteCertificateHashEntry", id, NULL); + case SOAP_TYPE__sai__AddCertificateHashEntryResponse: + return ((_sai__AddCertificateHashEntryResponse *)ptr)->soap_out(soap, "sai:AddCertificateHashEntryResponse", id, NULL); + case SOAP_TYPE__sai__AddCertificateHashEntry: + return ((_sai__AddCertificateHashEntry *)ptr)->soap_out(soap, "sai:AddCertificateHashEntry", id, NULL); + case SOAP_TYPE__sai__GetCertificateHashEntryResponse: + return ((_sai__GetCertificateHashEntryResponse *)ptr)->soap_out(soap, "sai:GetCertificateHashEntryResponse", id, NULL); + case SOAP_TYPE__sai__GetCertificateHashEntry: + return ((_sai__GetCertificateHashEntry *)ptr)->soap_out(soap, "sai:GetCertificateHashEntry", id, NULL); + case SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse: + return ((_sai__EnumerateCertificateHashEntriesResponse *)ptr)->soap_out(soap, "sai:EnumerateCertificateHashEntriesResponse", id, NULL); + case SOAP_TYPE__sai__EnumerateCertificateHashEntries: + return ((_sai__EnumerateCertificateHashEntries *)ptr)->soap_out(soap, "sai:EnumerateCertificateHashEntries", id, NULL); + case SOAP_TYPE__sai__GetProvisioningServerOTPResponse: + return ((_sai__GetProvisioningServerOTPResponse *)ptr)->soap_out(soap, "sai:GetProvisioningServerOTPResponse", id, NULL); + case SOAP_TYPE__sai__GetProvisioningServerOTP: + return ((_sai__GetProvisioningServerOTP *)ptr)->soap_out(soap, "sai:GetProvisioningServerOTP", id, NULL); + case SOAP_TYPE__sai__SetProvisioningServerOTPResponse: + return ((_sai__SetProvisioningServerOTPResponse *)ptr)->soap_out(soap, "sai:SetProvisioningServerOTPResponse", id, NULL); + case SOAP_TYPE__sai__SetProvisioningServerOTP: + return ((_sai__SetProvisioningServerOTP *)ptr)->soap_out(soap, "sai:SetProvisioningServerOTP", id, NULL); + case SOAP_TYPE__sai__SetMEBxPasswordResponse: + return ((_sai__SetMEBxPasswordResponse *)ptr)->soap_out(soap, "sai:SetMEBxPasswordResponse", id, NULL); + case SOAP_TYPE__sai__SetMEBxPassword: + return ((_sai__SetMEBxPassword *)ptr)->soap_out(soap, "sai:SetMEBxPassword", id, NULL); + case SOAP_TYPE__sai__PartialUnprovisionResponse: + return ((_sai__PartialUnprovisionResponse *)ptr)->soap_out(soap, "sai:PartialUnprovisionResponse", id, NULL); + case SOAP_TYPE__sai__PartialUnprovision: + return ((_sai__PartialUnprovision *)ptr)->soap_out(soap, "sai:PartialUnprovision", id, NULL); + case SOAP_TYPE__sai__SetTLSPSKResponse: + return ((_sai__SetTLSPSKResponse *)ptr)->soap_out(soap, "sai:SetTLSPSKResponse", id, NULL); + case SOAP_TYPE__sai__SetTLSPSK: + return ((_sai__SetTLSPSK *)ptr)->soap_out(soap, "sai:SetTLSPSK", id, NULL); + case SOAP_TYPE__sai__GetPowerSavingOptionsResponse: + return ((_sai__GetPowerSavingOptionsResponse *)ptr)->soap_out(soap, "sai:GetPowerSavingOptionsResponse", id, NULL); + case SOAP_TYPE__sai__GetPowerSavingOptions: + return ((_sai__GetPowerSavingOptions *)ptr)->soap_out(soap, "sai:GetPowerSavingOptions", id, NULL); + case SOAP_TYPE__sai__SetPowerSavingOptionsResponse: + return ((_sai__SetPowerSavingOptionsResponse *)ptr)->soap_out(soap, "sai:SetPowerSavingOptionsResponse", id, NULL); + case SOAP_TYPE__sai__SetPowerSavingOptions: + return ((_sai__SetPowerSavingOptions *)ptr)->soap_out(soap, "sai:SetPowerSavingOptions", id, NULL); + case SOAP_TYPE__sai__GetPkiCapabilitiesResponse: + return ((_sai__GetPkiCapabilitiesResponse *)ptr)->soap_out(soap, "sai:GetPkiCapabilitiesResponse", id, NULL); + case SOAP_TYPE__sai__GetPkiCapabilities: + return ((_sai__GetPkiCapabilities *)ptr)->soap_out(soap, "sai:GetPkiCapabilities", id, NULL); + case SOAP_TYPE__sai__GetServerCertificateReqResponse: + return ((_sai__GetServerCertificateReqResponse *)ptr)->soap_out(soap, "sai:GetServerCertificateReqResponse", id, NULL); + case SOAP_TYPE__sai__GetServerCertificateReq: + return ((_sai__GetServerCertificateReq *)ptr)->soap_out(soap, "sai:GetServerCertificateReq", id, NULL); + case SOAP_TYPE__sai__GetCRLResponse: + return ((_sai__GetCRLResponse *)ptr)->soap_out(soap, "sai:GetCRLResponse", id, NULL); + case SOAP_TYPE__sai__GetCRL: + return ((_sai__GetCRL *)ptr)->soap_out(soap, "sai:GetCRL", id, NULL); + case SOAP_TYPE__sai__SetCRLResponse: + return ((_sai__SetCRLResponse *)ptr)->soap_out(soap, "sai:SetCRLResponse", id, NULL); + case SOAP_TYPE__sai__SetCRL: + return ((_sai__SetCRL *)ptr)->soap_out(soap, "sai:SetCRL", id, NULL); + case SOAP_TYPE__sai__GetTrustedFqdnCNResponse: + return ((_sai__GetTrustedFqdnCNResponse *)ptr)->soap_out(soap, "sai:GetTrustedFqdnCNResponse", id, NULL); + case SOAP_TYPE__sai__GetTrustedFqdnCN: + return ((_sai__GetTrustedFqdnCN *)ptr)->soap_out(soap, "sai:GetTrustedFqdnCN", id, NULL); + case SOAP_TYPE__sai__SetTrustedFqdnCNResponse: + return ((_sai__SetTrustedFqdnCNResponse *)ptr)->soap_out(soap, "sai:SetTrustedFqdnCNResponse", id, NULL); + case SOAP_TYPE__sai__SetTrustedFqdnCN: + return ((_sai__SetTrustedFqdnCN *)ptr)->soap_out(soap, "sai:SetTrustedFqdnCN", id, NULL); + case SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse: + return ((_sai__EnumerateTrustedRootCertificatesResponse *)ptr)->soap_out(soap, "sai:EnumerateTrustedRootCertificatesResponse", id, NULL); + case SOAP_TYPE__sai__EnumerateTrustedRootCertificates: + return ((_sai__EnumerateTrustedRootCertificates *)ptr)->soap_out(soap, "sai:EnumerateTrustedRootCertificates", id, NULL); + case SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse: + return ((_sai__DeleteTrustedRootCertificateResponse *)ptr)->soap_out(soap, "sai:DeleteTrustedRootCertificateResponse", id, NULL); + case SOAP_TYPE__sai__DeleteTrustedRootCertificate: + return ((_sai__DeleteTrustedRootCertificate *)ptr)->soap_out(soap, "sai:DeleteTrustedRootCertificate", id, NULL); + case SOAP_TYPE__sai__GetTrustedRootCertificateResponse: + return ((_sai__GetTrustedRootCertificateResponse *)ptr)->soap_out(soap, "sai:GetTrustedRootCertificateResponse", id, NULL); + case SOAP_TYPE__sai__GetTrustedRootCertificate: + return ((_sai__GetTrustedRootCertificate *)ptr)->soap_out(soap, "sai:GetTrustedRootCertificate", id, NULL); + case SOAP_TYPE__sai__AddTrustedRootCertificateResponse: + return ((_sai__AddTrustedRootCertificateResponse *)ptr)->soap_out(soap, "sai:AddTrustedRootCertificateResponse", id, NULL); + case SOAP_TYPE__sai__AddTrustedRootCertificate: + return ((_sai__AddTrustedRootCertificate *)ptr)->soap_out(soap, "sai:AddTrustedRootCertificate", id, NULL); + case SOAP_TYPE__sai__GetTlsOptionsResponse: + return ((_sai__GetTlsOptionsResponse *)ptr)->soap_out(soap, "sai:GetTlsOptionsResponse", id, NULL); + case SOAP_TYPE__sai__GetTlsOptions: + return ((_sai__GetTlsOptions *)ptr)->soap_out(soap, "sai:GetTlsOptions", id, NULL); + case SOAP_TYPE__sai__SetTlsOptionsResponse: + return ((_sai__SetTlsOptionsResponse *)ptr)->soap_out(soap, "sai:SetTlsOptionsResponse", id, NULL); + case SOAP_TYPE__sai__SetTlsOptions: + return ((_sai__SetTlsOptions *)ptr)->soap_out(soap, "sai:SetTlsOptions", id, NULL); + case SOAP_TYPE__sai__GetEnabledInterfacesResponse: + return ((_sai__GetEnabledInterfacesResponse *)ptr)->soap_out(soap, "sai:GetEnabledInterfacesResponse", id, NULL); + case SOAP_TYPE__sai__GetEnabledInterfaces: + return ((_sai__GetEnabledInterfaces *)ptr)->soap_out(soap, "sai:GetEnabledInterfaces", id, NULL); + case SOAP_TYPE__sai__SetEnabledInterfacesResponse: + return ((_sai__SetEnabledInterfacesResponse *)ptr)->soap_out(soap, "sai:SetEnabledInterfacesResponse", id, NULL); + case SOAP_TYPE__sai__SetEnabledInterfaces: + return ((_sai__SetEnabledInterfaces *)ptr)->soap_out(soap, "sai:SetEnabledInterfaces", id, NULL); + case SOAP_TYPE__sai__GetKerberosOptionsResponse: + return ((_sai__GetKerberosOptionsResponse *)ptr)->soap_out(soap, "sai:GetKerberosOptionsResponse", id, NULL); + case SOAP_TYPE__sai__GetKerberosOptions: + return ((_sai__GetKerberosOptions *)ptr)->soap_out(soap, "sai:GetKerberosOptions", id, NULL); + case SOAP_TYPE__sai__SetKerberosOptionsResponse: + return ((_sai__SetKerberosOptionsResponse *)ptr)->soap_out(soap, "sai:SetKerberosOptionsResponse", id, NULL); + case SOAP_TYPE__sai__SetKerberosOptions: + return ((_sai__SetKerberosOptions *)ptr)->soap_out(soap, "sai:SetKerberosOptions", id, NULL); + case SOAP_TYPE__sai__GetDigestRealmResponse: + return ((_sai__GetDigestRealmResponse *)ptr)->soap_out(soap, "sai:GetDigestRealmResponse", id, NULL); + case SOAP_TYPE__sai__GetDigestRealm: + return ((_sai__GetDigestRealm *)ptr)->soap_out(soap, "sai:GetDigestRealm", id, NULL); + case SOAP_TYPE__sai__SetAdminAclEntryExResponse: + return ((_sai__SetAdminAclEntryExResponse *)ptr)->soap_out(soap, "sai:SetAdminAclEntryExResponse", id, NULL); + case SOAP_TYPE__sai__SetAdminAclEntryEx: + return ((_sai__SetAdminAclEntryEx *)ptr)->soap_out(soap, "sai:SetAdminAclEntryEx", id, NULL); + case SOAP_TYPE__sai__UpdateUserAclEntryExResponse: + return ((_sai__UpdateUserAclEntryExResponse *)ptr)->soap_out(soap, "sai:UpdateUserAclEntryExResponse", id, NULL); + case SOAP_TYPE__sai__UpdateUserAclEntryEx: + return ((_sai__UpdateUserAclEntryEx *)ptr)->soap_out(soap, "sai:UpdateUserAclEntryEx", id, NULL); + case SOAP_TYPE__sai__GetUserAclEntryExResponse: + return ((_sai__GetUserAclEntryExResponse *)ptr)->soap_out(soap, "sai:GetUserAclEntryExResponse", id, NULL); + case SOAP_TYPE__sai__GetUserAclEntryEx: + return ((_sai__GetUserAclEntryEx *)ptr)->soap_out(soap, "sai:GetUserAclEntryEx", id, NULL); + case SOAP_TYPE__sai__AddUserAclEntryExResponse: + return ((_sai__AddUserAclEntryExResponse *)ptr)->soap_out(soap, "sai:AddUserAclEntryExResponse", id, NULL); + case SOAP_TYPE__sai__AddUserAclEntryEx: + return ((_sai__AddUserAclEntryEx *)ptr)->soap_out(soap, "sai:AddUserAclEntryEx", id, NULL); + case SOAP_TYPE__sai__GetCoreVersionResponse: + return ((_sai__GetCoreVersionResponse *)ptr)->soap_out(soap, "sai:GetCoreVersionResponse", id, NULL); + case SOAP_TYPE__sai__GetCoreVersion: + return ((_sai__GetCoreVersion *)ptr)->soap_out(soap, "sai:GetCoreVersion", id, NULL); + case SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse: + return ((_sai__ResetFlashWearOutProtectionResponse *)ptr)->soap_out(soap, "sai:ResetFlashWearOutProtectionResponse", id, NULL); + case SOAP_TYPE__sai__ResetFlashWearOutProtection: + return ((_sai__ResetFlashWearOutProtection *)ptr)->soap_out(soap, "sai:ResetFlashWearOutProtection", id, NULL); + case SOAP_TYPE__sai__CommitChangesResponse: + return ((_sai__CommitChangesResponse *)ptr)->soap_out(soap, "sai:CommitChangesResponse", id, NULL); + case SOAP_TYPE__sai__CommitChanges: + return ((_sai__CommitChanges *)ptr)->soap_out(soap, "sai:CommitChanges", id, NULL); + case SOAP_TYPE__sai__UnprovisionResponse: + return ((_sai__UnprovisionResponse *)ptr)->soap_out(soap, "sai:UnprovisionResponse", id, NULL); + case SOAP_TYPE__sai__Unprovision: + return ((_sai__Unprovision *)ptr)->soap_out(soap, "sai:Unprovision", id, NULL); + case SOAP_TYPE__sai__SetProvisioningModeResponse: + return ((_sai__SetProvisioningModeResponse *)ptr)->soap_out(soap, "sai:SetProvisioningModeResponse", id, NULL); + case SOAP_TYPE__sai__SetProvisioningMode: + return ((_sai__SetProvisioningMode *)ptr)->soap_out(soap, "sai:SetProvisioningMode", id, NULL); + case SOAP_TYPE__sai__GetProvisioningModeResponse: + return ((_sai__GetProvisioningModeResponse *)ptr)->soap_out(soap, "sai:GetProvisioningModeResponse", id, NULL); + case SOAP_TYPE__sai__GetProvisioningMode: + return ((_sai__GetProvisioningMode *)ptr)->soap_out(soap, "sai:GetProvisioningMode", id, NULL); + case SOAP_TYPE__sai__UpdateCoreFromUrlResponse: + return ((_sai__UpdateCoreFromUrlResponse *)ptr)->soap_out(soap, "sai:UpdateCoreFromUrlResponse", id, NULL); + case SOAP_TYPE__sai__UpdateCoreFromUrl: + return ((_sai__UpdateCoreFromUrl *)ptr)->soap_out(soap, "sai:UpdateCoreFromUrl", id, NULL); + case SOAP_TYPE__sai__GetTLSCertificateResponse: + return ((_sai__GetTLSCertificateResponse *)ptr)->soap_out(soap, "sai:GetTLSCertificateResponse", id, NULL); + case SOAP_TYPE__sai__GetTLSCertificate: + return ((_sai__GetTLSCertificate *)ptr)->soap_out(soap, "sai:GetTLSCertificate", id, NULL); + case SOAP_TYPE__sai__SetTLSCertificateResponse: + return ((_sai__SetTLSCertificateResponse *)ptr)->soap_out(soap, "sai:SetTLSCertificateResponse", id, NULL); + case SOAP_TYPE__sai__SetTLSCertificate: + return ((_sai__SetTLSCertificate *)ptr)->soap_out(soap, "sai:SetTLSCertificate", id, NULL); + case SOAP_TYPE__sai__SetRngKeyResponse: + return ((_sai__SetRngKeyResponse *)ptr)->soap_out(soap, "sai:SetRngKeyResponse", id, NULL); + case SOAP_TYPE__sai__SetRngKey: + return ((_sai__SetRngKey *)ptr)->soap_out(soap, "sai:SetRngKey", id, NULL); + case SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse: + return ((_sai__SetTLSKeyAndCertificateResponse *)ptr)->soap_out(soap, "sai:SetTLSKeyAndCertificateResponse", id, NULL); + case SOAP_TYPE__sai__SetTLSKeyAndCertificate: + return ((_sai__SetTLSKeyAndCertificate *)ptr)->soap_out(soap, "sai:SetTLSKeyAndCertificate", id, NULL); + case SOAP_TYPE__sai__SetTlsEnabledResponse: + return ((_sai__SetTlsEnabledResponse *)ptr)->soap_out(soap, "sai:SetTlsEnabledResponse", id, NULL); + case SOAP_TYPE__sai__SetTlsEnabled: + return ((_sai__SetTlsEnabled *)ptr)->soap_out(soap, "sai:SetTlsEnabled", id, NULL); + case SOAP_TYPE__sai__RemoveUserAclEntryResponse: + return ((_sai__RemoveUserAclEntryResponse *)ptr)->soap_out(soap, "sai:RemoveUserAclEntryResponse", id, NULL); + case SOAP_TYPE__sai__RemoveUserAclEntry: + return ((_sai__RemoveUserAclEntry *)ptr)->soap_out(soap, "sai:RemoveUserAclEntry", id, NULL); + case SOAP_TYPE__sai__UpdateUserAclEntryResponse: + return ((_sai__UpdateUserAclEntryResponse *)ptr)->soap_out(soap, "sai:UpdateUserAclEntryResponse", id, NULL); + case SOAP_TYPE__sai__UpdateUserAclEntry: + return ((_sai__UpdateUserAclEntry *)ptr)->soap_out(soap, "sai:UpdateUserAclEntry", id, NULL); + case SOAP_TYPE__sai__GetAdminAclEntryResponse: + return ((_sai__GetAdminAclEntryResponse *)ptr)->soap_out(soap, "sai:GetAdminAclEntryResponse", id, NULL); + case SOAP_TYPE__sai__GetAdminAclEntry: + return ((_sai__GetAdminAclEntry *)ptr)->soap_out(soap, "sai:GetAdminAclEntry", id, NULL); + case SOAP_TYPE__sai__GetUserAclEntryResponse: + return ((_sai__GetUserAclEntryResponse *)ptr)->soap_out(soap, "sai:GetUserAclEntryResponse", id, NULL); + case SOAP_TYPE__sai__GetUserAclEntry: + return ((_sai__GetUserAclEntry *)ptr)->soap_out(soap, "sai:GetUserAclEntry", id, NULL); + case SOAP_TYPE__sai__EnumerateUserAclEntriesResponse: + return ((_sai__EnumerateUserAclEntriesResponse *)ptr)->soap_out(soap, "sai:EnumerateUserAclEntriesResponse", id, NULL); + case SOAP_TYPE__sai__EnumerateUserAclEntries: + return ((_sai__EnumerateUserAclEntries *)ptr)->soap_out(soap, "sai:EnumerateUserAclEntries", id, NULL); + case SOAP_TYPE__sai__SetAdminAclEntryResponse: + return ((_sai__SetAdminAclEntryResponse *)ptr)->soap_out(soap, "sai:SetAdminAclEntryResponse", id, NULL); + case SOAP_TYPE__sai__SetAdminAclEntry: + return ((_sai__SetAdminAclEntry *)ptr)->soap_out(soap, "sai:SetAdminAclEntry", id, NULL); + case SOAP_TYPE__sai__AddUserAclEntryResponse: + return ((_sai__AddUserAclEntryResponse *)ptr)->soap_out(soap, "sai:AddUserAclEntryResponse", id, NULL); + case SOAP_TYPE__sai__AddUserAclEntry: + return ((_sai__AddUserAclEntry *)ptr)->soap_out(soap, "sai:AddUserAclEntry", id, NULL); + case SOAP_TYPE_sai__GlobalPowerPolicyType: + return ((sai__GlobalPowerPolicyType *)ptr)->soap_out(soap, tag, id, "sai:GlobalPowerPolicyType"); + case SOAP_TYPE_sai__EnvironmentDetectionType: + return ((sai__EnvironmentDetectionType *)ptr)->soap_out(soap, tag, id, "sai:EnvironmentDetectionType"); + case SOAP_TYPE_sai__EnvironmentDetectionDomainType: + return ((sai__EnvironmentDetectionDomainType *)ptr)->soap_out(soap, tag, id, "sai:EnvironmentDetectionDomainType"); + case SOAP_TYPE_sai__ProvisioningAuditRecordType: + return ((sai__ProvisioningAuditRecordType *)ptr)->soap_out(soap, tag, id, "sai:ProvisioningAuditRecordType"); + case SOAP_TYPE_sai__CertHashEntryType: + return ((sai__CertHashEntryType *)ptr)->soap_out(soap, tag, id, "sai:CertHashEntryType"); + case SOAP_TYPE_sai__PkiCapsType: + return ((sai__PkiCapsType *)ptr)->soap_out(soap, tag, id, "sai:PkiCapsType"); + case SOAP_TYPE_sai__CrlType: + return ((sai__CrlType *)ptr)->soap_out(soap, tag, id, "sai:CrlType"); + case SOAP_TYPE_sai__CertificateType: + return ((sai__CertificateType *)ptr)->soap_out(soap, tag, id, "sai:CertificateType"); + case SOAP_TYPE_sai__TlsOptionsType: + return ((sai__TlsOptionsType *)ptr)->soap_out(soap, tag, id, "sai:TlsOptionsType"); + case SOAP_TYPE_sai__KerberosOptionsType: + return ((sai__KerberosOptionsType *)ptr)->soap_out(soap, tag, id, "sai:KerberosOptionsType"); + case SOAP_TYPE_sai__KerberosSpnType: + return ((sai__KerberosSpnType *)ptr)->soap_out(soap, tag, id, "sai:KerberosSpnType"); + case SOAP_TYPE_sai__AdminAclEntryExType: + return ((sai__AdminAclEntryExType *)ptr)->soap_out(soap, tag, id, "sai:AdminAclEntryExType"); + case SOAP_TYPE_sai__UserAclEntryExType: + return ((sai__UserAclEntryExType *)ptr)->soap_out(soap, tag, id, "sai:UserAclEntryExType"); + case SOAP_TYPE_sai__UserEntryKerberosType: + return ((sai__UserEntryKerberosType *)ptr)->soap_out(soap, tag, id, "sai:UserEntryKerberosType"); + case SOAP_TYPE_sai__UserEntryDigestType: + return ((sai__UserEntryDigestType *)ptr)->soap_out(soap, tag, id, "sai:UserEntryDigestType"); + case SOAP_TYPE_sai__AmtVersion: + return ((sai__AmtVersion *)ptr)->soap_out(soap, tag, id, "sai:AmtVersion"); + case SOAP_TYPE_sai__UpdateCoreUrlKeyType: + return ((sai__UpdateCoreUrlKeyType *)ptr)->soap_out(soap, tag, id, "sai:UpdateCoreUrlKeyType"); + case SOAP_TYPE_sai__CertificateChainType: + return ((sai__CertificateChainType *)ptr)->soap_out(soap, tag, id, "sai:CertificateChainType"); + case SOAP_TYPE_sai__RngKeyType: + return ((sai__RngKeyType *)ptr)->soap_out(soap, tag, id, "sai:RngKeyType"); + case SOAP_TYPE_sai__RsaKeyType: + return ((sai__RsaKeyType *)ptr)->soap_out(soap, tag, id, "sai:RsaKeyType"); + case SOAP_TYPE_sai__UserAclRealmListType: + return ((sai__UserAclRealmListType *)ptr)->soap_out(soap, tag, id, "sai:UserAclRealmListType"); + case SOAP_TYPE_sai__UserAclEntryHandleListType: + return ((sai__UserAclEntryHandleListType *)ptr)->soap_out(soap, tag, id, "sai:UserAclEntryHandleListType"); + case SOAP_TYPE_sai__AdminAclEntryType: + return ((sai__AdminAclEntryType *)ptr)->soap_out(soap, tag, id, "sai:AdminAclEntryType"); + case SOAP_TYPE_sai__UserAclEntryType: + return ((sai__UserAclEntryType *)ptr)->soap_out(soap, tag, id, "sai:UserAclEntryType"); + case SOAP_TYPE_cstr__KeyPairType: + return ((cstr__KeyPairType *)ptr)->soap_out(soap, tag, id, "cstr:KeyPairType"); + case SOAP_TYPE_cstr__RSAKeyPairType: + return ((cstr__RSAKeyPairType *)ptr)->soap_out(soap, tag, id, "cstr:RSAKeyPairType"); + case SOAP_TYPE_cmn__NodeAddressType: + return ((cmn__NodeAddressType *)ptr)->soap_out(soap, tag, id, "cmn:NodeAddressType"); + case SOAP_TYPE_cmn__URLType: + return ((cmn__URLType *)ptr)->soap_out(soap, tag, id, "cmn:URLType"); + case SOAP_TYPE_xsd__base64Binary: + return ((xsd__base64Binary *)ptr)->soap_out(soap, tag, id, "xsd:base64Binary"); + case SOAP_TYPE_xsd__anyURI: + return soap_out_xsd__anyURI(soap, tag, id, (const std::string *)ptr, "xsd:anyURI"); + case SOAP_TYPE_std__string: + return soap_out_std__string(soap, tag, id, (const std::string *)ptr, "xsd:string"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsResponse: + return soap_out_PointerTo_wcxs__GetWirelessSettingsResponse(soap, tag, id, (_wcxs__GetWirelessSettingsResponse *const*)ptr, "wcxs:GetWirelessSettingsResponse"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsRequest: + return soap_out_PointerTo_wcxs__GetWirelessSettingsRequest(soap, tag, id, (_wcxs__GetWirelessSettingsRequest *const*)ptr, "wcxs:GetWirelessSettingsRequest"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesResponse: + return soap_out_PointerTo_wcxs__GetWirelessCapabilitiesResponse(soap, tag, id, (_wcxs__GetWirelessCapabilitiesResponse *const*)ptr, "wcxs:GetWirelessCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesRequest: + return soap_out_PointerTo_wcxs__GetWirelessCapabilitiesRequest(soap, tag, id, (_wcxs__GetWirelessCapabilitiesRequest *const*)ptr, "wcxs:GetWirelessCapabilitiesRequest"); + case SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesResponse: + return soap_out_PointerTo_wcxs__EnumerateWirelessProfilesResponse(soap, tag, id, (_wcxs__EnumerateWirelessProfilesResponse *const*)ptr, "wcxs:EnumerateWirelessProfilesResponse"); + case SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesRequest: + return soap_out_PointerTo_wcxs__EnumerateWirelessProfilesRequest(soap, tag, id, (_wcxs__EnumerateWirelessProfilesRequest *const*)ptr, "wcxs:EnumerateWirelessProfilesRequest"); + case SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileResponse: + return soap_out_PointerTo_wcxs__UpdateWirelessProfileResponse(soap, tag, id, (_wcxs__UpdateWirelessProfileResponse *const*)ptr, "wcxs:UpdateWirelessProfileResponse"); + case SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileRequest: + return soap_out_PointerTo_wcxs__UpdateWirelessProfileRequest(soap, tag, id, (_wcxs__UpdateWirelessProfileRequest *const*)ptr, "wcxs:UpdateWirelessProfileRequest"); + case SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileResponse: + return soap_out_PointerTo_wcxs__RemoveWirelessProfileResponse(soap, tag, id, (_wcxs__RemoveWirelessProfileResponse *const*)ptr, "wcxs:RemoveWirelessProfileResponse"); + case SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileRequest: + return soap_out_PointerTo_wcxs__RemoveWirelessProfileRequest(soap, tag, id, (_wcxs__RemoveWirelessProfileRequest *const*)ptr, "wcxs:RemoveWirelessProfileRequest"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileResponse: + return soap_out_PointerTo_wcxs__GetWirelessProfileResponse(soap, tag, id, (_wcxs__GetWirelessProfileResponse *const*)ptr, "wcxs:GetWirelessProfileResponse"); + case SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileRequest: + return soap_out_PointerTo_wcxs__GetWirelessProfileRequest(soap, tag, id, (_wcxs__GetWirelessProfileRequest *const*)ptr, "wcxs:GetWirelessProfileRequest"); + case SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileResponse: + return soap_out_PointerTo_wcxs__AddWirelessProfileResponse(soap, tag, id, (_wcxs__AddWirelessProfileResponse *const*)ptr, "wcxs:AddWirelessProfileResponse"); + case SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileRequest: + return soap_out_PointerTo_wcxs__AddWirelessProfileRequest(soap, tag, id, (_wcxs__AddWirelessProfileRequest *const*)ptr, "wcxs:AddWirelessProfileRequest"); + case SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynchResponse: + return soap_out_PointerTo_tim__SetHighAccuracyTimeSynchResponse(soap, tag, id, (_tim__SetHighAccuracyTimeSynchResponse *const*)ptr, "tim:SetHighAccuracyTimeSynchResponse"); + case SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynch: + return soap_out_PointerTo_tim__SetHighAccuracyTimeSynch(soap, tag, id, (_tim__SetHighAccuracyTimeSynch *const*)ptr, "tim:SetHighAccuracyTimeSynch"); + case SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynchResponse: + return soap_out_PointerTo_tim__GetLowAccuracyTimeSynchResponse(soap, tag, id, (_tim__GetLowAccuracyTimeSynchResponse *const*)ptr, "tim:GetLowAccuracyTimeSynchResponse"); + case SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynch: + return soap_out_PointerTo_tim__GetLowAccuracyTimeSynch(soap, tag, id, (_tim__GetLowAccuracyTimeSynch *const*)ptr, "tim:GetLowAccuracyTimeSynch"); + case SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntryResponse: + return soap_out_PointerTo_stra__RemoveStorageFpaclEntryResponse(soap, tag, id, (_stra__RemoveStorageFpaclEntryResponse *const*)ptr, "stra:RemoveStorageFpaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntry: + return soap_out_PointerTo_stra__RemoveStorageFpaclEntry(soap, tag, id, (_stra__RemoveStorageFpaclEntry *const*)ptr, "stra:RemoveStorageFpaclEntry"); + case SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntryResponse: + return soap_out_PointerTo_stra__UpdateStorageFpaclEntryResponse(soap, tag, id, (_stra__UpdateStorageFpaclEntryResponse *const*)ptr, "stra:UpdateStorageFpaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntry: + return soap_out_PointerTo_stra__UpdateStorageFpaclEntry(soap, tag, id, (_stra__UpdateStorageFpaclEntry *const*)ptr, "stra:UpdateStorageFpaclEntry"); + case SOAP_TYPE_PointerTo_stra__GetStorageAllocEntryResponse: + return soap_out_PointerTo_stra__GetStorageAllocEntryResponse(soap, tag, id, (_stra__GetStorageAllocEntryResponse *const*)ptr, "stra:GetStorageAllocEntryResponse"); + case SOAP_TYPE_PointerTo_stra__GetStorageAllocEntry: + return soap_out_PointerTo_stra__GetStorageAllocEntry(soap, tag, id, (_stra__GetStorageAllocEntry *const*)ptr, "stra:GetStorageAllocEntry"); + case SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntriesResponse: + return soap_out_PointerTo_stra__EnumerateStorageAllocEntriesResponse(soap, tag, id, (_stra__EnumerateStorageAllocEntriesResponse *const*)ptr, "stra:EnumerateStorageAllocEntriesResponse"); + case SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntries: + return soap_out_PointerTo_stra__EnumerateStorageAllocEntries(soap, tag, id, (_stra__EnumerateStorageAllocEntries *const*)ptr, "stra:EnumerateStorageAllocEntries"); + case SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntryResponse: + return soap_out_PointerTo_stra__AddStorageFpaclEntryResponse(soap, tag, id, (_stra__AddStorageFpaclEntryResponse *const*)ptr, "stra:AddStorageFpaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntry: + return soap_out_PointerTo_stra__AddStorageFpaclEntry(soap, tag, id, (_stra__AddStorageFpaclEntry *const*)ptr, "stra:AddStorageFpaclEntry"); + case SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntryResponse: + return soap_out_PointerTo_stra__RemoveStorageEaclEntryResponse(soap, tag, id, (_stra__RemoveStorageEaclEntryResponse *const*)ptr, "stra:RemoveStorageEaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntry: + return soap_out_PointerTo_stra__RemoveStorageEaclEntry(soap, tag, id, (_stra__RemoveStorageEaclEntry *const*)ptr, "stra:RemoveStorageEaclEntry"); + case SOAP_TYPE_PointerTo_stra__GetStorageEaclEntryResponse: + return soap_out_PointerTo_stra__GetStorageEaclEntryResponse(soap, tag, id, (_stra__GetStorageEaclEntryResponse *const*)ptr, "stra:GetStorageEaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__GetStorageEaclEntry: + return soap_out_PointerTo_stra__GetStorageEaclEntry(soap, tag, id, (_stra__GetStorageEaclEntry *const*)ptr, "stra:GetStorageEaclEntry"); + case SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntriesResponse: + return soap_out_PointerTo_stra__EnumerateStorageEaclEntriesResponse(soap, tag, id, (_stra__EnumerateStorageEaclEntriesResponse *const*)ptr, "stra:EnumerateStorageEaclEntriesResponse"); + case SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntries: + return soap_out_PointerTo_stra__EnumerateStorageEaclEntries(soap, tag, id, (_stra__EnumerateStorageEaclEntries *const*)ptr, "stra:EnumerateStorageEaclEntries"); + case SOAP_TYPE_PointerTo_stra__AddStorageEaclEntryResponse: + return soap_out_PointerTo_stra__AddStorageEaclEntryResponse(soap, tag, id, (_stra__AddStorageEaclEntryResponse *const*)ptr, "stra:AddStorageEaclEntryResponse"); + case SOAP_TYPE_PointerTo_stra__AddStorageEaclEntry: + return soap_out_PointerTo_stra__AddStorageEaclEntry(soap, tag, id, (_stra__AddStorageEaclEntry *const*)ptr, "stra:AddStorageEaclEntry"); + case SOAP_TYPE_PointerTo_stra__AdminRemoveApplicationResponse: + return soap_out_PointerTo_stra__AdminRemoveApplicationResponse(soap, tag, id, (_stra__AdminRemoveApplicationResponse *const*)ptr, "stra:AdminRemoveApplicationResponse"); + case SOAP_TYPE_PointerTo_stra__AdminRemoveApplication: + return soap_out_PointerTo_stra__AdminRemoveApplication(soap, tag, id, (_stra__AdminRemoveApplication *const*)ptr, "stra:AdminRemoveApplication"); + case SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributesResponse: + return soap_out_PointerTo_stra__AdminGetApplicationAttributesResponse(soap, tag, id, (_stra__AdminGetApplicationAttributesResponse *const*)ptr, "stra:AdminGetApplicationAttributesResponse"); + case SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributes: + return soap_out_PointerTo_stra__AdminGetApplicationAttributes(soap, tag, id, (_stra__AdminGetApplicationAttributes *const*)ptr, "stra:AdminGetApplicationAttributes"); + case SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplicationsResponse: + return soap_out_PointerTo_stra__AdminGetRegisteredApplicationsResponse(soap, tag, id, (_stra__AdminGetRegisteredApplicationsResponse *const*)ptr, "stra:AdminGetRegisteredApplicationsResponse"); + case SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplications: + return soap_out_PointerTo_stra__AdminGetRegisteredApplications(soap, tag, id, (_stra__AdminGetRegisteredApplications *const*)ptr, "stra:AdminGetRegisteredApplications"); + case SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributesResponse: + return soap_out_PointerTo_stra__SetGlobalStorageAttributesResponse(soap, tag, id, (_stra__SetGlobalStorageAttributesResponse *const*)ptr, "stra:SetGlobalStorageAttributesResponse"); + case SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributes: + return soap_out_PointerTo_stra__SetGlobalStorageAttributes(soap, tag, id, (_stra__SetGlobalStorageAttributes *const*)ptr, "stra:SetGlobalStorageAttributes"); + case SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributesResponse: + return soap_out_PointerTo_stra__GetGlobalStorageAttributesResponse(soap, tag, id, (_stra__GetGlobalStorageAttributesResponse *const*)ptr, "stra:GetGlobalStorageAttributesResponse"); + case SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributes: + return soap_out_PointerTo_stra__GetGlobalStorageAttributes(soap, tag, id, (_stra__GetGlobalStorageAttributes *const*)ptr, "stra:GetGlobalStorageAttributes"); + case SOAP_TYPE_PointerTo_str__ExecuteStorageOperationResponse: + return soap_out_PointerTo_str__ExecuteStorageOperationResponse(soap, tag, id, (_str__ExecuteStorageOperationResponse *const*)ptr, "str:ExecuteStorageOperationResponse"); + case SOAP_TYPE_PointerTo_str__ExecuteStorageOperation: + return soap_out_PointerTo_str__ExecuteStorageOperation(soap, tag, id, (_str__ExecuteStorageOperation *const*)ptr, "str:ExecuteStorageOperation"); + case SOAP_TYPE_PointerTo_sai__GetAclEnabledStateResponse: + return soap_out_PointerTo_sai__GetAclEnabledStateResponse(soap, tag, id, (_sai__GetAclEnabledStateResponse *const*)ptr, "sai:GetAclEnabledStateResponse"); + case SOAP_TYPE_PointerTo_sai__GetAclEnabledState: + return soap_out_PointerTo_sai__GetAclEnabledState(soap, tag, id, (_sai__GetAclEnabledState *const*)ptr, "sai:GetAclEnabledState"); + case SOAP_TYPE_PointerTo_sai__SetAclEnabledStateResponse: + return soap_out_PointerTo_sai__SetAclEnabledStateResponse(soap, tag, id, (_sai__SetAclEnabledStateResponse *const*)ptr, "sai:SetAclEnabledStateResponse"); + case SOAP_TYPE_PointerTo_sai__SetAclEnabledState: + return soap_out_PointerTo_sai__SetAclEnabledState(soap, tag, id, (_sai__SetAclEnabledState *const*)ptr, "sai:SetAclEnabledState"); + case SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDNResponse: + return soap_out_PointerTo_sai__SetConfigurationServerFQDNResponse(soap, tag, id, (_sai__SetConfigurationServerFQDNResponse *const*)ptr, "sai:SetConfigurationServerFQDNResponse"); + case SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDN: + return soap_out_PointerTo_sai__SetConfigurationServerFQDN(soap, tag, id, (_sai__SetConfigurationServerFQDN *const*)ptr, "sai:SetConfigurationServerFQDN"); + case SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDNResponse: + return soap_out_PointerTo_sai__GetConfigurationServerFQDNResponse(soap, tag, id, (_sai__GetConfigurationServerFQDNResponse *const*)ptr, "sai:GetConfigurationServerFQDNResponse"); + case SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDN: + return soap_out_PointerTo_sai__GetConfigurationServerFQDN(soap, tag, id, (_sai__GetConfigurationServerFQDN *const*)ptr, "sai:GetConfigurationServerFQDN"); + case SOAP_TYPE_PointerTo_sai__EnableVpnRoutingResponse: + return soap_out_PointerTo_sai__EnableVpnRoutingResponse(soap, tag, id, (_sai__EnableVpnRoutingResponse *const*)ptr, "sai:EnableVpnRoutingResponse"); + case SOAP_TYPE_PointerTo_sai__EnableVpnRouting: + return soap_out_PointerTo_sai__EnableVpnRouting(soap, tag, id, (_sai__EnableVpnRouting *const*)ptr, "sai:EnableVpnRouting"); + case SOAP_TYPE_PointerTo_sai__GetTLSCredentialsResponse: + return soap_out_PointerTo_sai__GetTLSCredentialsResponse(soap, tag, id, (_sai__GetTLSCredentialsResponse *const*)ptr, "sai:GetTLSCredentialsResponse"); + case SOAP_TYPE_PointerTo_sai__GetTLSCredentials: + return soap_out_PointerTo_sai__GetTLSCredentials(soap, tag, id, (_sai__GetTLSCredentials *const*)ptr, "sai:GetTLSCredentials"); + case SOAP_TYPE_PointerTo_sai__SetTLSCredentialsResponse: + return soap_out_PointerTo_sai__SetTLSCredentialsResponse(soap, tag, id, (_sai__SetTLSCredentialsResponse *const*)ptr, "sai:SetTLSCredentialsResponse"); + case SOAP_TYPE_PointerTo_sai__SetTLSCredentials: + return soap_out_PointerTo_sai__SetTLSCredentials(soap, tag, id, (_sai__SetTLSCredentials *const*)ptr, "sai:SetTLSCredentials"); + case SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificateResponse: + return soap_out_PointerTo_sai__CertStoreUpdateCertificateResponse(soap, tag, id, (_sai__CertStoreUpdateCertificateResponse *const*)ptr, "sai:CertStoreUpdateCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificate: + return soap_out_PointerTo_sai__CertStoreUpdateCertificate(soap, tag, id, (_sai__CertStoreUpdateCertificate *const*)ptr, "sai:CertStoreUpdateCertificate"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10RequestResponse: + return soap_out_PointerTo_sai__CertStoreGetPKCS10RequestResponse(soap, tag, id, (_sai__CertStoreGetPKCS10RequestResponse *const*)ptr, "sai:CertStoreGetPKCS10RequestResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10Request: + return soap_out_PointerTo_sai__CertStoreGetPKCS10Request(soap, tag, id, (_sai__CertStoreGetPKCS10Request *const*)ptr, "sai:CertStoreGetPKCS10Request"); + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificateResponse: + return soap_out_PointerTo_sai__CertStoreRemoveCertificateResponse(soap, tag, id, (_sai__CertStoreRemoveCertificateResponse *const*)ptr, "sai:CertStoreRemoveCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificate: + return soap_out_PointerTo_sai__CertStoreRemoveCertificate(soap, tag, id, (_sai__CertStoreRemoveCertificate *const*)ptr, "sai:CertStoreRemoveCertificate"); + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificatesResponse: + return soap_out_PointerTo_sai__CertStoreEnumerateCertificatesResponse(soap, tag, id, (_sai__CertStoreEnumerateCertificatesResponse *const*)ptr, "sai:CertStoreEnumerateCertificatesResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificates: + return soap_out_PointerTo_sai__CertStoreEnumerateCertificates(soap, tag, id, (_sai__CertStoreEnumerateCertificates *const*)ptr, "sai:CertStoreEnumerateCertificates"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetCertificateResponse: + return soap_out_PointerTo_sai__CertStoreGetCertificateResponse(soap, tag, id, (_sai__CertStoreGetCertificateResponse *const*)ptr, "sai:CertStoreGetCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetCertificate: + return soap_out_PointerTo_sai__CertStoreGetCertificate(soap, tag, id, (_sai__CertStoreGetCertificate *const*)ptr, "sai:CertStoreGetCertificate"); + case SOAP_TYPE_PointerTo_sai__CertStoreAddCertificateResponse: + return soap_out_PointerTo_sai__CertStoreAddCertificateResponse(soap, tag, id, (_sai__CertStoreAddCertificateResponse *const*)ptr, "sai:CertStoreAddCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreAddCertificate: + return soap_out_PointerTo_sai__CertStoreAddCertificate(soap, tag, id, (_sai__CertStoreAddCertificate *const*)ptr, "sai:CertStoreAddCertificate"); + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveKeyResponse: + return soap_out_PointerTo_sai__CertStoreRemoveKeyResponse(soap, tag, id, (_sai__CertStoreRemoveKeyResponse *const*)ptr, "sai:CertStoreRemoveKeyResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveKey: + return soap_out_PointerTo_sai__CertStoreRemoveKey(soap, tag, id, (_sai__CertStoreRemoveKey *const*)ptr, "sai:CertStoreRemoveKey"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetKeyResponse: + return soap_out_PointerTo_sai__CertStoreGetKeyResponse(soap, tag, id, (_sai__CertStoreGetKeyResponse *const*)ptr, "sai:CertStoreGetKeyResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreGetKey: + return soap_out_PointerTo_sai__CertStoreGetKey(soap, tag, id, (_sai__CertStoreGetKey *const*)ptr, "sai:CertStoreGetKey"); + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeysResponse: + return soap_out_PointerTo_sai__CertStoreEnumerateKeysResponse(soap, tag, id, (_sai__CertStoreEnumerateKeysResponse *const*)ptr, "sai:CertStoreEnumerateKeysResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeys: + return soap_out_PointerTo_sai__CertStoreEnumerateKeys(soap, tag, id, (_sai__CertStoreEnumerateKeys *const*)ptr, "sai:CertStoreEnumerateKeys"); + case SOAP_TYPE_PointerTo_sai__CertStoreAddKeyResponse: + return soap_out_PointerTo_sai__CertStoreAddKeyResponse(soap, tag, id, (_sai__CertStoreAddKeyResponse *const*)ptr, "sai:CertStoreAddKeyResponse"); + case SOAP_TYPE_PointerTo_sai__CertStoreAddKey: + return soap_out_PointerTo_sai__CertStoreAddKey(soap, tag, id, (_sai__CertStoreAddKey *const*)ptr, "sai:CertStoreAddKey"); + case SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicyResponse: + return soap_out_PointerTo_sai__GetGlobalPowerPolicyResponse(soap, tag, id, (_sai__GetGlobalPowerPolicyResponse *const*)ptr, "sai:GetGlobalPowerPolicyResponse"); + case SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicy: + return soap_out_PointerTo_sai__GetGlobalPowerPolicy(soap, tag, id, (_sai__GetGlobalPowerPolicy *const*)ptr, "sai:GetGlobalPowerPolicy"); + case SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicyResponse: + return soap_out_PointerTo_sai__SetGlobalPowerPolicyResponse(soap, tag, id, (_sai__SetGlobalPowerPolicyResponse *const*)ptr, "sai:SetGlobalPowerPolicyResponse"); + case SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicy: + return soap_out_PointerTo_sai__SetGlobalPowerPolicy(soap, tag, id, (_sai__SetGlobalPowerPolicy *const*)ptr, "sai:SetGlobalPowerPolicy"); + case SOAP_TYPE_PointerTo_sai__SetActivePowerPackageResponse: + return soap_out_PointerTo_sai__SetActivePowerPackageResponse(soap, tag, id, (_sai__SetActivePowerPackageResponse *const*)ptr, "sai:SetActivePowerPackageResponse"); + case SOAP_TYPE_PointerTo_sai__SetActivePowerPackage: + return soap_out_PointerTo_sai__SetActivePowerPackage(soap, tag, id, (_sai__SetActivePowerPackage *const*)ptr, "sai:SetActivePowerPackage"); + case SOAP_TYPE_PointerTo_sai__GetActivePowerPackageResponse: + return soap_out_PointerTo_sai__GetActivePowerPackageResponse(soap, tag, id, (_sai__GetActivePowerPackageResponse *const*)ptr, "sai:GetActivePowerPackageResponse"); + case SOAP_TYPE_PointerTo_sai__GetActivePowerPackage: + return soap_out_PointerTo_sai__GetActivePowerPackage(soap, tag, id, (_sai__GetActivePowerPackage *const*)ptr, "sai:GetActivePowerPackage"); + case SOAP_TYPE_PointerTo_sai__GetPowerPackageResponse: + return soap_out_PointerTo_sai__GetPowerPackageResponse(soap, tag, id, (_sai__GetPowerPackageResponse *const*)ptr, "sai:GetPowerPackageResponse"); + case SOAP_TYPE_PointerTo_sai__GetPowerPackage: + return soap_out_PointerTo_sai__GetPowerPackage(soap, tag, id, (_sai__GetPowerPackage *const*)ptr, "sai:GetPowerPackage"); + case SOAP_TYPE_PointerTo_sai__EnumeratePowerPackagesResponse: + return soap_out_PointerTo_sai__EnumeratePowerPackagesResponse(soap, tag, id, (_sai__EnumeratePowerPackagesResponse *const*)ptr, "sai:EnumeratePowerPackagesResponse"); + case SOAP_TYPE_PointerTo_sai__EnumeratePowerPackages: + return soap_out_PointerTo_sai__EnumeratePowerPackages(soap, tag, id, (_sai__EnumeratePowerPackages *const*)ptr, "sai:EnumeratePowerPackages"); + case SOAP_TYPE_PointerTo_sai__GetEnvironmentDetectionResponse: + return soap_out_PointerTo_sai__GetEnvironmentDetectionResponse(soap, tag, id, (_sai__GetEnvironmentDetectionResponse *const*)ptr, "sai:GetEnvironmentDetectionResponse"); + case SOAP_TYPE_PointerTo_sai__GetEnvironmentDetection: + return soap_out_PointerTo_sai__GetEnvironmentDetection(soap, tag, id, (_sai__GetEnvironmentDetection *const*)ptr, "sai:GetEnvironmentDetection"); + case SOAP_TYPE_PointerTo_sai__SetEnvironmentDetectionResponse: + return soap_out_PointerTo_sai__SetEnvironmentDetectionResponse(soap, tag, id, (_sai__SetEnvironmentDetectionResponse *const*)ptr, "sai:SetEnvironmentDetectionResponse"); + case SOAP_TYPE_PointerTo_sai__SetEnvironmentDetection: + return soap_out_PointerTo_sai__SetEnvironmentDetection(soap, tag, id, (_sai__SetEnvironmentDetection *const*)ptr, "sai:SetEnvironmentDetection"); + case SOAP_TYPE_PointerTo_sai__SetRealmAuthOptionsResponse: + return soap_out_PointerTo_sai__SetRealmAuthOptionsResponse(soap, tag, id, (_sai__SetRealmAuthOptionsResponse *const*)ptr, "sai:SetRealmAuthOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__SetRealmAuthOptions: + return soap_out_PointerTo_sai__SetRealmAuthOptions(soap, tag, id, (_sai__SetRealmAuthOptions *const*)ptr, "sai:SetRealmAuthOptions"); + case SOAP_TYPE_PointerTo_sai__GetRealmAuthOptionsResponse: + return soap_out_PointerTo_sai__GetRealmAuthOptionsResponse(soap, tag, id, (_sai__GetRealmAuthOptionsResponse *const*)ptr, "sai:GetRealmAuthOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__GetRealmAuthOptions: + return soap_out_PointerTo_sai__GetRealmAuthOptions(soap, tag, id, (_sai__GetRealmAuthOptions *const*)ptr, "sai:GetRealmAuthOptions"); + case SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriodResponse: + return soap_out_PointerTo_sai__ExtendProvisioningPeriodResponse(soap, tag, id, (_sai__ExtendProvisioningPeriodResponse *const*)ptr, "sai:ExtendProvisioningPeriodResponse"); + case SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriod: + return soap_out_PointerTo_sai__ExtendProvisioningPeriod(soap, tag, id, (_sai__ExtendProvisioningPeriod *const*)ptr, "sai:ExtendProvisioningPeriod"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningPIDResponse: + return soap_out_PointerTo_sai__GetProvisioningPIDResponse(soap, tag, id, (_sai__GetProvisioningPIDResponse *const*)ptr, "sai:GetProvisioningPIDResponse"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningPID: + return soap_out_PointerTo_sai__GetProvisioningPID(soap, tag, id, (_sai__GetProvisioningPID *const*)ptr, "sai:GetProvisioningPID"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecordResponse: + return soap_out_PointerTo_sai__GetProvisioningAuditRecordResponse(soap, tag, id, (_sai__GetProvisioningAuditRecordResponse *const*)ptr, "sai:GetProvisioningAuditRecordResponse"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecord: + return soap_out_PointerTo_sai__GetProvisioningAuditRecord(soap, tag, id, (_sai__GetProvisioningAuditRecord *const*)ptr, "sai:GetProvisioningAuditRecord"); + case SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationModeResponse: + return soap_out_PointerTo_sai__SetZeroTouchConfigurationModeResponse(soap, tag, id, (_sai__SetZeroTouchConfigurationModeResponse *const*)ptr, "sai:SetZeroTouchConfigurationModeResponse"); + case SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationMode: + return soap_out_PointerTo_sai__SetZeroTouchConfigurationMode(soap, tag, id, (_sai__SetZeroTouchConfigurationMode *const*)ptr, "sai:SetZeroTouchConfigurationMode"); + case SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationModeResponse: + return soap_out_PointerTo_sai__GetZeroTouchConfigurationModeResponse(soap, tag, id, (_sai__GetZeroTouchConfigurationModeResponse *const*)ptr, "sai:GetZeroTouchConfigurationModeResponse"); + case SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationMode: + return soap_out_PointerTo_sai__GetZeroTouchConfigurationMode(soap, tag, id, (_sai__GetZeroTouchConfigurationMode *const*)ptr, "sai:GetZeroTouchConfigurationMode"); + case SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntryResponse: + return soap_out_PointerTo_sai__EnableCertificateHashEntryResponse(soap, tag, id, (_sai__EnableCertificateHashEntryResponse *const*)ptr, "sai:EnableCertificateHashEntryResponse"); + case SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntry: + return soap_out_PointerTo_sai__EnableCertificateHashEntry(soap, tag, id, (_sai__EnableCertificateHashEntry *const*)ptr, "sai:EnableCertificateHashEntry"); + case SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntryResponse: + return soap_out_PointerTo_sai__DeleteCertificateHashEntryResponse(soap, tag, id, (_sai__DeleteCertificateHashEntryResponse *const*)ptr, "sai:DeleteCertificateHashEntryResponse"); + case SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntry: + return soap_out_PointerTo_sai__DeleteCertificateHashEntry(soap, tag, id, (_sai__DeleteCertificateHashEntry *const*)ptr, "sai:DeleteCertificateHashEntry"); + case SOAP_TYPE_PointerTo_sai__AddCertificateHashEntryResponse: + return soap_out_PointerTo_sai__AddCertificateHashEntryResponse(soap, tag, id, (_sai__AddCertificateHashEntryResponse *const*)ptr, "sai:AddCertificateHashEntryResponse"); + case SOAP_TYPE_PointerTo_sai__AddCertificateHashEntry: + return soap_out_PointerTo_sai__AddCertificateHashEntry(soap, tag, id, (_sai__AddCertificateHashEntry *const*)ptr, "sai:AddCertificateHashEntry"); + case SOAP_TYPE_PointerTo_sai__GetCertificateHashEntryResponse: + return soap_out_PointerTo_sai__GetCertificateHashEntryResponse(soap, tag, id, (_sai__GetCertificateHashEntryResponse *const*)ptr, "sai:GetCertificateHashEntryResponse"); + case SOAP_TYPE_PointerTo_sai__GetCertificateHashEntry: + return soap_out_PointerTo_sai__GetCertificateHashEntry(soap, tag, id, (_sai__GetCertificateHashEntry *const*)ptr, "sai:GetCertificateHashEntry"); + case SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntriesResponse: + return soap_out_PointerTo_sai__EnumerateCertificateHashEntriesResponse(soap, tag, id, (_sai__EnumerateCertificateHashEntriesResponse *const*)ptr, "sai:EnumerateCertificateHashEntriesResponse"); + case SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntries: + return soap_out_PointerTo_sai__EnumerateCertificateHashEntries(soap, tag, id, (_sai__EnumerateCertificateHashEntries *const*)ptr, "sai:EnumerateCertificateHashEntries"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTPResponse: + return soap_out_PointerTo_sai__GetProvisioningServerOTPResponse(soap, tag, id, (_sai__GetProvisioningServerOTPResponse *const*)ptr, "sai:GetProvisioningServerOTPResponse"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTP: + return soap_out_PointerTo_sai__GetProvisioningServerOTP(soap, tag, id, (_sai__GetProvisioningServerOTP *const*)ptr, "sai:GetProvisioningServerOTP"); + case SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTPResponse: + return soap_out_PointerTo_sai__SetProvisioningServerOTPResponse(soap, tag, id, (_sai__SetProvisioningServerOTPResponse *const*)ptr, "sai:SetProvisioningServerOTPResponse"); + case SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTP: + return soap_out_PointerTo_sai__SetProvisioningServerOTP(soap, tag, id, (_sai__SetProvisioningServerOTP *const*)ptr, "sai:SetProvisioningServerOTP"); + case SOAP_TYPE_PointerTo_sai__SetMEBxPasswordResponse: + return soap_out_PointerTo_sai__SetMEBxPasswordResponse(soap, tag, id, (_sai__SetMEBxPasswordResponse *const*)ptr, "sai:SetMEBxPasswordResponse"); + case SOAP_TYPE_PointerTo_sai__SetMEBxPassword: + return soap_out_PointerTo_sai__SetMEBxPassword(soap, tag, id, (_sai__SetMEBxPassword *const*)ptr, "sai:SetMEBxPassword"); + case SOAP_TYPE_PointerTo_sai__PartialUnprovisionResponse: + return soap_out_PointerTo_sai__PartialUnprovisionResponse(soap, tag, id, (_sai__PartialUnprovisionResponse *const*)ptr, "sai:PartialUnprovisionResponse"); + case SOAP_TYPE_PointerTo_sai__PartialUnprovision: + return soap_out_PointerTo_sai__PartialUnprovision(soap, tag, id, (_sai__PartialUnprovision *const*)ptr, "sai:PartialUnprovision"); + case SOAP_TYPE_PointerTo_sai__SetTLSPSKResponse: + return soap_out_PointerTo_sai__SetTLSPSKResponse(soap, tag, id, (_sai__SetTLSPSKResponse *const*)ptr, "sai:SetTLSPSKResponse"); + case SOAP_TYPE_PointerTo_sai__SetTLSPSK: + return soap_out_PointerTo_sai__SetTLSPSK(soap, tag, id, (_sai__SetTLSPSK *const*)ptr, "sai:SetTLSPSK"); + case SOAP_TYPE_PointerTo_sai__GetPowerSavingOptionsResponse: + return soap_out_PointerTo_sai__GetPowerSavingOptionsResponse(soap, tag, id, (_sai__GetPowerSavingOptionsResponse *const*)ptr, "sai:GetPowerSavingOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__GetPowerSavingOptions: + return soap_out_PointerTo_sai__GetPowerSavingOptions(soap, tag, id, (_sai__GetPowerSavingOptions *const*)ptr, "sai:GetPowerSavingOptions"); + case SOAP_TYPE_PointerTo_sai__SetPowerSavingOptionsResponse: + return soap_out_PointerTo_sai__SetPowerSavingOptionsResponse(soap, tag, id, (_sai__SetPowerSavingOptionsResponse *const*)ptr, "sai:SetPowerSavingOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__SetPowerSavingOptions: + return soap_out_PointerTo_sai__SetPowerSavingOptions(soap, tag, id, (_sai__SetPowerSavingOptions *const*)ptr, "sai:SetPowerSavingOptions"); + case SOAP_TYPE_PointerTo_sai__GetPkiCapabilitiesResponse: + return soap_out_PointerTo_sai__GetPkiCapabilitiesResponse(soap, tag, id, (_sai__GetPkiCapabilitiesResponse *const*)ptr, "sai:GetPkiCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_sai__GetPkiCapabilities: + return soap_out_PointerTo_sai__GetPkiCapabilities(soap, tag, id, (_sai__GetPkiCapabilities *const*)ptr, "sai:GetPkiCapabilities"); + case SOAP_TYPE_PointerTo_sai__GetServerCertificateReqResponse: + return soap_out_PointerTo_sai__GetServerCertificateReqResponse(soap, tag, id, (_sai__GetServerCertificateReqResponse *const*)ptr, "sai:GetServerCertificateReqResponse"); + case SOAP_TYPE_PointerTo_sai__GetServerCertificateReq: + return soap_out_PointerTo_sai__GetServerCertificateReq(soap, tag, id, (_sai__GetServerCertificateReq *const*)ptr, "sai:GetServerCertificateReq"); + case SOAP_TYPE_PointerTo_sai__GetCRLResponse: + return soap_out_PointerTo_sai__GetCRLResponse(soap, tag, id, (_sai__GetCRLResponse *const*)ptr, "sai:GetCRLResponse"); + case SOAP_TYPE_PointerTo_sai__GetCRL: + return soap_out_PointerTo_sai__GetCRL(soap, tag, id, (_sai__GetCRL *const*)ptr, "sai:GetCRL"); + case SOAP_TYPE_PointerTo_sai__SetCRLResponse: + return soap_out_PointerTo_sai__SetCRLResponse(soap, tag, id, (_sai__SetCRLResponse *const*)ptr, "sai:SetCRLResponse"); + case SOAP_TYPE_PointerTo_sai__SetCRL: + return soap_out_PointerTo_sai__SetCRL(soap, tag, id, (_sai__SetCRL *const*)ptr, "sai:SetCRL"); + case SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCNResponse: + return soap_out_PointerTo_sai__GetTrustedFqdnCNResponse(soap, tag, id, (_sai__GetTrustedFqdnCNResponse *const*)ptr, "sai:GetTrustedFqdnCNResponse"); + case SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCN: + return soap_out_PointerTo_sai__GetTrustedFqdnCN(soap, tag, id, (_sai__GetTrustedFqdnCN *const*)ptr, "sai:GetTrustedFqdnCN"); + case SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCNResponse: + return soap_out_PointerTo_sai__SetTrustedFqdnCNResponse(soap, tag, id, (_sai__SetTrustedFqdnCNResponse *const*)ptr, "sai:SetTrustedFqdnCNResponse"); + case SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCN: + return soap_out_PointerTo_sai__SetTrustedFqdnCN(soap, tag, id, (_sai__SetTrustedFqdnCN *const*)ptr, "sai:SetTrustedFqdnCN"); + case SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificatesResponse: + return soap_out_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(soap, tag, id, (_sai__EnumerateTrustedRootCertificatesResponse *const*)ptr, "sai:EnumerateTrustedRootCertificatesResponse"); + case SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificates: + return soap_out_PointerTo_sai__EnumerateTrustedRootCertificates(soap, tag, id, (_sai__EnumerateTrustedRootCertificates *const*)ptr, "sai:EnumerateTrustedRootCertificates"); + case SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificateResponse: + return soap_out_PointerTo_sai__DeleteTrustedRootCertificateResponse(soap, tag, id, (_sai__DeleteTrustedRootCertificateResponse *const*)ptr, "sai:DeleteTrustedRootCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificate: + return soap_out_PointerTo_sai__DeleteTrustedRootCertificate(soap, tag, id, (_sai__DeleteTrustedRootCertificate *const*)ptr, "sai:DeleteTrustedRootCertificate"); + case SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificateResponse: + return soap_out_PointerTo_sai__GetTrustedRootCertificateResponse(soap, tag, id, (_sai__GetTrustedRootCertificateResponse *const*)ptr, "sai:GetTrustedRootCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificate: + return soap_out_PointerTo_sai__GetTrustedRootCertificate(soap, tag, id, (_sai__GetTrustedRootCertificate *const*)ptr, "sai:GetTrustedRootCertificate"); + case SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificateResponse: + return soap_out_PointerTo_sai__AddTrustedRootCertificateResponse(soap, tag, id, (_sai__AddTrustedRootCertificateResponse *const*)ptr, "sai:AddTrustedRootCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificate: + return soap_out_PointerTo_sai__AddTrustedRootCertificate(soap, tag, id, (_sai__AddTrustedRootCertificate *const*)ptr, "sai:AddTrustedRootCertificate"); + case SOAP_TYPE_PointerTo_sai__GetTlsOptionsResponse: + return soap_out_PointerTo_sai__GetTlsOptionsResponse(soap, tag, id, (_sai__GetTlsOptionsResponse *const*)ptr, "sai:GetTlsOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__GetTlsOptions: + return soap_out_PointerTo_sai__GetTlsOptions(soap, tag, id, (_sai__GetTlsOptions *const*)ptr, "sai:GetTlsOptions"); + case SOAP_TYPE_PointerTo_sai__SetTlsOptionsResponse: + return soap_out_PointerTo_sai__SetTlsOptionsResponse(soap, tag, id, (_sai__SetTlsOptionsResponse *const*)ptr, "sai:SetTlsOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__SetTlsOptions: + return soap_out_PointerTo_sai__SetTlsOptions(soap, tag, id, (_sai__SetTlsOptions *const*)ptr, "sai:SetTlsOptions"); + case SOAP_TYPE_PointerTo_sai__GetEnabledInterfacesResponse: + return soap_out_PointerTo_sai__GetEnabledInterfacesResponse(soap, tag, id, (_sai__GetEnabledInterfacesResponse *const*)ptr, "sai:GetEnabledInterfacesResponse"); + case SOAP_TYPE_PointerTo_sai__GetEnabledInterfaces: + return soap_out_PointerTo_sai__GetEnabledInterfaces(soap, tag, id, (_sai__GetEnabledInterfaces *const*)ptr, "sai:GetEnabledInterfaces"); + case SOAP_TYPE_PointerTo_sai__SetEnabledInterfacesResponse: + return soap_out_PointerTo_sai__SetEnabledInterfacesResponse(soap, tag, id, (_sai__SetEnabledInterfacesResponse *const*)ptr, "sai:SetEnabledInterfacesResponse"); + case SOAP_TYPE_PointerTo_sai__SetEnabledInterfaces: + return soap_out_PointerTo_sai__SetEnabledInterfaces(soap, tag, id, (_sai__SetEnabledInterfaces *const*)ptr, "sai:SetEnabledInterfaces"); + case SOAP_TYPE_PointerTo_sai__GetKerberosOptionsResponse: + return soap_out_PointerTo_sai__GetKerberosOptionsResponse(soap, tag, id, (_sai__GetKerberosOptionsResponse *const*)ptr, "sai:GetKerberosOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__GetKerberosOptions: + return soap_out_PointerTo_sai__GetKerberosOptions(soap, tag, id, (_sai__GetKerberosOptions *const*)ptr, "sai:GetKerberosOptions"); + case SOAP_TYPE_PointerTo_sai__SetKerberosOptionsResponse: + return soap_out_PointerTo_sai__SetKerberosOptionsResponse(soap, tag, id, (_sai__SetKerberosOptionsResponse *const*)ptr, "sai:SetKerberosOptionsResponse"); + case SOAP_TYPE_PointerTo_sai__SetKerberosOptions: + return soap_out_PointerTo_sai__SetKerberosOptions(soap, tag, id, (_sai__SetKerberosOptions *const*)ptr, "sai:SetKerberosOptions"); + case SOAP_TYPE_PointerTo_sai__GetDigestRealmResponse: + return soap_out_PointerTo_sai__GetDigestRealmResponse(soap, tag, id, (_sai__GetDigestRealmResponse *const*)ptr, "sai:GetDigestRealmResponse"); + case SOAP_TYPE_PointerTo_sai__GetDigestRealm: + return soap_out_PointerTo_sai__GetDigestRealm(soap, tag, id, (_sai__GetDigestRealm *const*)ptr, "sai:GetDigestRealm"); + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntryExResponse: + return soap_out_PointerTo_sai__SetAdminAclEntryExResponse(soap, tag, id, (_sai__SetAdminAclEntryExResponse *const*)ptr, "sai:SetAdminAclEntryExResponse"); + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntryEx: + return soap_out_PointerTo_sai__SetAdminAclEntryEx(soap, tag, id, (_sai__SetAdminAclEntryEx *const*)ptr, "sai:SetAdminAclEntryEx"); + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryExResponse: + return soap_out_PointerTo_sai__UpdateUserAclEntryExResponse(soap, tag, id, (_sai__UpdateUserAclEntryExResponse *const*)ptr, "sai:UpdateUserAclEntryExResponse"); + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryEx: + return soap_out_PointerTo_sai__UpdateUserAclEntryEx(soap, tag, id, (_sai__UpdateUserAclEntryEx *const*)ptr, "sai:UpdateUserAclEntryEx"); + case SOAP_TYPE_PointerTo_sai__GetUserAclEntryExResponse: + return soap_out_PointerTo_sai__GetUserAclEntryExResponse(soap, tag, id, (_sai__GetUserAclEntryExResponse *const*)ptr, "sai:GetUserAclEntryExResponse"); + case SOAP_TYPE_PointerTo_sai__GetUserAclEntryEx: + return soap_out_PointerTo_sai__GetUserAclEntryEx(soap, tag, id, (_sai__GetUserAclEntryEx *const*)ptr, "sai:GetUserAclEntryEx"); + case SOAP_TYPE_PointerTo_sai__AddUserAclEntryExResponse: + return soap_out_PointerTo_sai__AddUserAclEntryExResponse(soap, tag, id, (_sai__AddUserAclEntryExResponse *const*)ptr, "sai:AddUserAclEntryExResponse"); + case SOAP_TYPE_PointerTo_sai__AddUserAclEntryEx: + return soap_out_PointerTo_sai__AddUserAclEntryEx(soap, tag, id, (_sai__AddUserAclEntryEx *const*)ptr, "sai:AddUserAclEntryEx"); + case SOAP_TYPE_PointerTo_sai__GetCoreVersionResponse: + return soap_out_PointerTo_sai__GetCoreVersionResponse(soap, tag, id, (_sai__GetCoreVersionResponse *const*)ptr, "sai:GetCoreVersionResponse"); + case SOAP_TYPE_PointerTo_sai__GetCoreVersion: + return soap_out_PointerTo_sai__GetCoreVersion(soap, tag, id, (_sai__GetCoreVersion *const*)ptr, "sai:GetCoreVersion"); + case SOAP_TYPE_PointerTo_sai__CommitChangesResponse: + return soap_out_PointerTo_sai__CommitChangesResponse(soap, tag, id, (_sai__CommitChangesResponse *const*)ptr, "sai:CommitChangesResponse"); + case SOAP_TYPE_PointerTo_sai__CommitChanges: + return soap_out_PointerTo_sai__CommitChanges(soap, tag, id, (_sai__CommitChanges *const*)ptr, "sai:CommitChanges"); + case SOAP_TYPE_PointerTo_sai__UnprovisionResponse: + return soap_out_PointerTo_sai__UnprovisionResponse(soap, tag, id, (_sai__UnprovisionResponse *const*)ptr, "sai:UnprovisionResponse"); + case SOAP_TYPE_PointerTo_sai__Unprovision: + return soap_out_PointerTo_sai__Unprovision(soap, tag, id, (_sai__Unprovision *const*)ptr, "sai:Unprovision"); + case SOAP_TYPE_PointerTo_sai__SetProvisioningModeResponse: + return soap_out_PointerTo_sai__SetProvisioningModeResponse(soap, tag, id, (_sai__SetProvisioningModeResponse *const*)ptr, "sai:SetProvisioningModeResponse"); + case SOAP_TYPE_PointerTo_sai__SetProvisioningMode: + return soap_out_PointerTo_sai__SetProvisioningMode(soap, tag, id, (_sai__SetProvisioningMode *const*)ptr, "sai:SetProvisioningMode"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningModeResponse: + return soap_out_PointerTo_sai__GetProvisioningModeResponse(soap, tag, id, (_sai__GetProvisioningModeResponse *const*)ptr, "sai:GetProvisioningModeResponse"); + case SOAP_TYPE_PointerTo_sai__GetProvisioningMode: + return soap_out_PointerTo_sai__GetProvisioningMode(soap, tag, id, (_sai__GetProvisioningMode *const*)ptr, "sai:GetProvisioningMode"); + case SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrlResponse: + return soap_out_PointerTo_sai__UpdateCoreFromUrlResponse(soap, tag, id, (_sai__UpdateCoreFromUrlResponse *const*)ptr, "sai:UpdateCoreFromUrlResponse"); + case SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrl: + return soap_out_PointerTo_sai__UpdateCoreFromUrl(soap, tag, id, (_sai__UpdateCoreFromUrl *const*)ptr, "sai:UpdateCoreFromUrl"); + case SOAP_TYPE_PointerTo_sai__GetTLSCertificateResponse: + return soap_out_PointerTo_sai__GetTLSCertificateResponse(soap, tag, id, (_sai__GetTLSCertificateResponse *const*)ptr, "sai:GetTLSCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__GetTLSCertificate: + return soap_out_PointerTo_sai__GetTLSCertificate(soap, tag, id, (_sai__GetTLSCertificate *const*)ptr, "sai:GetTLSCertificate"); + case SOAP_TYPE_PointerTo_sai__SetTLSCertificateResponse: + return soap_out_PointerTo_sai__SetTLSCertificateResponse(soap, tag, id, (_sai__SetTLSCertificateResponse *const*)ptr, "sai:SetTLSCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__SetTLSCertificate: + return soap_out_PointerTo_sai__SetTLSCertificate(soap, tag, id, (_sai__SetTLSCertificate *const*)ptr, "sai:SetTLSCertificate"); + case SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificateResponse: + return soap_out_PointerTo_sai__SetTLSKeyAndCertificateResponse(soap, tag, id, (_sai__SetTLSKeyAndCertificateResponse *const*)ptr, "sai:SetTLSKeyAndCertificateResponse"); + case SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificate: + return soap_out_PointerTo_sai__SetTLSKeyAndCertificate(soap, tag, id, (_sai__SetTLSKeyAndCertificate *const*)ptr, "sai:SetTLSKeyAndCertificate"); + case SOAP_TYPE_PointerTo_sai__SetRngKeyResponse: + return soap_out_PointerTo_sai__SetRngKeyResponse(soap, tag, id, (_sai__SetRngKeyResponse *const*)ptr, "sai:SetRngKeyResponse"); + case SOAP_TYPE_PointerTo_sai__SetRngKey: + return soap_out_PointerTo_sai__SetRngKey(soap, tag, id, (_sai__SetRngKey *const*)ptr, "sai:SetRngKey"); + case SOAP_TYPE_PointerTo_sai__SetTlsEnabledResponse: + return soap_out_PointerTo_sai__SetTlsEnabledResponse(soap, tag, id, (_sai__SetTlsEnabledResponse *const*)ptr, "sai:SetTlsEnabledResponse"); + case SOAP_TYPE_PointerTo_sai__SetTlsEnabled: + return soap_out_PointerTo_sai__SetTlsEnabled(soap, tag, id, (_sai__SetTlsEnabled *const*)ptr, "sai:SetTlsEnabled"); + case SOAP_TYPE_PointerTo_sai__RemoveUserAclEntryResponse: + return soap_out_PointerTo_sai__RemoveUserAclEntryResponse(soap, tag, id, (_sai__RemoveUserAclEntryResponse *const*)ptr, "sai:RemoveUserAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__RemoveUserAclEntry: + return soap_out_PointerTo_sai__RemoveUserAclEntry(soap, tag, id, (_sai__RemoveUserAclEntry *const*)ptr, "sai:RemoveUserAclEntry"); + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryResponse: + return soap_out_PointerTo_sai__UpdateUserAclEntryResponse(soap, tag, id, (_sai__UpdateUserAclEntryResponse *const*)ptr, "sai:UpdateUserAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntry: + return soap_out_PointerTo_sai__UpdateUserAclEntry(soap, tag, id, (_sai__UpdateUserAclEntry *const*)ptr, "sai:UpdateUserAclEntry"); + case SOAP_TYPE_PointerTo_sai__GetUserAclEntryResponse: + return soap_out_PointerTo_sai__GetUserAclEntryResponse(soap, tag, id, (_sai__GetUserAclEntryResponse *const*)ptr, "sai:GetUserAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__GetUserAclEntry: + return soap_out_PointerTo_sai__GetUserAclEntry(soap, tag, id, (_sai__GetUserAclEntry *const*)ptr, "sai:GetUserAclEntry"); + case SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntriesResponse: + return soap_out_PointerTo_sai__EnumerateUserAclEntriesResponse(soap, tag, id, (_sai__EnumerateUserAclEntriesResponse *const*)ptr, "sai:EnumerateUserAclEntriesResponse"); + case SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntries: + return soap_out_PointerTo_sai__EnumerateUserAclEntries(soap, tag, id, (_sai__EnumerateUserAclEntries *const*)ptr, "sai:EnumerateUserAclEntries"); + case SOAP_TYPE_PointerTo_sai__AddUserAclEntryResponse: + return soap_out_PointerTo_sai__AddUserAclEntryResponse(soap, tag, id, (_sai__AddUserAclEntryResponse *const*)ptr, "sai:AddUserAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__AddUserAclEntry: + return soap_out_PointerTo_sai__AddUserAclEntry(soap, tag, id, (_sai__AddUserAclEntry *const*)ptr, "sai:AddUserAclEntry"); + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntryResponse: + return soap_out_PointerTo_sai__SetAdminAclEntryResponse(soap, tag, id, (_sai__SetAdminAclEntryResponse *const*)ptr, "sai:SetAdminAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntry: + return soap_out_PointerTo_sai__SetAdminAclEntry(soap, tag, id, (_sai__SetAdminAclEntry *const*)ptr, "sai:SetAdminAclEntry"); + case SOAP_TYPE_PointerTo_sai__GetAdminAclEntryResponse: + return soap_out_PointerTo_sai__GetAdminAclEntryResponse(soap, tag, id, (_sai__GetAdminAclEntryResponse *const*)ptr, "sai:GetAdminAclEntryResponse"); + case SOAP_TYPE_PointerTo_sai__GetAdminAclEntry: + return soap_out_PointerTo_sai__GetAdminAclEntry(soap, tag, id, (_sai__GetAdminAclEntry *const*)ptr, "sai:GetAdminAclEntry"); + case SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtectionResponse: + return soap_out_PointerTo_sai__ResetFlashWearOutProtectionResponse(soap, tag, id, (_sai__ResetFlashWearOutProtectionResponse *const*)ptr, "sai:ResetFlashWearOutProtectionResponse"); + case SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtection: + return soap_out_PointerTo_sai__ResetFlashWearOutProtection(soap, tag, id, (_sai__ResetFlashWearOutProtection *const*)ptr, "sai:ResetFlashWearOutProtection"); + case SOAP_TYPE_PointerTo_rci__GetSystemPowerStateResponse: + return soap_out_PointerTo_rci__GetSystemPowerStateResponse(soap, tag, id, (_rci__GetSystemPowerStateResponse *const*)ptr, "rci:GetSystemPowerStateResponse"); + case SOAP_TYPE_PointerTo_rci__GetSystemPowerState: + return soap_out_PointerTo_rci__GetSystemPowerState(soap, tag, id, (_rci__GetSystemPowerState *const*)ptr, "rci:GetSystemPowerState"); + case SOAP_TYPE_PointerTo_rci__RemoteControlResponse: + return soap_out_PointerTo_rci__RemoteControlResponse(soap, tag, id, (_rci__RemoteControlResponse *const*)ptr, "rci:RemoteControlResponse"); + case SOAP_TYPE_PointerTo_rci__RemoteControl: + return soap_out_PointerTo_rci__RemoteControl(soap, tag, id, (_rci__RemoteControl *const*)ptr, "rci:RemoteControl"); + case SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilitiesResponse: + return soap_out_PointerTo_rci__GetRemoteControlCapabilitiesResponse(soap, tag, id, (_rci__GetRemoteControlCapabilitiesResponse *const*)ptr, "rci:GetRemoteControlCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilities: + return soap_out_PointerTo_rci__GetRemoteControlCapabilities(soap, tag, id, (_rci__GetRemoteControlCapabilities *const*)ptr, "rci:GetRemoteControlCapabilities"); + case SOAP_TYPE_PointerTo_net__Get8021XPxeTimeoutResponse: + return soap_out_PointerTo_net__Get8021XPxeTimeoutResponse(soap, tag, id, (_net__Get8021XPxeTimeoutResponse *const*)ptr, "net:Get8021XPxeTimeoutResponse"); + case SOAP_TYPE_PointerTo_net__Get8021XPxeTimeout: + return soap_out_PointerTo_net__Get8021XPxeTimeout(soap, tag, id, (_net__Get8021XPxeTimeout *const*)ptr, "net:Get8021XPxeTimeout"); + case SOAP_TYPE_PointerTo_net__Set8021XPxeTimeoutResponse: + return soap_out_PointerTo_net__Set8021XPxeTimeoutResponse(soap, tag, id, (_net__Set8021XPxeTimeoutResponse *const*)ptr, "net:Set8021XPxeTimeoutResponse"); + case SOAP_TYPE_PointerTo_net__Set8021XPxeTimeout: + return soap_out_PointerTo_net__Set8021XPxeTimeout(soap, tag, id, (_net__Set8021XPxeTimeout *const*)ptr, "net:Set8021XPxeTimeout"); + case SOAP_TYPE_PointerTo_net__Get8021XActiveS0Response: + return soap_out_PointerTo_net__Get8021XActiveS0Response(soap, tag, id, (_net__Get8021XActiveS0Response *const*)ptr, "net:Get8021XActiveS0Response"); + case SOAP_TYPE_PointerTo_net__Get8021XActiveS0: + return soap_out_PointerTo_net__Get8021XActiveS0(soap, tag, id, (_net__Get8021XActiveS0 *const*)ptr, "net:Get8021XActiveS0"); + case SOAP_TYPE_PointerTo_net__Set8021XActiveS0Response: + return soap_out_PointerTo_net__Set8021XActiveS0Response(soap, tag, id, (_net__Set8021XActiveS0Response *const*)ptr, "net:Set8021XActiveS0Response"); + case SOAP_TYPE_PointerTo_net__Set8021XActiveS0: + return soap_out_PointerTo_net__Set8021XActiveS0(soap, tag, id, (_net__Set8021XActiveS0 *const*)ptr, "net:Set8021XActiveS0"); + case SOAP_TYPE_PointerTo_net__Get8021XWiredProfileResponse: + return soap_out_PointerTo_net__Get8021XWiredProfileResponse(soap, tag, id, (_net__Get8021XWiredProfileResponse *const*)ptr, "net:Get8021XWiredProfileResponse"); + case SOAP_TYPE_PointerTo_net__Get8021XWiredProfile: + return soap_out_PointerTo_net__Get8021XWiredProfile(soap, tag, id, (_net__Get8021XWiredProfile *const*)ptr, "net:Get8021XWiredProfile"); + case SOAP_TYPE_PointerTo_net__Set8021XWiredProfileResponse: + return soap_out_PointerTo_net__Set8021XWiredProfileResponse(soap, tag, id, (_net__Set8021XWiredProfileResponse *const*)ptr, "net:Set8021XWiredProfileResponse"); + case SOAP_TYPE_PointerTo_net__Set8021XWiredProfile: + return soap_out_PointerTo_net__Set8021XWiredProfile(soap, tag, id, (_net__Set8021XWiredProfile *const*)ptr, "net:Set8021XWiredProfile"); + case SOAP_TYPE_PointerTo_net__SetInterfaceSettingsResponse: + return soap_out_PointerTo_net__SetInterfaceSettingsResponse(soap, tag, id, (_net__SetInterfaceSettingsResponse *const*)ptr, "net:SetInterfaceSettingsResponse"); + case SOAP_TYPE_PointerTo_net__SetInterfaceSettings: + return soap_out_PointerTo_net__SetInterfaceSettings(soap, tag, id, (_net__SetInterfaceSettings *const*)ptr, "net:SetInterfaceSettings"); + case SOAP_TYPE_PointerTo_net__GetInterfaceSettingsResponse: + return soap_out_PointerTo_net__GetInterfaceSettingsResponse(soap, tag, id, (_net__GetInterfaceSettingsResponse *const*)ptr, "net:GetInterfaceSettingsResponse"); + case SOAP_TYPE_PointerTo_net__GetInterfaceSettings: + return soap_out_PointerTo_net__GetInterfaceSettings(soap, tag, id, (_net__GetInterfaceSettings *const*)ptr, "net:GetInterfaceSettings"); + case SOAP_TYPE_PointerTo_net__EnumerateInterfacesResponse: + return soap_out_PointerTo_net__EnumerateInterfacesResponse(soap, tag, id, (_net__EnumerateInterfacesResponse *const*)ptr, "net:EnumerateInterfacesResponse"); + case SOAP_TYPE_PointerTo_net__EnumerateInterfaces: + return soap_out_PointerTo_net__EnumerateInterfaces(soap, tag, id, (_net__EnumerateInterfaces *const*)ptr, "net:EnumerateInterfaces"); + case SOAP_TYPE_PointerTo_net__GetPingResponseResponse: + return soap_out_PointerTo_net__GetPingResponseResponse(soap, tag, id, (_net__GetPingResponseResponse *const*)ptr, "net:GetPingResponseResponse"); + case SOAP_TYPE_PointerTo_net__GetPingResponse: + return soap_out_PointerTo_net__GetPingResponse(soap, tag, id, (_net__GetPingResponse *const*)ptr, "net:GetPingResponse"); + case SOAP_TYPE_PointerTo_net__SetPingResponseResponse: + return soap_out_PointerTo_net__SetPingResponseResponse(soap, tag, id, (_net__SetPingResponseResponse *const*)ptr, "net:SetPingResponseResponse"); + case SOAP_TYPE_PointerTo_net__SetPingResponse: + return soap_out_PointerTo_net__SetPingResponse(soap, tag, id, (_net__SetPingResponse *const*)ptr, "net:SetPingResponse"); + case SOAP_TYPE_PointerTo_net__GetVlanParametersResponse: + return soap_out_PointerTo_net__GetVlanParametersResponse(soap, tag, id, (_net__GetVlanParametersResponse *const*)ptr, "net:GetVlanParametersResponse"); + case SOAP_TYPE_PointerTo_net__GetVlanParameters: + return soap_out_PointerTo_net__GetVlanParameters(soap, tag, id, (_net__GetVlanParameters *const*)ptr, "net:GetVlanParameters"); + case SOAP_TYPE_PointerTo_net__SetVlanParametersResponse: + return soap_out_PointerTo_net__SetVlanParametersResponse(soap, tag, id, (_net__SetVlanParametersResponse *const*)ptr, "net:SetVlanParametersResponse"); + case SOAP_TYPE_PointerTo_net__SetVlanParameters: + return soap_out_PointerTo_net__SetVlanParameters(soap, tag, id, (_net__SetVlanParameters *const*)ptr, "net:SetVlanParameters"); + case SOAP_TYPE_PointerTo_net__GetTcpIpParametersResponse: + return soap_out_PointerTo_net__GetTcpIpParametersResponse(soap, tag, id, (_net__GetTcpIpParametersResponse *const*)ptr, "net:GetTcpIpParametersResponse"); + case SOAP_TYPE_PointerTo_net__GetTcpIpParameters: + return soap_out_PointerTo_net__GetTcpIpParameters(soap, tag, id, (_net__GetTcpIpParameters *const*)ptr, "net:GetTcpIpParameters"); + case SOAP_TYPE_PointerTo_net__SetTcpIpParametersResponse: + return soap_out_PointerTo_net__SetTcpIpParametersResponse(soap, tag, id, (_net__SetTcpIpParametersResponse *const*)ptr, "net:SetTcpIpParametersResponse"); + case SOAP_TYPE_PointerTo_net__SetTcpIpParameters: + return soap_out_PointerTo_net__SetTcpIpParameters(soap, tag, id, (_net__SetTcpIpParameters *const*)ptr, "net:SetTcpIpParameters"); + case SOAP_TYPE_PointerTo_net__GetDomainNameResponse: + return soap_out_PointerTo_net__GetDomainNameResponse(soap, tag, id, (_net__GetDomainNameResponse *const*)ptr, "net:GetDomainNameResponse"); + case SOAP_TYPE_PointerTo_net__GetDomainName: + return soap_out_PointerTo_net__GetDomainName(soap, tag, id, (_net__GetDomainName *const*)ptr, "net:GetDomainName"); + case SOAP_TYPE_PointerTo_net__SetDomainNameResponse: + return soap_out_PointerTo_net__SetDomainNameResponse(soap, tag, id, (_net__SetDomainNameResponse *const*)ptr, "net:SetDomainNameResponse"); + case SOAP_TYPE_PointerTo_net__SetDomainName: + return soap_out_PointerTo_net__SetDomainName(soap, tag, id, (_net__SetDomainName *const*)ptr, "net:SetDomainName"); + case SOAP_TYPE_PointerTo_net__GetHostNameResponse: + return soap_out_PointerTo_net__GetHostNameResponse(soap, tag, id, (_net__GetHostNameResponse *const*)ptr, "net:GetHostNameResponse"); + case SOAP_TYPE_PointerTo_net__GetHostName: + return soap_out_PointerTo_net__GetHostName(soap, tag, id, (_net__GetHostName *const*)ptr, "net:GetHostName"); + case SOAP_TYPE_PointerTo_net__SetHostNameResponse: + return soap_out_PointerTo_net__SetHostNameResponse(soap, tag, id, (_net__SetHostNameResponse *const*)ptr, "net:SetHostNameResponse"); + case SOAP_TYPE_PointerTo_net__SetHostName: + return soap_out_PointerTo_net__SetHostName(soap, tag, id, (_net__SetHostName *const*)ptr, "net:SetHostName"); + case SOAP_TYPE_PointerTo_inf__GetIderSessionLogResponse: + return soap_out_PointerTo_inf__GetIderSessionLogResponse(soap, tag, id, (_inf__GetIderSessionLogResponse *const*)ptr, "inf:GetIderSessionLogResponse"); + case SOAP_TYPE_PointerTo_inf__GetIderSessionLog: + return soap_out_PointerTo_inf__GetIderSessionLog(soap, tag, id, (_inf__GetIderSessionLog *const*)ptr, "inf:GetIderSessionLog"); + case SOAP_TYPE_PointerTo_inf__GetSecurityParametersResponse: + return soap_out_PointerTo_inf__GetSecurityParametersResponse(soap, tag, id, (_inf__GetSecurityParametersResponse *const*)ptr, "inf:GetSecurityParametersResponse"); + case SOAP_TYPE_PointerTo_inf__GetSecurityParameters: + return soap_out_PointerTo_inf__GetSecurityParameters(soap, tag, id, (_inf__GetSecurityParameters *const*)ptr, "inf:GetSecurityParameters"); + case SOAP_TYPE_PointerTo_inf__GetNetworkStateResponse: + return soap_out_PointerTo_inf__GetNetworkStateResponse(soap, tag, id, (_inf__GetNetworkStateResponse *const*)ptr, "inf:GetNetworkStateResponse"); + case SOAP_TYPE_PointerTo_inf__GetNetworkState: + return soap_out_PointerTo_inf__GetNetworkState(soap, tag, id, (_inf__GetNetworkState *const*)ptr, "inf:GetNetworkState"); + case SOAP_TYPE_PointerTo_inf__GetEnabledInterfacesResponse: + return soap_out_PointerTo_inf__GetEnabledInterfacesResponse(soap, tag, id, (_inf__GetEnabledInterfacesResponse *const*)ptr, "inf:GetEnabledInterfacesResponse"); + case SOAP_TYPE_PointerTo_inf__GetEnabledInterfaces: + return soap_out_PointerTo_inf__GetEnabledInterfaces(soap, tag, id, (_inf__GetEnabledInterfaces *const*)ptr, "inf:GetEnabledInterfaces"); + case SOAP_TYPE_PointerTo_inf__GetPasswordModelResponse: + return soap_out_PointerTo_inf__GetPasswordModelResponse(soap, tag, id, (_inf__GetPasswordModelResponse *const*)ptr, "inf:GetPasswordModelResponse"); + case SOAP_TYPE_PointerTo_inf__GetPasswordModel: + return soap_out_PointerTo_inf__GetPasswordModel(soap, tag, id, (_inf__GetPasswordModel *const*)ptr, "inf:GetPasswordModel"); + case SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatusResponse: + return soap_out_PointerTo_inf__GetAdminNetAclEntryStatusResponse(soap, tag, id, (_inf__GetAdminNetAclEntryStatusResponse *const*)ptr, "inf:GetAdminNetAclEntryStatusResponse"); + case SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatus: + return soap_out_PointerTo_inf__GetAdminNetAclEntryStatus(soap, tag, id, (_inf__GetAdminNetAclEntryStatus *const*)ptr, "inf:GetAdminNetAclEntryStatus"); + case SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatusResponse: + return soap_out_PointerTo_inf__GetAdminAclEntryStatusResponse(soap, tag, id, (_inf__GetAdminAclEntryStatusResponse *const*)ptr, "inf:GetAdminAclEntryStatusResponse"); + case SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatus: + return soap_out_PointerTo_inf__GetAdminAclEntryStatus(soap, tag, id, (_inf__GetAdminAclEntryStatus *const*)ptr, "inf:GetAdminAclEntryStatus"); + case SOAP_TYPE_PointerTo_inf__GetConfigServerInfoResponse: + return soap_out_PointerTo_inf__GetConfigServerInfoResponse(soap, tag, id, (_inf__GetConfigServerInfoResponse *const*)ptr, "inf:GetConfigServerInfoResponse"); + case SOAP_TYPE_PointerTo_inf__GetConfigServerInfo: + return soap_out_PointerTo_inf__GetConfigServerInfo(soap, tag, id, (_inf__GetConfigServerInfo *const*)ptr, "inf:GetConfigServerInfo"); + case SOAP_TYPE_PointerTo_inf__GetHostNameResponse: + return soap_out_PointerTo_inf__GetHostNameResponse(soap, tag, id, (_inf__GetHostNameResponse *const*)ptr, "inf:GetHostNameResponse"); + case SOAP_TYPE_PointerTo_inf__GetHostName: + return soap_out_PointerTo_inf__GetHostName(soap, tag, id, (_inf__GetHostName *const*)ptr, "inf:GetHostName"); + case SOAP_TYPE_PointerTo_inf__GetVlanParametersResponse: + return soap_out_PointerTo_inf__GetVlanParametersResponse(soap, tag, id, (_inf__GetVlanParametersResponse *const*)ptr, "inf:GetVlanParametersResponse"); + case SOAP_TYPE_PointerTo_inf__GetVlanParameters: + return soap_out_PointerTo_inf__GetVlanParameters(soap, tag, id, (_inf__GetVlanParameters *const*)ptr, "inf:GetVlanParameters"); + case SOAP_TYPE_PointerTo_inf__GetProvisioningStateResponse: + return soap_out_PointerTo_inf__GetProvisioningStateResponse(soap, tag, id, (_inf__GetProvisioningStateResponse *const*)ptr, "inf:GetProvisioningStateResponse"); + case SOAP_TYPE_PointerTo_inf__GetProvisioningState: + return soap_out_PointerTo_inf__GetProvisioningState(soap, tag, id, (_inf__GetProvisioningState *const*)ptr, "inf:GetProvisioningState"); + case SOAP_TYPE_PointerTo_inf__GetProvisioningModeResponse: + return soap_out_PointerTo_inf__GetProvisioningModeResponse(soap, tag, id, (_inf__GetProvisioningModeResponse *const*)ptr, "inf:GetProvisioningModeResponse"); + case SOAP_TYPE_PointerTo_inf__GetProvisioningMode: + return soap_out_PointerTo_inf__GetProvisioningMode(soap, tag, id, (_inf__GetProvisioningMode *const*)ptr, "inf:GetProvisioningMode"); + case SOAP_TYPE_PointerTo_inf__GetCodeVersionsResponse: + return soap_out_PointerTo_inf__GetCodeVersionsResponse(soap, tag, id, (_inf__GetCodeVersionsResponse *const*)ptr, "inf:GetCodeVersionsResponse"); + case SOAP_TYPE_PointerTo_inf__GetCodeVersions: + return soap_out_PointerTo_inf__GetCodeVersions(soap, tag, id, (_inf__GetCodeVersions *const*)ptr, "inf:GetCodeVersions"); + case SOAP_TYPE_PointerTo_inf__GetCoreVersionResponse: + return soap_out_PointerTo_inf__GetCoreVersionResponse(soap, tag, id, (_inf__GetCoreVersionResponse *const*)ptr, "inf:GetCoreVersionResponse"); + case SOAP_TYPE_PointerTo_inf__GetCoreVersion: + return soap_out_PointerTo_inf__GetCoreVersion(soap, tag, id, (_inf__GetCoreVersion *const*)ptr, "inf:GetCoreVersion"); + case SOAP_TYPE_PointerTo_idr__GetIderSessionLogResponse: + return soap_out_PointerTo_idr__GetIderSessionLogResponse(soap, tag, id, (_idr__GetIderSessionLogResponse *const*)ptr, "idr:GetIderSessionLogResponse"); + case SOAP_TYPE_PointerTo_idr__GetIderSessionLog: + return soap_out_PointerTo_idr__GetIderSessionLog(soap, tag, id, (_idr__GetIderSessionLog *const*)ptr, "idr:GetIderSessionLog"); + case SOAP_TYPE_PointerTo_idr__GetRedirectionListenerStateResponse: + return soap_out_PointerTo_idr__GetRedirectionListenerStateResponse(soap, tag, id, (_idr__GetRedirectionListenerStateResponse *const*)ptr, "idr:GetRedirectionListenerStateResponse"); + case SOAP_TYPE_PointerTo_idr__GetRedirectionListenerState: + return soap_out_PointerTo_idr__GetRedirectionListenerState(soap, tag, id, (_idr__GetRedirectionListenerState *const*)ptr, "idr:GetRedirectionListenerState"); + case SOAP_TYPE_PointerTo_idr__SetRedirectionListenerStateResponse: + return soap_out_PointerTo_idr__SetRedirectionListenerStateResponse(soap, tag, id, (_idr__SetRedirectionListenerStateResponse *const*)ptr, "idr:SetRedirectionListenerStateResponse"); + case SOAP_TYPE_PointerTo_idr__SetRedirectionListenerState: + return soap_out_PointerTo_idr__SetRedirectionListenerState(soap, tag, id, (_idr__SetRedirectionListenerState *const*)ptr, "idr:SetRedirectionListenerState"); + case SOAP_TYPE_PointerTo_hwa__GetAssetDataResponse: + return soap_out_PointerTo_hwa__GetAssetDataResponse(soap, tag, id, (_hwa__GetAssetDataResponse *const*)ptr, "hwa:GetAssetDataResponse"); + case SOAP_TYPE_PointerTo_hwa__GetAssetData: + return soap_out_PointerTo_hwa__GetAssetData(soap, tag, id, (_hwa__GetAssetData *const*)ptr, "hwa:GetAssetData"); + case SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypesResponse: + return soap_out_PointerTo_hwa__EnumerateAssetTypesResponse(soap, tag, id, (_hwa__EnumerateAssetTypesResponse *const*)ptr, "hwa:EnumerateAssetTypesResponse"); + case SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypes: + return soap_out_PointerTo_hwa__EnumerateAssetTypes(soap, tag, id, (_hwa__EnumerateAssetTypes *const*)ptr, "hwa:EnumerateAssetTypes"); + case SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscriptionResponse: + return soap_out_PointerTo_emi__GetGeneralAlertSubscriptionResponse(soap, tag, id, (_emi__GetGeneralAlertSubscriptionResponse *const*)ptr, "emi:GetGeneralAlertSubscriptionResponse"); + case SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscription: + return soap_out_PointerTo_emi__GetGeneralAlertSubscription(soap, tag, id, (_emi__GetGeneralAlertSubscription *const*)ptr, "emi:GetGeneralAlertSubscription"); + case SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse: + return soap_out_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(soap, tag, id, (_emi__EnumerateGeneralAlertSubscriptionsResponse *const*)ptr, "emi:EnumerateGeneralAlertSubscriptionsResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptions: + return soap_out_PointerTo_emi__EnumerateGeneralAlertSubscriptions(soap, tag, id, (_emi__EnumerateGeneralAlertSubscriptions *const*)ptr, "emi:EnumerateGeneralAlertSubscriptions"); + case SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlertResponse: + return soap_out_PointerTo_emi__SubscribeForGeneralAlertResponse(soap, tag, id, (_emi__SubscribeForGeneralAlertResponse *const*)ptr, "emi:SubscribeForGeneralAlertResponse"); + case SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlert: + return soap_out_PointerTo_emi__SubscribeForGeneralAlert(soap, tag, id, (_emi__SubscribeForGeneralAlert *const*)ptr, "emi:SubscribeForGeneralAlert"); + case SOAP_TYPE_PointerTo_emi__GetSensorAttributesResponse: + return soap_out_PointerTo_emi__GetSensorAttributesResponse(soap, tag, id, (_emi__GetSensorAttributesResponse *const*)ptr, "emi:GetSensorAttributesResponse"); + case SOAP_TYPE_PointerTo_emi__GetSensorAttributes: + return soap_out_PointerTo_emi__GetSensorAttributes(soap, tag, id, (_emi__GetSensorAttributes *const*)ptr, "emi:GetSensorAttributes"); + case SOAP_TYPE_PointerTo_emi__EnumerateSensorsResponse: + return soap_out_PointerTo_emi__EnumerateSensorsResponse(soap, tag, id, (_emi__EnumerateSensorsResponse *const*)ptr, "emi:EnumerateSensorsResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateSensors: + return soap_out_PointerTo_emi__EnumerateSensors(soap, tag, id, (_emi__EnumerateSensors *const*)ptr, "emi:EnumerateSensors"); + case SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClockResponse: + return soap_out_PointerTo_emi__GetEventLogTimestampClockResponse(soap, tag, id, (_emi__GetEventLogTimestampClockResponse *const*)ptr, "emi:GetEventLogTimestampClockResponse"); + case SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClock: + return soap_out_PointerTo_emi__GetEventLogTimestampClock(soap, tag, id, (_emi__GetEventLogTimestampClock *const*)ptr, "emi:GetEventLogTimestampClock"); + case SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClockResponse: + return soap_out_PointerTo_emi__SetEventLogTimestampClockResponse(soap, tag, id, (_emi__SetEventLogTimestampClockResponse *const*)ptr, "emi:SetEventLogTimestampClockResponse"); + case SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClock: + return soap_out_PointerTo_emi__SetEventLogTimestampClock(soap, tag, id, (_emi__SetEventLogTimestampClock *const*)ptr, "emi:SetEventLogTimestampClock"); + case SOAP_TYPE_PointerTo_emi__FreezeEventLogResponse: + return soap_out_PointerTo_emi__FreezeEventLogResponse(soap, tag, id, (_emi__FreezeEventLogResponse *const*)ptr, "emi:FreezeEventLogResponse"); + case SOAP_TYPE_PointerTo_emi__FreezeEventLog: + return soap_out_PointerTo_emi__FreezeEventLog(soap, tag, id, (_emi__FreezeEventLog *const*)ptr, "emi:FreezeEventLog"); + case SOAP_TYPE_PointerTo_emi__ClearEventLogResponse: + return soap_out_PointerTo_emi__ClearEventLogResponse(soap, tag, id, (_emi__ClearEventLogResponse *const*)ptr, "emi:ClearEventLogResponse"); + case SOAP_TYPE_PointerTo_emi__ClearEventLog: + return soap_out_PointerTo_emi__ClearEventLog(soap, tag, id, (_emi__ClearEventLog *const*)ptr, "emi:ClearEventLog"); + case SOAP_TYPE_PointerTo_emi__ReadEventLogRecordsResponse: + return soap_out_PointerTo_emi__ReadEventLogRecordsResponse(soap, tag, id, (_emi__ReadEventLogRecordsResponse *const*)ptr, "emi:ReadEventLogRecordsResponse"); + case SOAP_TYPE_PointerTo_emi__ReadEventLogRecords: + return soap_out_PointerTo_emi__ReadEventLogRecords(soap, tag, id, (_emi__ReadEventLogRecords *const*)ptr, "emi:ReadEventLogRecords"); + case SOAP_TYPE_PointerTo_emi__GetEventLogStatusResponse: + return soap_out_PointerTo_emi__GetEventLogStatusResponse(soap, tag, id, (_emi__GetEventLogStatusResponse *const*)ptr, "emi:GetEventLogStatusResponse"); + case SOAP_TYPE_PointerTo_emi__GetEventLogStatus: + return soap_out_PointerTo_emi__GetEventLogStatus(soap, tag, id, (_emi__GetEventLogStatus *const*)ptr, "emi:GetEventLogStatus"); + case SOAP_TYPE_PointerTo_emi__RemoveEventFilterResponse: + return soap_out_PointerTo_emi__RemoveEventFilterResponse(soap, tag, id, (_emi__RemoveEventFilterResponse *const*)ptr, "emi:RemoveEventFilterResponse"); + case SOAP_TYPE_PointerTo_emi__RemoveEventFilter: + return soap_out_PointerTo_emi__RemoveEventFilter(soap, tag, id, (_emi__RemoveEventFilter *const*)ptr, "emi:RemoveEventFilter"); + case SOAP_TYPE_PointerTo_emi__UpdateEventFilterResponse: + return soap_out_PointerTo_emi__UpdateEventFilterResponse(soap, tag, id, (_emi__UpdateEventFilterResponse *const*)ptr, "emi:UpdateEventFilterResponse"); + case SOAP_TYPE_PointerTo_emi__UpdateEventFilter: + return soap_out_PointerTo_emi__UpdateEventFilter(soap, tag, id, (_emi__UpdateEventFilter *const*)ptr, "emi:UpdateEventFilter"); + case SOAP_TYPE_PointerTo_emi__GetEventFilterResponse: + return soap_out_PointerTo_emi__GetEventFilterResponse(soap, tag, id, (_emi__GetEventFilterResponse *const*)ptr, "emi:GetEventFilterResponse"); + case SOAP_TYPE_PointerTo_emi__GetEventFilter: + return soap_out_PointerTo_emi__GetEventFilter(soap, tag, id, (_emi__GetEventFilter *const*)ptr, "emi:GetEventFilter"); + case SOAP_TYPE_PointerTo_emi__CancelAlertSubscriptionResponse: + return soap_out_PointerTo_emi__CancelAlertSubscriptionResponse(soap, tag, id, (_emi__CancelAlertSubscriptionResponse *const*)ptr, "emi:CancelAlertSubscriptionResponse"); + case SOAP_TYPE_PointerTo_emi__CancelAlertSubscription: + return soap_out_PointerTo_emi__CancelAlertSubscription(soap, tag, id, (_emi__CancelAlertSubscription *const*)ptr, "emi:CancelAlertSubscription"); + case SOAP_TYPE_PointerTo_emi__EnumerateAlertPoliciesResponse: + return soap_out_PointerTo_emi__EnumerateAlertPoliciesResponse(soap, tag, id, (_emi__EnumerateAlertPoliciesResponse *const*)ptr, "emi:EnumerateAlertPoliciesResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateAlertPolicies: + return soap_out_PointerTo_emi__EnumerateAlertPolicies(soap, tag, id, (_emi__EnumerateAlertPolicies *const*)ptr, "emi:EnumerateAlertPolicies"); + case SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptionsResponse: + return soap_out_PointerTo_emi__EnumerateAlertSubscriptionsResponse(soap, tag, id, (_emi__EnumerateAlertSubscriptionsResponse *const*)ptr, "emi:EnumerateAlertSubscriptionsResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptions: + return soap_out_PointerTo_emi__EnumerateAlertSubscriptions(soap, tag, id, (_emi__EnumerateAlertSubscriptions *const*)ptr, "emi:EnumerateAlertSubscriptions"); + case SOAP_TYPE_PointerTo_emi__SubscribeForAlertResponse: + return soap_out_PointerTo_emi__SubscribeForAlertResponse(soap, tag, id, (_emi__SubscribeForAlertResponse *const*)ptr, "emi:SubscribeForAlertResponse"); + case SOAP_TYPE_PointerTo_emi__SubscribeForAlert: + return soap_out_PointerTo_emi__SubscribeForAlert(soap, tag, id, (_emi__SubscribeForAlert *const*)ptr, "emi:SubscribeForAlert"); + case SOAP_TYPE_PointerTo_emi__AddEventFilterResponse: + return soap_out_PointerTo_emi__AddEventFilterResponse(soap, tag, id, (_emi__AddEventFilterResponse *const*)ptr, "emi:AddEventFilterResponse"); + case SOAP_TYPE_PointerTo_emi__AddEventFilter: + return soap_out_PointerTo_emi__AddEventFilter(soap, tag, id, (_emi__AddEventFilter *const*)ptr, "emi:AddEventFilter"); + case SOAP_TYPE_PointerTo_emi__GetAlertCommunityStringResponse: + return soap_out_PointerTo_emi__GetAlertCommunityStringResponse(soap, tag, id, (_emi__GetAlertCommunityStringResponse *const*)ptr, "emi:GetAlertCommunityStringResponse"); + case SOAP_TYPE_PointerTo_emi__GetAlertCommunityString: + return soap_out_PointerTo_emi__GetAlertCommunityString(soap, tag, id, (_emi__GetAlertCommunityString *const*)ptr, "emi:GetAlertCommunityString"); + case SOAP_TYPE_PointerTo_emi__SetAlertCommunityStringResponse: + return soap_out_PointerTo_emi__SetAlertCommunityStringResponse(soap, tag, id, (_emi__SetAlertCommunityStringResponse *const*)ptr, "emi:SetAlertCommunityStringResponse"); + case SOAP_TYPE_PointerTo_emi__SetAlertCommunityString: + return soap_out_PointerTo_emi__SetAlertCommunityString(soap, tag, id, (_emi__SetAlertCommunityString *const*)ptr, "emi:SetAlertCommunityString"); + case SOAP_TYPE_PointerTo_emi__GetAlertSubscriptionResponse: + return soap_out_PointerTo_emi__GetAlertSubscriptionResponse(soap, tag, id, (_emi__GetAlertSubscriptionResponse *const*)ptr, "emi:GetAlertSubscriptionResponse"); + case SOAP_TYPE_PointerTo_emi__GetAlertSubscription: + return soap_out_PointerTo_emi__GetAlertSubscription(soap, tag, id, (_emi__GetAlertSubscription *const*)ptr, "emi:GetAlertSubscription"); + case SOAP_TYPE_PointerTo_emi__EnumerateEventFiltersResponse: + return soap_out_PointerTo_emi__EnumerateEventFiltersResponse(soap, tag, id, (_emi__EnumerateEventFiltersResponse *const*)ptr, "emi:EnumerateEventFiltersResponse"); + case SOAP_TYPE_PointerTo_emi__EnumerateEventFilters: + return soap_out_PointerTo_emi__EnumerateEventFilters(soap, tag, id, (_emi__EnumerateEventFilters *const*)ptr, "emi:EnumerateEventFilters"); + case SOAP_TYPE_PointerTo_cb__GetHcbStateResponse: + return soap_out_PointerTo_cb__GetHcbStateResponse(soap, tag, id, (_cb__GetHcbStateResponse *const*)ptr, "cb:GetHcbStateResponse"); + case SOAP_TYPE_PointerTo_cb__GetHcbState: + return soap_out_PointerTo_cb__GetHcbState(soap, tag, id, (_cb__GetHcbState *const*)ptr, "cb:GetHcbState"); + case SOAP_TYPE_PointerTo_cb__ClearHcbStateResponse: + return soap_out_PointerTo_cb__ClearHcbStateResponse(soap, tag, id, (_cb__ClearHcbStateResponse *const*)ptr, "cb:ClearHcbStateResponse"); + case SOAP_TYPE_PointerTo_cb__ClearHcbState: + return soap_out_PointerTo_cb__ClearHcbState(soap, tag, id, (_cb__ClearHcbState *const*)ptr, "cb:ClearHcbState"); + case SOAP_TYPE_PointerTo_cb__GetHcbOptionsResponse: + return soap_out_PointerTo_cb__GetHcbOptionsResponse(soap, tag, id, (_cb__GetHcbOptionsResponse *const*)ptr, "cb:GetHcbOptionsResponse"); + case SOAP_TYPE_PointerTo_cb__GetHcbOptions: + return soap_out_PointerTo_cb__GetHcbOptions(soap, tag, id, (_cb__GetHcbOptions *const*)ptr, "cb:GetHcbOptions"); + case SOAP_TYPE_PointerTo_cb__SetHcbOptionsResponse: + return soap_out_PointerTo_cb__SetHcbOptionsResponse(soap, tag, id, (_cb__SetHcbOptionsResponse *const*)ptr, "cb:SetHcbOptionsResponse"); + case SOAP_TYPE_PointerTo_cb__SetHcbOptions: + return soap_out_PointerTo_cb__SetHcbOptions(soap, tag, id, (_cb__SetHcbOptions *const*)ptr, "cb:SetHcbOptions"); + case SOAP_TYPE_PointerTo_cb__CbQueryCapabilitiesResponse: + return soap_out_PointerTo_cb__CbQueryCapabilitiesResponse(soap, tag, id, (_cb__CbQueryCapabilitiesResponse *const*)ptr, "cb:CbQueryCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_cb__CbQueryCapabilities: + return soap_out_PointerTo_cb__CbQueryCapabilities(soap, tag, id, (_cb__CbQueryCapabilities *const*)ptr, "cb:CbQueryCapabilities"); + case SOAP_TYPE_PointerTo_cb__CbFilterEnumerateResponse: + return soap_out_PointerTo_cb__CbFilterEnumerateResponse(soap, tag, id, (_cb__CbFilterEnumerateResponse *const*)ptr, "cb:CbFilterEnumerateResponse"); + case SOAP_TYPE_PointerTo_cb__CbFilterEnumerate: + return soap_out_PointerTo_cb__CbFilterEnumerate(soap, tag, id, (_cb__CbFilterEnumerate *const*)ptr, "cb:CbFilterEnumerate"); + case SOAP_TYPE_PointerTo_cb__CbFilterDeleteResponse: + return soap_out_PointerTo_cb__CbFilterDeleteResponse(soap, tag, id, (_cb__CbFilterDeleteResponse *const*)ptr, "cb:CbFilterDeleteResponse"); + case SOAP_TYPE_PointerTo_cb__CbFilterDelete: + return soap_out_PointerTo_cb__CbFilterDelete(soap, tag, id, (_cb__CbFilterDelete *const*)ptr, "cb:CbFilterDelete"); + case SOAP_TYPE_PointerTo_cb__CbFilterGetResponse: + return soap_out_PointerTo_cb__CbFilterGetResponse(soap, tag, id, (_cb__CbFilterGetResponse *const*)ptr, "cb:CbFilterGetResponse"); + case SOAP_TYPE_PointerTo_cb__CbFilterGet: + return soap_out_PointerTo_cb__CbFilterGet(soap, tag, id, (_cb__CbFilterGet *const*)ptr, "cb:CbFilterGet"); + case SOAP_TYPE_PointerTo_cb__CbFilterCreateResponse: + return soap_out_PointerTo_cb__CbFilterCreateResponse(soap, tag, id, (_cb__CbFilterCreateResponse *const*)ptr, "cb:CbFilterCreateResponse"); + case SOAP_TYPE_PointerTo_cb__CbFilterCreate: + return soap_out_PointerTo_cb__CbFilterCreate(soap, tag, id, (_cb__CbFilterCreate *const*)ptr, "cb:CbFilterCreate"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatisticsResponse: + return soap_out_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(soap, tag, id, (_cb__CbPolicyGetActiveStatisticsResponse *const*)ptr, "cb:CbPolicyGetActiveStatisticsResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatistics: + return soap_out_PointerTo_cb__CbPolicyGetActiveStatistics(soap, tag, id, (_cb__CbPolicyGetActiveStatistics *const*)ptr, "cb:CbPolicyGetActiveStatistics"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabledResponse: + return soap_out_PointerTo_cb__CbPolicyGetEnabledResponse(soap, tag, id, (_cb__CbPolicyGetEnabledResponse *const*)ptr, "cb:CbPolicyGetEnabledResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabled: + return soap_out_PointerTo_cb__CbPolicyGetEnabled(soap, tag, id, (_cb__CbPolicyGetEnabled *const*)ptr, "cb:CbPolicyGetEnabled"); + case SOAP_TYPE_PointerTo_cb__CbPolicyDisableResponse: + return soap_out_PointerTo_cb__CbPolicyDisableResponse(soap, tag, id, (_cb__CbPolicyDisableResponse *const*)ptr, "cb:CbPolicyDisableResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyDisable: + return soap_out_PointerTo_cb__CbPolicyDisable(soap, tag, id, (_cb__CbPolicyDisable *const*)ptr, "cb:CbPolicyDisable"); + case SOAP_TYPE_PointerTo_cb__CbPolicyEnableResponse: + return soap_out_PointerTo_cb__CbPolicyEnableResponse(soap, tag, id, (_cb__CbPolicyEnableResponse *const*)ptr, "cb:CbPolicyEnableResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyEnable: + return soap_out_PointerTo_cb__CbPolicyEnable(soap, tag, id, (_cb__CbPolicyEnable *const*)ptr, "cb:CbPolicyEnable"); + case SOAP_TYPE_PointerTo_cb__CbPolicyEnumerateResponse: + return soap_out_PointerTo_cb__CbPolicyEnumerateResponse(soap, tag, id, (_cb__CbPolicyEnumerateResponse *const*)ptr, "cb:CbPolicyEnumerateResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyEnumerate: + return soap_out_PointerTo_cb__CbPolicyEnumerate(soap, tag, id, (_cb__CbPolicyEnumerate *const*)ptr, "cb:CbPolicyEnumerate"); + case SOAP_TYPE_PointerTo_cb__CbPolicyDeleteResponse: + return soap_out_PointerTo_cb__CbPolicyDeleteResponse(soap, tag, id, (_cb__CbPolicyDeleteResponse *const*)ptr, "cb:CbPolicyDeleteResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyDelete: + return soap_out_PointerTo_cb__CbPolicyDelete(soap, tag, id, (_cb__CbPolicyDelete *const*)ptr, "cb:CbPolicyDelete"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGetResponse: + return soap_out_PointerTo_cb__CbPolicyGetResponse(soap, tag, id, (_cb__CbPolicyGetResponse *const*)ptr, "cb:CbPolicyGetResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyGet: + return soap_out_PointerTo_cb__CbPolicyGet(soap, tag, id, (_cb__CbPolicyGet *const*)ptr, "cb:CbPolicyGet"); + case SOAP_TYPE_PointerTo_cb__CbPolicyCreateResponse: + return soap_out_PointerTo_cb__CbPolicyCreateResponse(soap, tag, id, (_cb__CbPolicyCreateResponse *const*)ptr, "cb:CbPolicyCreateResponse"); + case SOAP_TYPE_PointerTo_cb__CbPolicyCreate: + return soap_out_PointerTo_cb__CbPolicyCreate(soap, tag, id, (_cb__CbPolicyCreate *const*)ptr, "cb:CbPolicyCreate"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse: + return soap_out_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, tag, id, (_apr__ConsoleWatchdogQueryCapabilitiesResponse *const*)ptr, "apr:ConsoleWatchdogQueryCapabilitiesResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilities: + return soap_out_PointerTo_apr__ConsoleWatchdogQueryCapabilities(soap, tag, id, (_apr__ConsoleWatchdogQueryCapabilities *const*)ptr, "apr:ConsoleWatchdogQueryCapabilities"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse: + return soap_out_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(soap, tag, id, (_apr__ConsoleWatchdogGetCbPolicyResponse *const*)ptr, "apr:ConsoleWatchdogGetCbPolicyResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicy: + return soap_out_PointerTo_apr__ConsoleWatchdogGetCbPolicy(soap, tag, id, (_apr__ConsoleWatchdogGetCbPolicy *const*)ptr, "apr:ConsoleWatchdogGetCbPolicy"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse: + return soap_out_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(soap, tag, id, (_apr__ConsoleWatchdogSetCbPolicyResponse *const*)ptr, "apr:ConsoleWatchdogSetCbPolicyResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicy: + return soap_out_PointerTo_apr__ConsoleWatchdogSetCbPolicy(soap, tag, id, (_apr__ConsoleWatchdogSetCbPolicy *const*)ptr, "apr:ConsoleWatchdogSetCbPolicy"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActionsResponse: + return soap_out_PointerTo_apr__ConsoleWatchdogGetActionsResponse(soap, tag, id, (_apr__ConsoleWatchdogGetActionsResponse *const*)ptr, "apr:ConsoleWatchdogGetActionsResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActions: + return soap_out_PointerTo_apr__ConsoleWatchdogGetActions(soap, tag, id, (_apr__ConsoleWatchdogGetActions *const*)ptr, "apr:ConsoleWatchdogGetActions"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActionsResponse: + return soap_out_PointerTo_apr__ConsoleWatchdogSetActionsResponse(soap, tag, id, (_apr__ConsoleWatchdogSetActionsResponse *const*)ptr, "apr:ConsoleWatchdogSetActionsResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActions: + return soap_out_PointerTo_apr__ConsoleWatchdogSetActions(soap, tag, id, (_apr__ConsoleWatchdogSetActions *const*)ptr, "apr:ConsoleWatchdogSetActions"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerateResponse: + return soap_out_PointerTo_apr__ConsoleWatchdogEnumerateResponse(soap, tag, id, (_apr__ConsoleWatchdogEnumerateResponse *const*)ptr, "apr:ConsoleWatchdogEnumerateResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerate: + return soap_out_PointerTo_apr__ConsoleWatchdogEnumerate(soap, tag, id, (_apr__ConsoleWatchdogEnumerate *const*)ptr, "apr:ConsoleWatchdogEnumerate"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDeleteResponse: + return soap_out_PointerTo_apr__ConsoleWatchdogDeleteResponse(soap, tag, id, (_apr__ConsoleWatchdogDeleteResponse *const*)ptr, "apr:ConsoleWatchdogDeleteResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDelete: + return soap_out_PointerTo_apr__ConsoleWatchdogDelete(soap, tag, id, (_apr__ConsoleWatchdogDelete *const*)ptr, "apr:ConsoleWatchdogDelete"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreateResponse: + return soap_out_PointerTo_apr__ConsoleWatchdogCreateResponse(soap, tag, id, (_apr__ConsoleWatchdogCreateResponse *const*)ptr, "apr:ConsoleWatchdogCreateResponse"); + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreate: + return soap_out_PointerTo_apr__ConsoleWatchdogCreate(soap, tag, id, (_apr__ConsoleWatchdogCreate *const*)ptr, "apr:ConsoleWatchdogCreate"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogRegisterResponse: + return soap_out_PointerTo_apl__AgentWatchdogRegisterResponse(soap, tag, id, (_apl__AgentWatchdogRegisterResponse *const*)ptr, "apl:AgentWatchdogRegisterResponse"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogRegister: + return soap_out_PointerTo_apl__AgentWatchdogRegister(soap, tag, id, (_apl__AgentWatchdogRegister *const*)ptr, "apl:AgentWatchdogRegister"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeatResponse: + return soap_out_PointerTo_apl__AgentWatchdogHeartbeatResponse(soap, tag, id, (_apl__AgentWatchdogHeartbeatResponse *const*)ptr, "apl:AgentWatchdogHeartbeatResponse"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeat: + return soap_out_PointerTo_apl__AgentWatchdogHeartbeat(soap, tag, id, (_apl__AgentWatchdogHeartbeat *const*)ptr, "apl:AgentWatchdogHeartbeat"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdownResponse: + return soap_out_PointerTo_apl__AgentWatchdogShutdownResponse(soap, tag, id, (_apl__AgentWatchdogShutdownResponse *const*)ptr, "apl:AgentWatchdogShutdownResponse"); + case SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdown: + return soap_out_PointerTo_apl__AgentWatchdogShutdown(soap, tag, id, (_apl__AgentWatchdogShutdown *const*)ptr, "apl:AgentWatchdogShutdown"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType: + return soap_out_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(soap, tag, id, (cb__CircuitBreakerIPLayeredTCPFlagsType *const*)ptr, "cb:CircuitBreakerIPLayeredTCPFlagsType"); + case SOAP_TYPE_PointerTowcxs__WirelessSettingsType: + return soap_out_PointerTowcxs__WirelessSettingsType(soap, tag, id, (wcxs__WirelessSettingsType *const*)ptr, "wcxs:WirelessSettingsType"); + case SOAP_TYPE_PointerTowcxs__WirelessCapabilitiesType: + return soap_out_PointerTowcxs__WirelessCapabilitiesType(soap, tag, id, (wcxs__WirelessCapabilitiesType *const*)ptr, "wcxs:WirelessCapabilitiesType"); + case SOAP_TYPE_PointerTowcxs__ProfileType: + return soap_out_PointerTowcxs__ProfileType(soap, tag, id, (wcxs__ProfileType *const*)ptr, "wcxs:ProfileType"); + case SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingsType: + return soap_out_PointerTowcxs__ProfileSecuritySettingsType(soap, tag, id, (wcxs__ProfileSecuritySettingsType *const*)ptr, "wcxs:ProfileSecuritySettingsType"); + case SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingRSNType: + return soap_out_PointerTowcxs__ProfileSecuritySettingRSNType(soap, tag, id, (wcxs__ProfileSecuritySettingRSNType *const*)ptr, "wcxs:ProfileSecuritySettingRSNType"); + case SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingWPAType: + return soap_out_PointerTowcxs__ProfileSecuritySettingWPAType(soap, tag, id, (wcxs__ProfileSecuritySettingWPAType *const*)ptr, "wcxs:ProfileSecuritySettingWPAType"); + case SOAP_TYPE_PointerTowcxs__DataEncryptionCCMPType: + return soap_out_PointerTowcxs__DataEncryptionCCMPType(soap, tag, id, (wcxs__DataEncryptionCCMPType *const*)ptr, "wcxs:DataEncryptionCCMPType"); + case SOAP_TYPE_PointerTowcxs__DataEncryptionTKIPType: + return soap_out_PointerTowcxs__DataEncryptionTKIPType(soap, tag, id, (wcxs__DataEncryptionTKIPType *const*)ptr, "wcxs:DataEncryptionTKIPType"); + case SOAP_TYPE_PointerTowcxs__RawKey256Type: + return soap_out_PointerTowcxs__RawKey256Type(soap, tag, id, (xsd__base64Binary *const*)ptr, "wcxs:RawKey256Type"); + case SOAP_TYPE_PointerTowcxs__PassPhrase63Type: + return soap_out_PointerTowcxs__PassPhrase63Type(soap, tag, id, (std::string *const*)ptr, "wcxs:PassPhrase63Type"); + case SOAP_TYPE_PointerTowcxs__WEP128Type: + return soap_out_PointerTowcxs__WEP128Type(soap, tag, id, (wcxs__WEP128Type *const*)ptr, "wcxs:WEP128Type"); + case SOAP_TYPE_PointerTowcxs__WEP64Type: + return soap_out_PointerTowcxs__WEP64Type(soap, tag, id, (wcxs__WEP64Type *const*)ptr, "wcxs:WEP64Type"); + case SOAP_TYPE_PointerTowcxs__RawKey128Type: + return soap_out_PointerTowcxs__RawKey128Type(soap, tag, id, (xsd__base64Binary *const*)ptr, "wcxs:RawKey128Type"); + case SOAP_TYPE_PointerTowcxs__PassPhraseWEP128Type: + return soap_out_PointerTowcxs__PassPhraseWEP128Type(soap, tag, id, (std::string *const*)ptr, "wcxs:PassPhraseWEP128Type"); + case SOAP_TYPE_PointerTowcxs__RawKey64Type: + return soap_out_PointerTowcxs__RawKey64Type(soap, tag, id, (xsd__base64Binary *const*)ptr, "wcxs:RawKey64Type"); + case SOAP_TYPE_PointerTowcxs__PassPhrase5Type: + return soap_out_PointerTowcxs__PassPhrase5Type(soap, tag, id, (std::string *const*)ptr, "wcxs:PassPhrase5Type"); + case SOAP_TYPE_PointerTorci__OemParametersType: + return soap_out_PointerTorci__OemParametersType(soap, tag, id, (unsigned short *const*)ptr, "rci:OemParametersType"); + case SOAP_TYPE_PointerTorci__BootOptionsType: + return soap_out_PointerTorci__BootOptionsType(soap, tag, id, (unsigned short *const*)ptr, "rci:BootOptionsType"); + case SOAP_TYPE_PointerTorci__SpecialCommandParameterType: + return soap_out_PointerTorci__SpecialCommandParameterType(soap, tag, id, (unsigned short *const*)ptr, "rci:SpecialCommandParameterType"); + case SOAP_TYPE_PointerTorci__SpecialCommandType: + return soap_out_PointerTorci__SpecialCommandType(soap, tag, id, (enum rci__SpecialCommandType *const*)ptr, "rci:SpecialCommandType"); + case SOAP_TYPE_PointerToinf__IderSessionLogEntryType: + return soap_out_PointerToinf__IderSessionLogEntryType(soap, tag, id, (inf__IderSessionLogEntryType *const*)ptr, "inf:IderSessionLogEntryType"); + case SOAP_TYPE_PointerToinf__FirmwareVersionType: + return soap_out_PointerToinf__FirmwareVersionType(soap, tag, id, (inf__FirmwareVersionType *const*)ptr, "inf:FirmwareVersionType"); + case SOAP_TYPE_PointerToidr__IderSessionLogEntryType: + return soap_out_PointerToidr__IderSessionLogEntryType(soap, tag, id, (idr__IderSessionLogEntryType *const*)ptr, "idr:IderSessionLogEntryType"); + case SOAP_TYPE_PointerToapl__GUID: + return soap_out_PointerToapl__GUID(soap, tag, id, (apl__GUID *const*)ptr, "apl:GUID"); + case SOAP_TYPE_PointerToapr__AgentPresenceCapabilitiesType: + return soap_out_PointerToapr__AgentPresenceCapabilitiesType(soap, tag, id, (apr__AgentPresenceCapabilitiesType *const*)ptr, "apr:AgentPresenceCapabilitiesType"); + case SOAP_TYPE_PointerToapr__CircuitBreakerHardwarePolicyType: + return soap_out_PointerToapr__CircuitBreakerHardwarePolicyType(soap, tag, id, (apr__CircuitBreakerHardwarePolicyType *const*)ptr, "apr:CircuitBreakerHardwarePolicyType"); + case SOAP_TYPE_PointerToapr__ConsoleWatchdogActionType: + return soap_out_PointerToapr__ConsoleWatchdogActionType(soap, tag, id, (apr__ConsoleWatchdogActionType *const*)ptr, "apr:ConsoleWatchdogActionType"); + case SOAP_TYPE_PointerToapr__ConsoleWatchdogEntryType: + return soap_out_PointerToapr__ConsoleWatchdogEntryType(soap, tag, id, (apr__ConsoleWatchdogEntryType *const*)ptr, "apr:ConsoleWatchdogEntryType"); + case SOAP_TYPE_PointerToapr__CbActionType: + return soap_out_PointerToapr__CbActionType(soap, tag, id, (enum apr__CbActionType *const*)ptr, "apr:CbActionType"); + case SOAP_TYPE_PointerToapr__GUID: + return soap_out_PointerToapr__GUID(soap, tag, id, (apr__GUID *const*)ptr, "apr:GUID"); + case SOAP_TYPE_PointerTohwa__AssetDataArrayType: + return soap_out_PointerTohwa__AssetDataArrayType(soap, tag, id, (hwa__AssetDataArrayType *const*)ptr, "hwa:AssetDataArrayType"); + case SOAP_TYPE_PointerTohwa__AssetTypeArrayType: + return soap_out_PointerTohwa__AssetTypeArrayType(soap, tag, id, (hwa__AssetTypeArrayType *const*)ptr, "hwa:AssetTypeArrayType"); + case SOAP_TYPE_PointerTohwa__GUID: + return soap_out_PointerTohwa__GUID(soap, tag, id, (hwa__GUID *const*)ptr, "hwa:GUID"); + case SOAP_TYPE_PointerToxsd__base64Binary: + return soap_out_PointerToxsd__base64Binary(soap, tag, id, (xsd__base64Binary *const*)ptr, "xsd:base64Binary"); + case SOAP_TYPE_PointerTohwa__AssetDataType: + return soap_out_PointerTohwa__AssetDataType(soap, tag, id, (hwa__AssetDataType *const*)ptr, "hwa:AssetDataType"); + case SOAP_TYPE_PointerTocb__BlockedPortInfoType: + return soap_out_PointerTocb__BlockedPortInfoType(soap, tag, id, (cb__BlockedPortInfoType *const*)ptr, "cb:BlockedPortInfoType"); + case SOAP_TYPE_PointerTocb__HcbTriggerReasonType: + return soap_out_PointerTocb__HcbTriggerReasonType(soap, tag, id, (enum cb__HcbTriggerReasonType *const*)ptr, "cb:HcbTriggerReasonType"); + case SOAP_TYPE_PointerTocb__TimeType: + return soap_out_PointerTocb__TimeType(soap, tag, id, (unsigned int *const*)ptr, "cb:TimeType"); + case SOAP_TYPE_PointerTocb__HcbOptionsType: + return soap_out_PointerTocb__HcbOptionsType(soap, tag, id, (cb__HcbOptionsType *const*)ptr, "cb:HcbOptionsType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerCapabilitiesType: + return soap_out_PointerTocb__CircuitBreakerCapabilitiesType(soap, tag, id, (cb__CircuitBreakerCapabilitiesType *const*)ptr, "cb:CircuitBreakerCapabilitiesType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerFilterInfoType: + return soap_out_PointerTocb__CircuitBreakerFilterInfoType(soap, tag, id, (cb__CircuitBreakerFilterInfoType *const*)ptr, "cb:CircuitBreakerFilterInfoType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerFilterStatisticsType: + return soap_out_PointerTocb__CircuitBreakerFilterStatisticsType(soap, tag, id, (cb__CircuitBreakerFilterStatisticsType *const*)ptr, "cb:CircuitBreakerFilterStatisticsType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerApplicationType: + return soap_out_PointerTocb__CircuitBreakerApplicationType(soap, tag, id, (enum cb__CircuitBreakerApplicationType *const*)ptr, "cb:CircuitBreakerApplicationType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerHardwarePolicyType: + return soap_out_PointerTocb__CircuitBreakerHardwarePolicyType(soap, tag, id, (cb__CircuitBreakerHardwarePolicyType *const*)ptr, "cb:CircuitBreakerHardwarePolicyType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPolicyInfoType: + return soap_out_PointerTocb__CircuitBreakerPolicyInfoType(soap, tag, id, (cb__CircuitBreakerPolicyInfoType *const*)ptr, "cb:CircuitBreakerPolicyInfoType"); + case SOAP_TYPE_PointerTocb__TimedCounterType: + return soap_out_PointerTocb__TimedCounterType(soap, tag, id, (cb__TimedCounterType *const*)ptr, "cb:TimedCounterType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerFilterType: + return soap_out_PointerTocb__CircuitBreakerFilterType(soap, tag, id, (cb__CircuitBreakerFilterType *const*)ptr, "cb:CircuitBreakerFilterType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketType: + return soap_out_PointerTocb__CircuitBreakerPacketType(soap, tag, id, (cb__CircuitBreakerPacketType *const*)ptr, "cb:CircuitBreakerPacketType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketETHType: + return soap_out_PointerTocb__CircuitBreakerPacketETHType(soap, tag, id, (cb__CircuitBreakerPacketETHType *const*)ptr, "cb:CircuitBreakerPacketETHType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketIPType: + return soap_out_PointerTocb__CircuitBreakerPacketIPType(soap, tag, id, (cb__CircuitBreakerPacketIPType *const*)ptr, "cb:CircuitBreakerPacketIPType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketUDPType: + return soap_out_PointerTocb__CircuitBreakerPacketUDPType(soap, tag, id, (cb__CircuitBreakerPacketUDPType *const*)ptr, "cb:CircuitBreakerPacketUDPType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketTCPType: + return soap_out_PointerTocb__CircuitBreakerPacketTCPType(soap, tag, id, (cb__CircuitBreakerPacketTCPType *const*)ptr, "cb:CircuitBreakerPacketTCPType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortType: + return soap_out_PointerTocb__CircuitBreakerIPLayeredPortType(soap, tag, id, (cb__CircuitBreakerIPLayeredPortType *const*)ptr, "cb:CircuitBreakerIPLayeredPortType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPPacketType: + return soap_out_PointerTocb__CircuitBreakerIPPacketType(soap, tag, id, (cb__CircuitBreakerIPPacketType *const*)ptr, "cb:CircuitBreakerIPPacketType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv6Type: + return soap_out_PointerTocb__CircuitBreakerIPv6Type(soap, tag, id, (cb__CircuitBreakerIPv6Type *const*)ptr, "cb:CircuitBreakerIPv6Type"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv4Type: + return soap_out_PointerTocb__CircuitBreakerIPv4Type(soap, tag, id, (cb__CircuitBreakerIPv4Type *const*)ptr, "cb:CircuitBreakerIPv4Type"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv6AddressAndMaskType: + return soap_out_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(soap, tag, id, (cb__CircuitBreakerIPv6AddressAndMaskType *const*)ptr, "cb:CircuitBreakerIPv6AddressAndMaskType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv4AddressAndMaskType: + return soap_out_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(soap, tag, id, (cb__CircuitBreakerIPv4AddressAndMaskType *const*)ptr, "cb:CircuitBreakerIPv4AddressAndMaskType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortRangeType: + return soap_out_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, tag, id, (cb__CircuitBreakerIPLayeredPortRangeType *const*)ptr, "cb:CircuitBreakerIPLayeredPortRangeType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortSimpleType: + return soap_out_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(soap, tag, id, (cb__CircuitBreakerIPLayeredPortSimpleType *const*)ptr, "cb:CircuitBreakerIPLayeredPortSimpleType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerPolicyType: + return soap_out_PointerTocb__CircuitBreakerPolicyType(soap, tag, id, (cb__CircuitBreakerPolicyType *const*)ptr, "cb:CircuitBreakerPolicyType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerDefaultFilterType: + return soap_out_PointerTocb__CircuitBreakerDefaultFilterType(soap, tag, id, (cb__CircuitBreakerDefaultFilterType *const*)ptr, "cb:CircuitBreakerDefaultFilterType"); + case SOAP_TYPE_PointerTocb__CircuitBreakerAntiSpoofingFilterType: + return soap_out_PointerTocb__CircuitBreakerAntiSpoofingFilterType(soap, tag, id, (cb__CircuitBreakerAntiSpoofingFilterType *const*)ptr, "cb:CircuitBreakerAntiSpoofingFilterType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionGeneralType: + return soap_out_PointerToemi__AlertSubscriptionGeneralType(soap, tag, id, (emi__AlertSubscriptionGeneralType *const*)ptr, "emi:AlertSubscriptionGeneralType"); + case SOAP_TYPE_PointerToemi__SensorAttributesType: + return soap_out_PointerToemi__SensorAttributesType(soap, tag, id, (emi__SensorAttributesType *const*)ptr, "emi:SensorAttributesType"); + case SOAP_TYPE_PointerToemi__SensorHandleArrayType: + return soap_out_PointerToemi__SensorHandleArrayType(soap, tag, id, (emi__SensorHandleArrayType *const*)ptr, "emi:SensorHandleArrayType"); + case SOAP_TYPE_PointerToemi__EventLogRecordArrayType: + return soap_out_PointerToemi__EventLogRecordArrayType(soap, tag, id, (emi__EventLogRecordArrayType *const*)ptr, "emi:EventLogRecordArrayType"); + case SOAP_TYPE_PointerToemi__EventFilterHandleArrayType: + return soap_out_PointerToemi__EventFilterHandleArrayType(soap, tag, id, (emi__EventFilterHandleArrayType *const*)ptr, "emi:EventFilterHandleArrayType"); + case SOAP_TYPE_PointerToemi__EventFilterType: + return soap_out_PointerToemi__EventFilterType(soap, tag, id, (emi__EventFilterType *const*)ptr, "emi:EventFilterType"); + case SOAP_TYPE_PointerToemi__ByteStr: + return soap_out_PointerToemi__ByteStr(soap, tag, id, (emi__ByteStr *const*)ptr, "emi:ByteStr"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDArrayType: + return soap_out_PointerToemi__AlertSubscriptionPolicyIDArrayType(soap, tag, id, (emi__AlertSubscriptionPolicyIDArrayType *const*)ptr, "emi:AlertSubscriptionPolicyIDArrayType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionHandleArrayType: + return soap_out_PointerToemi__AlertSubscriptionHandleArrayType(soap, tag, id, (emi__AlertSubscriptionHandleArrayType *const*)ptr, "emi:AlertSubscriptionHandleArrayType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDType: + return soap_out_PointerToemi__AlertSubscriptionPolicyIDType(soap, tag, id, (unsigned char *const*)ptr, "emi:AlertSubscriptionPolicyIDType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionType: + return soap_out_PointerToemi__AlertSubscriptionType(soap, tag, id, (emi__AlertSubscriptionType *const*)ptr, "emi:AlertSubscriptionType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionSoapType: + return soap_out_PointerToemi__AlertSubscriptionSoapType(soap, tag, id, (emi__AlertSubscriptionSoapType *const*)ptr, "emi:AlertSubscriptionSoapType"); + case SOAP_TYPE_PointerToemi__AlertSubscriptionSNMPType: + return soap_out_PointerToemi__AlertSubscriptionSNMPType(soap, tag, id, (emi__AlertSubscriptionSNMPType *const*)ptr, "emi:AlertSubscriptionSNMPType"); + case SOAP_TYPE_PointerToemi__AlertCredentialsType: + return soap_out_PointerToemi__AlertCredentialsType(soap, tag, id, (emi__AlertCredentialsType *const*)ptr, "emi:AlertCredentialsType"); + case SOAP_TYPE_PointerTocmn__URLType: + return soap_out_PointerTocmn__URLType(soap, tag, id, (cmn__URLType *const*)ptr, "cmn:URLType"); + case SOAP_TYPE_PointerToemi__CommunityStringType: + return soap_out_PointerToemi__CommunityStringType(soap, tag, id, (std::string *const*)ptr, "emi:CommunityStringType"); + case SOAP_TYPE_PointerTocmn__NodeAddressType: + return soap_out_PointerTocmn__NodeAddressType(soap, tag, id, (cmn__NodeAddressType *const*)ptr, "cmn:NodeAddressType"); + case SOAP_TYPE_PointerToemi__EventLogRecordType: + return soap_out_PointerToemi__EventLogRecordType(soap, tag, id, (emi__EventLogRecordType *const*)ptr, "emi:EventLogRecordType"); + case SOAP_TYPE_PointerToemi__ByteData: + return soap_out_PointerToemi__ByteData(soap, tag, id, (emi__ByteData *const*)ptr, "emi:ByteData"); + case SOAP_TYPE_PointerTostra__StorageAllocEntryHandleListType: + return soap_out_PointerTostra__StorageAllocEntryHandleListType(soap, tag, id, (stra__StorageAllocEntryHandleListType *const*)ptr, "stra:StorageAllocEntryHandleListType"); + case SOAP_TYPE_PointerTostra__StorageAllocEntryType: + return soap_out_PointerTostra__StorageAllocEntryType(soap, tag, id, (stra__StorageAllocEntryType *const*)ptr, "stra:StorageAllocEntryType"); + case SOAP_TYPE_PointerTostra__StorageEaclEntryHandleListType: + return soap_out_PointerTostra__StorageEaclEntryHandleListType(soap, tag, id, (stra__StorageEaclEntryHandleListType *const*)ptr, "stra:StorageEaclEntryHandleListType"); + case SOAP_TYPE_PointerTostra__StorageEaclEntryType: + return soap_out_PointerTostra__StorageEaclEntryType(soap, tag, id, (stra__StorageEaclEntryType *const*)ptr, "stra:StorageEaclEntryType"); + case SOAP_TYPE_PointerTostra__StorageApplicationAttributesType: + return soap_out_PointerTostra__StorageApplicationAttributesType(soap, tag, id, (stra__StorageApplicationAttributesType *const*)ptr, "stra:StorageApplicationAttributesType"); + case SOAP_TYPE_PointerTostra__StorageApplicationHandleListType: + return soap_out_PointerTostra__StorageApplicationHandleListType(soap, tag, id, (stra__StorageApplicationHandleListType *const*)ptr, "stra:StorageApplicationHandleListType"); + case SOAP_TYPE_PointerTostra__GlobalStorageAttributesType: + return soap_out_PointerTostra__GlobalStorageAttributesType(soap, tag, id, (stra__GlobalStorageAttributesType *const*)ptr, "stra:GlobalStorageAttributesType"); + case SOAP_TYPE_PointerTostra__StorageSnrpApplicationAttributeType: + return soap_out_PointerTostra__StorageSnrpApplicationAttributeType(soap, tag, id, (stra__StorageSnrpApplicationAttributeType *const*)ptr, "stra:StorageSnrpApplicationAttributeType"); + case SOAP_TYPE_PointerTostra__GUID: + return soap_out_PointerTostra__GUID(soap, tag, id, (stra__GUID *const*)ptr, "stra:GUID"); + case SOAP_TYPE_PointerTostra__StorageAllocSnrpEntryType: + return soap_out_PointerTostra__StorageAllocSnrpEntryType(soap, tag, id, (stra__StorageAllocSnrpEntryType *const*)ptr, "stra:StorageAllocSnrpEntryType"); + case SOAP_TYPE_PointerToxcfg__XProfileType: + return soap_out_PointerToxcfg__XProfileType(soap, tag, id, (xcfg__XProfileType *const*)ptr, "xcfg:XProfileType"); + case SOAP_TYPE_PointerTonet__InterfaceDescriptorSetType: + return soap_out_PointerTonet__InterfaceDescriptorSetType(soap, tag, id, (net__InterfaceDescriptorSetType *const*)ptr, "net:InterfaceDescriptorSetType"); + case SOAP_TYPE_PointerTonet__InterfaceDescriptorGetType: + return soap_out_PointerTonet__InterfaceDescriptorGetType(soap, tag, id, (net__InterfaceDescriptorGetType *const*)ptr, "net:InterfaceDescriptorGetType"); + case SOAP_TYPE_PointerTocmn__InterfaceHandleType: + return soap_out_PointerTocmn__InterfaceHandleType(soap, tag, id, (unsigned int *const*)ptr, "cmn:InterfaceHandleType"); + case SOAP_TYPE_PointerTonet__StaticIPv4ParametersType: + return soap_out_PointerTonet__StaticIPv4ParametersType(soap, tag, id, (net__StaticIPv4ParametersType *const*)ptr, "net:StaticIPv4ParametersType"); + case SOAP_TYPE_PointerTonet__IPv4ParametersType: + return soap_out_PointerTonet__IPv4ParametersType(soap, tag, id, (net__IPv4ParametersType *const*)ptr, "net:IPv4ParametersType"); + case SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCORETLSType: + return soap_out_PointerToxcfg__XProfileEAPFAST_USCORETLSType(soap, tag, id, (xcfg__XProfileEAPFAST_USCORETLSType *const*)ptr, "xcfg:XProfileEAPFAST_TLSType"); + case SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREGTCType: + return soap_out_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(soap, tag, id, (xcfg__XProfileEAPFAST_USCOREGTCType *const*)ptr, "xcfg:XProfileEAPFAST_GTCType"); + case SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type: + return soap_out_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, tag, id, (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *const*)ptr, "xcfg:XProfileEAPFAST_MSCHAPv2Type"); + case SOAP_TYPE_PointerToxcfg__XProfileEAP_USCOREGTCType: + return soap_out_PointerToxcfg__XProfileEAP_USCOREGTCType(soap, tag, id, (xcfg__XProfileEAP_USCOREGTCType *const*)ptr, "xcfg:XProfileEAP_GTCType"); + case SOAP_TYPE_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type: + return soap_out_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, tag, id, (xcfg__XProfilePEAP_USCOREMSCHAPv2Type *const*)ptr, "xcfg:XProfilePEAP_MSCHAPv2Type"); + case SOAP_TYPE_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type: + return soap_out_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, tag, id, (xcfg__XProfileTTLS_USCOREMSCHAPv2Type *const*)ptr, "xcfg:XProfileTTLS_MSCHAPv2Type"); + case SOAP_TYPE_PointerToxcfg__XProfileTLSType: + return soap_out_PointerToxcfg__XProfileTLSType(soap, tag, id, (xcfg__XProfileTLSType *const*)ptr, "xcfg:XProfileTLSType"); + case SOAP_TYPE_PointerToxcfg__ManualPACType: + return soap_out_PointerToxcfg__ManualPACType(soap, tag, id, (xcfg__ManualPACType *const*)ptr, "xcfg:ManualPACType"); + case SOAP_TYPE_PointerToxcfg__UserCredentialsType: + return soap_out_PointerToxcfg__UserCredentialsType(soap, tag, id, (xcfg__UserCredentialsType *const*)ptr, "xcfg:UserCredentialsType"); + case SOAP_TYPE_PointerToxcfg__ServerIdentityType: + return soap_out_PointerToxcfg__ServerIdentityType(soap, tag, id, (xcfg__ServerIdentityType *const*)ptr, "xcfg:ServerIdentityType"); + case SOAP_TYPE_PointerToxcfg__CertificateNameType: + return soap_out_PointerToxcfg__CertificateNameType(soap, tag, id, (xcfg__CertificateNameType *const*)ptr, "xcfg:CertificateNameType"); + case SOAP_TYPE_PointerTosai__CertificateHandleType: + return soap_out_PointerTosai__CertificateHandleType(soap, tag, id, (unsigned int *const*)ptr, "sai:CertificateHandleType"); + case SOAP_TYPE_PointerTocstr__KeyPairType: + return soap_out_PointerTocstr__KeyPairType(soap, tag, id, (cstr__KeyPairType *const*)ptr, "cstr:KeyPairType"); + case SOAP_TYPE_PointerTosai__GlobalPowerPolicyType: + return soap_out_PointerTosai__GlobalPowerPolicyType(soap, tag, id, (sai__GlobalPowerPolicyType *const*)ptr, "sai:GlobalPowerPolicyType"); + case SOAP_TYPE_PointerTosai__EnvironmentDetectionType: + return soap_out_PointerTosai__EnvironmentDetectionType(soap, tag, id, (sai__EnvironmentDetectionType *const*)ptr, "sai:EnvironmentDetectionType"); + case SOAP_TYPE_PointerTosai__ProvisioningAuditRecordType: + return soap_out_PointerTosai__ProvisioningAuditRecordType(soap, tag, id, (sai__ProvisioningAuditRecordType *const*)ptr, "sai:ProvisioningAuditRecordType"); + case SOAP_TYPE_PointerTosai__CertHashEntryType: + return soap_out_PointerTosai__CertHashEntryType(soap, tag, id, (sai__CertHashEntryType *const*)ptr, "sai:CertHashEntryType"); + case SOAP_TYPE_PointerTosai__ProvisioningOTPType: + return soap_out_PointerTosai__ProvisioningOTPType(soap, tag, id, (xsd__base64Binary *const*)ptr, "sai:ProvisioningOTPType"); + case SOAP_TYPE_PointerTounsignedShort: + return soap_out_PointerTounsignedShort(soap, tag, id, (unsigned short *const*)ptr, "xsd:unsignedShort"); + case SOAP_TYPE_PointerTosai__PowerStateType: + return soap_out_PointerTosai__PowerStateType(soap, tag, id, (enum sai__PowerStateType *const*)ptr, "sai:PowerStateType"); + case SOAP_TYPE_PointerTosai__PkiCapsType: + return soap_out_PointerTosai__PkiCapsType(soap, tag, id, (sai__PkiCapsType *const*)ptr, "sai:PkiCapsType"); + case SOAP_TYPE_PointerTosai__CrlType: + return soap_out_PointerTosai__CrlType(soap, tag, id, (sai__CrlType *const*)ptr, "sai:CrlType"); + case SOAP_TYPE_PointerTosai__CertificateType: + return soap_out_PointerTosai__CertificateType(soap, tag, id, (sai__CertificateType *const*)ptr, "sai:CertificateType"); + case SOAP_TYPE_PointerTosai__TlsOptionsType: + return soap_out_PointerTosai__TlsOptionsType(soap, tag, id, (sai__TlsOptionsType *const*)ptr, "sai:TlsOptionsType"); + case SOAP_TYPE_PointerTosai__KerberosOptionsType: + return soap_out_PointerTosai__KerberosOptionsType(soap, tag, id, (sai__KerberosOptionsType *const*)ptr, "sai:KerberosOptionsType"); + case SOAP_TYPE_PointerTosai__AdminAclEntryExType: + return soap_out_PointerTosai__AdminAclEntryExType(soap, tag, id, (sai__AdminAclEntryExType *const*)ptr, "sai:AdminAclEntryExType"); + case SOAP_TYPE_PointerTosai__UserAclEntryExType: + return soap_out_PointerTosai__UserAclEntryExType(soap, tag, id, (sai__UserAclEntryExType *const*)ptr, "sai:UserAclEntryExType"); + case SOAP_TYPE_PointerTosai__UpdateCoreUrlKeyType: + return soap_out_PointerTosai__UpdateCoreUrlKeyType(soap, tag, id, (sai__UpdateCoreUrlKeyType *const*)ptr, "sai:UpdateCoreUrlKeyType"); + case SOAP_TYPE_PointerTosai__AmtVersion: + return soap_out_PointerTosai__AmtVersion(soap, tag, id, (sai__AmtVersion *const*)ptr, "sai:AmtVersion"); + case SOAP_TYPE_PointerTosai__RngKeyType: + return soap_out_PointerTosai__RngKeyType(soap, tag, id, (sai__RngKeyType *const*)ptr, "sai:RngKeyType"); + case SOAP_TYPE_PointerTosai__CertificateChainType: + return soap_out_PointerTosai__CertificateChainType(soap, tag, id, (sai__CertificateChainType *const*)ptr, "sai:CertificateChainType"); + case SOAP_TYPE_PointerTosai__RsaKeyType: + return soap_out_PointerTosai__RsaKeyType(soap, tag, id, (sai__RsaKeyType *const*)ptr, "sai:RsaKeyType"); + case SOAP_TYPE_PointerTosai__UserAclEntryHandleListType: + return soap_out_PointerTosai__UserAclEntryHandleListType(soap, tag, id, (sai__UserAclEntryHandleListType *const*)ptr, "sai:UserAclEntryHandleListType"); + case SOAP_TYPE_PointerTosai__AdminAclEntryType: + return soap_out_PointerTosai__AdminAclEntryType(soap, tag, id, (sai__AdminAclEntryType *const*)ptr, "sai:AdminAclEntryType"); + case SOAP_TYPE_PointerTosai__UserAclEntryType: + return soap_out_PointerTosai__UserAclEntryType(soap, tag, id, (sai__UserAclEntryType *const*)ptr, "sai:UserAclEntryType"); + case SOAP_TYPE_PointerTounsignedInt: + return soap_out_PointerTounsignedInt(soap, tag, id, (unsigned int *const*)ptr, "xsd:unsignedInt"); + case SOAP_TYPE_PointerTosai__EnvironmentDetectionDomainType: + return soap_out_PointerTosai__EnvironmentDetectionDomainType(soap, tag, id, (sai__EnvironmentDetectionDomainType *const*)ptr, "sai:EnvironmentDetectionDomainType"); + case SOAP_TYPE_PointerTobool: + return soap_out_PointerTobool(soap, tag, id, (bool *const*)ptr, "xsd:boolean"); + case SOAP_TYPE_PointerTostd__string: + return soap_out_PointerTostd__string(soap, tag, id, (std::string *const*)ptr, "xsd:string"); + case SOAP_TYPE_PointerTosai__KerberosSpnType: + return soap_out_PointerTosai__KerberosSpnType(soap, tag, id, (sai__KerberosSpnType *const*)ptr, "sai:KerberosSpnType"); + case SOAP_TYPE_PointerTosai__UserEntryKerberosType: + return soap_out_PointerTosai__UserEntryKerberosType(soap, tag, id, (sai__UserEntryKerberosType *const*)ptr, "sai:UserEntryKerberosType"); + case SOAP_TYPE_PointerTosai__UserEntryDigestType: + return soap_out_PointerTosai__UserEntryDigestType(soap, tag, id, (sai__UserEntryDigestType *const*)ptr, "sai:UserEntryDigestType"); + case SOAP_TYPE_PointerTosai__UserAclRealmListType: + return soap_out_PointerTosai__UserAclRealmListType(soap, tag, id, (sai__UserAclRealmListType *const*)ptr, "sai:UserAclRealmListType"); + case SOAP_TYPE_PointerTocstr__RSAKeyPairType: + return soap_out_PointerTocstr__RSAKeyPairType(soap, tag, id, (cstr__RSAKeyPairType *const*)ptr, "cstr:RSAKeyPairType"); + case SOAP_TYPE_PointerTocmn__IPv6AddressStringType: + return soap_out_PointerTocmn__IPv6AddressStringType(soap, tag, id, (std::string *const*)ptr, "cmn:IPv6AddressStringType"); + case SOAP_TYPE_PointerTocmn__IPv4AddressStringType: + return soap_out_PointerTocmn__IPv4AddressStringType(soap, tag, id, (std::string *const*)ptr, "cmn:IPv4AddressStringType"); + case SOAP_TYPE_PointerTocmn__HostNameType: + return soap_out_PointerTocmn__HostNameType(soap, tag, id, (std::string *const*)ptr, "cmn:HostNameType"); + case SOAP_TYPE_PointerTounsignedByte: + return soap_out_PointerTounsignedByte(soap, tag, id, (unsigned char *const*)ptr, "xsd:unsignedByte"); + case SOAP_TYPE__QName: + return soap_out_string(soap, "QName", id, (char**)&ptr, NULL); + case SOAP_TYPE_string: + return soap_out_string(soap, tag, id, (char**)&ptr, "xsd:string"); + } + return SOAP_OK; +} +#endif + +#ifndef WITH_NOIDREF +SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type) +{ + (void)soap; (void)ptr; (void)type; /* appease -Wall -Werror */ + switch (type) + { + case SOAP_TYPE_wcxs__PassPhrase63Type: + soap_serialize_wcxs__PassPhrase63Type(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_wcxs__PassPhraseWEP128Type: + soap_serialize_wcxs__PassPhraseWEP128Type(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_wcxs__PassPhrase5Type: + soap_serialize_wcxs__PassPhrase5Type(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_wcxs__RawKey256Type: + soap_serialize_wcxs__RawKey256Type(soap, (const xsd__base64Binary *)ptr); + break; + case SOAP_TYPE_wcxs__RawKey128Type: + soap_serialize_wcxs__RawKey128Type(soap, (const xsd__base64Binary *)ptr); + break; + case SOAP_TYPE_wcxs__RawKey64Type: + soap_serialize_wcxs__RawKey64Type(soap, (const xsd__base64Binary *)ptr); + break; + case SOAP_TYPE_wcxs__ProfileNameType: + soap_serialize_wcxs__ProfileNameType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE__apr__AgentDescription: + soap_serialize__apr__AgentDescription(soap, (const std::string *)ptr); + break; + case SOAP_TYPE__cb__PolicyName: + soap_serialize__cb__PolicyName(soap, (const std::string *)ptr); + break; + case SOAP_TYPE__cb__FilterName: + soap_serialize__cb__FilterName(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_cb__IPv6AddressStringType: + soap_serialize_cb__IPv6AddressStringType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_cb__IPv4AddressStringType: + soap_serialize_cb__IPv4AddressStringType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_emi__CommunityStringType: + soap_serialize_emi__CommunityStringType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_net__MACAddressType: + soap_serialize_net__MACAddressType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE__sai__KerberosRealmName: + soap_serialize__sai__KerberosRealmName(soap, (const std::string *)ptr); + break; + case SOAP_TYPE__sai__SpnString: + soap_serialize__sai__SpnString(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_sai__FriendlyNameType: + soap_serialize_sai__FriendlyNameType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_sai__ProvisioningOTPType: + soap_serialize_sai__ProvisioningOTPType(soap, (const xsd__base64Binary *)ptr); + break; + case SOAP_TYPE_sai__MEBxPasswordType: + soap_serialize_sai__MEBxPasswordType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_sai__AclPasswordStringType: + soap_serialize_sai__AclPasswordStringType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_sai__AclStringType: + soap_serialize_sai__AclStringType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_cmn__GuidBuf: + soap_serialize_cmn__GuidBuf(soap, (const xsd__base64Binary *)ptr); + break; + case SOAP_TYPE_cmn__IPv6AddressStringType: + soap_serialize_cmn__IPv6AddressStringType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_cmn__IPv4AddressStringType: + soap_serialize_cmn__IPv4AddressStringType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_cmn__HostNameType: + soap_serialize_cmn__HostNameType(soap, (const std::string *)ptr); + break; + case SOAP_TYPE__wcxs__GetWirelessSettingsResponse: + ((_wcxs__GetWirelessSettingsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__GetWirelessSettingsRequest: + ((_wcxs__GetWirelessSettingsRequest *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse: + ((_wcxs__GetWirelessCapabilitiesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest: + ((_wcxs__GetWirelessCapabilitiesRequest *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse: + ((_wcxs__EnumerateWirelessProfilesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest: + ((_wcxs__EnumerateWirelessProfilesRequest *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__UpdateWirelessProfileResponse: + ((_wcxs__UpdateWirelessProfileResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__UpdateWirelessProfileRequest: + ((_wcxs__UpdateWirelessProfileRequest *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__RemoveWirelessProfileResponse: + ((_wcxs__RemoveWirelessProfileResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__RemoveWirelessProfileRequest: + ((_wcxs__RemoveWirelessProfileRequest *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__GetWirelessProfileResponse: + ((_wcxs__GetWirelessProfileResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__GetWirelessProfileRequest: + ((_wcxs__GetWirelessProfileRequest *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__AddWirelessProfileResponse: + ((_wcxs__AddWirelessProfileResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__wcxs__AddWirelessProfileRequest: + ((_wcxs__AddWirelessProfileRequest *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__WirelessSettingsType: + ((wcxs__WirelessSettingsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__WirelessCapabilitiesType: + ((wcxs__WirelessCapabilitiesType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__ProfileType: + ((wcxs__ProfileType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__ProfileSecuritySettingsType: + ((wcxs__ProfileSecuritySettingsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType: + ((wcxs__ProfileSecuritySettingRSNType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType: + ((wcxs__ProfileSecuritySettingWPAType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__DataEncryptionCCMPType: + ((wcxs__DataEncryptionCCMPType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__DataEncryptionTKIPType: + ((wcxs__DataEncryptionTKIPType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__DataEncryptionWEPType: + ((wcxs__DataEncryptionWEPType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__DataEncryptionWEPXType: + ((wcxs__DataEncryptionWEPXType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__WEP128Type: + ((wcxs__WEP128Type *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_wcxs__WEP64Type: + ((wcxs__WEP64Type *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__rci__GetSystemPowerStateResponse: + ((_rci__GetSystemPowerStateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__rci__GetSystemPowerState: + ((_rci__GetSystemPowerState *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__rci__RemoteControlResponse: + ((_rci__RemoteControlResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__rci__RemoteControl: + ((_rci__RemoteControl *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse: + ((_rci__GetRemoteControlCapabilitiesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__rci__GetRemoteControlCapabilities: + ((_rci__GetRemoteControlCapabilities *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetIderSessionLogResponse: + ((_inf__GetIderSessionLogResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetIderSessionLog: + ((_inf__GetIderSessionLog *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetSecurityParametersResponse: + ((_inf__GetSecurityParametersResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetSecurityParameters: + ((_inf__GetSecurityParameters *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetNetworkStateResponse: + ((_inf__GetNetworkStateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetNetworkState: + ((_inf__GetNetworkState *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetEnabledInterfacesResponse: + ((_inf__GetEnabledInterfacesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetEnabledInterfaces: + ((_inf__GetEnabledInterfaces *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetPasswordModelResponse: + ((_inf__GetPasswordModelResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetPasswordModel: + ((_inf__GetPasswordModel *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse: + ((_inf__GetAdminNetAclEntryStatusResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetAdminNetAclEntryStatus: + ((_inf__GetAdminNetAclEntryStatus *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetAdminAclEntryStatusResponse: + ((_inf__GetAdminAclEntryStatusResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetAdminAclEntryStatus: + ((_inf__GetAdminAclEntryStatus *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetConfigServerInfoResponse: + ((_inf__GetConfigServerInfoResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetConfigServerInfo: + ((_inf__GetConfigServerInfo *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetHostNameResponse: + ((_inf__GetHostNameResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetHostName: + ((_inf__GetHostName *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetVlanParametersResponse: + ((_inf__GetVlanParametersResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetVlanParameters: + ((_inf__GetVlanParameters *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetProvisioningStateResponse: + ((_inf__GetProvisioningStateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetProvisioningState: + ((_inf__GetProvisioningState *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetProvisioningModeResponse: + ((_inf__GetProvisioningModeResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetProvisioningMode: + ((_inf__GetProvisioningMode *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetCodeVersionsResponse: + ((_inf__GetCodeVersionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetCodeVersions: + ((_inf__GetCodeVersions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetCoreVersionResponse: + ((_inf__GetCoreVersionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__inf__GetCoreVersion: + ((_inf__GetCoreVersion *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_inf__FirmwareVersionType: + ((inf__FirmwareVersionType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_inf__IderSessionLogEntryType: + ((inf__IderSessionLogEntryType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__str__ExecuteStorageOperationResponse: + ((_str__ExecuteStorageOperationResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__str__ExecuteStorageOperation: + ((_str__ExecuteStorageOperation *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse: + ((_tim__SetHighAccuracyTimeSynchResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__tim__SetHighAccuracyTimeSynch: + ((_tim__SetHighAccuracyTimeSynch *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse: + ((_tim__GetLowAccuracyTimeSynchResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__tim__GetLowAccuracyTimeSynch: + ((_tim__GetLowAccuracyTimeSynch *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__idr__GetIderSessionLogResponse: + ((_idr__GetIderSessionLogResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__idr__GetIderSessionLog: + ((_idr__GetIderSessionLog *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__idr__GetRedirectionListenerStateResponse: + ((_idr__GetRedirectionListenerStateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__idr__GetRedirectionListenerState: + ((_idr__GetRedirectionListenerState *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__idr__SetRedirectionListenerStateResponse: + ((_idr__SetRedirectionListenerStateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__idr__SetRedirectionListenerState: + ((_idr__SetRedirectionListenerState *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_idr__FirmwareVersionType: + ((idr__FirmwareVersionType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_idr__IderSessionLogEntryType: + ((idr__IderSessionLogEntryType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apl__AgentWatchdogShutdownResponse: + ((_apl__AgentWatchdogShutdownResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apl__AgentWatchdogShutdown: + ((_apl__AgentWatchdogShutdown *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse: + ((_apl__AgentWatchdogHeartbeatResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apl__AgentWatchdogHeartbeat: + ((_apl__AgentWatchdogHeartbeat *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apl__AgentWatchdogRegisterResponse: + ((_apl__AgentWatchdogRegisterResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apl__AgentWatchdogRegister: + ((_apl__AgentWatchdogRegister *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_apl__GUID: + ((apl__GUID *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse: + ((_apr__ConsoleWatchdogQueryCapabilitiesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities: + ((_apr__ConsoleWatchdogQueryCapabilities *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse: + ((_apr__ConsoleWatchdogGetCbPolicyResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy: + ((_apr__ConsoleWatchdogGetCbPolicy *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse: + ((_apr__ConsoleWatchdogSetCbPolicyResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy: + ((_apr__ConsoleWatchdogSetCbPolicy *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse: + ((_apr__ConsoleWatchdogGetActionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogGetActions: + ((_apr__ConsoleWatchdogGetActions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse: + ((_apr__ConsoleWatchdogSetActionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogSetActions: + ((_apr__ConsoleWatchdogSetActions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse: + ((_apr__ConsoleWatchdogEnumerateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogEnumerate: + ((_apr__ConsoleWatchdogEnumerate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse: + ((_apr__ConsoleWatchdogDeleteResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogDelete: + ((_apr__ConsoleWatchdogDelete *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogCreateResponse: + ((_apr__ConsoleWatchdogCreateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__apr__ConsoleWatchdogCreate: + ((_apr__ConsoleWatchdogCreate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_apr__AgentPresenceCapabilitiesType: + ((apr__AgentPresenceCapabilitiesType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType: + ((apr__CircuitBreakerHardwarePolicyType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_apr__ConsoleWatchdogActionType: + ((apr__ConsoleWatchdogActionType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_apr__ConsoleWatchdogEntryType: + ((apr__ConsoleWatchdogEntryType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_apr__GUID: + ((apr__GUID *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__hwa__GetAssetDataResponse: + ((_hwa__GetAssetDataResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__hwa__GetAssetData: + ((_hwa__GetAssetData *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__hwa__EnumerateAssetTypesResponse: + ((_hwa__EnumerateAssetTypesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__hwa__EnumerateAssetTypes: + ((_hwa__EnumerateAssetTypes *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE: + ((hwa__PT_USCOREMEDIA_USCOREDEVICE *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__PT_USCOREFRU: + ((hwa__PT_USCOREFRU *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE: + ((hwa__PT_USCOREMEMORY_USCOREMODULE *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR: + ((hwa__PT_USCOREPROCESSOR *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__PT_USCOREBASEBOARD: + ((hwa__PT_USCOREBASEBOARD *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__GUID: + ((hwa__GUID *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM: + ((hwa__PT_USCORECOMPUTER_USCORESYSTEM *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__PT_USCOREBIOS: + ((hwa__PT_USCOREBIOS *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__AssetDataType: + ((hwa__AssetDataType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__AssetDataArrayType: + ((hwa__AssetDataArrayType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_hwa__AssetTypeArrayType: + ((hwa__AssetTypeArrayType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__GetHcbStateResponse: + ((_cb__GetHcbStateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__GetHcbState: + ((_cb__GetHcbState *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__ClearHcbStateResponse: + ((_cb__ClearHcbStateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__ClearHcbState: + ((_cb__ClearHcbState *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__GetHcbOptionsResponse: + ((_cb__GetHcbOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__GetHcbOptions: + ((_cb__GetHcbOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__SetHcbOptionsResponse: + ((_cb__SetHcbOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__SetHcbOptions: + ((_cb__SetHcbOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbQueryCapabilitiesResponse: + ((_cb__CbQueryCapabilitiesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbQueryCapabilities: + ((_cb__CbQueryCapabilities *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbFilterEnumerateResponse: + ((_cb__CbFilterEnumerateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbFilterEnumerate: + ((_cb__CbFilterEnumerate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbFilterDeleteResponse: + ((_cb__CbFilterDeleteResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbFilterDelete: + ((_cb__CbFilterDelete *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbFilterGetResponse: + ((_cb__CbFilterGetResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbFilterGet: + ((_cb__CbFilterGet *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbFilterCreateResponse: + ((_cb__CbFilterCreateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbFilterCreate: + ((_cb__CbFilterCreate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse: + ((_cb__CbPolicyGetActiveStatisticsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyGetActiveStatistics: + ((_cb__CbPolicyGetActiveStatistics *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyGetEnabledResponse: + ((_cb__CbPolicyGetEnabledResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyGetEnabled: + ((_cb__CbPolicyGetEnabled *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyDisableResponse: + ((_cb__CbPolicyDisableResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyDisable: + ((_cb__CbPolicyDisable *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyEnableResponse: + ((_cb__CbPolicyEnableResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyEnable: + ((_cb__CbPolicyEnable *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyEnumerateResponse: + ((_cb__CbPolicyEnumerateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyEnumerate: + ((_cb__CbPolicyEnumerate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyDeleteResponse: + ((_cb__CbPolicyDeleteResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyDelete: + ((_cb__CbPolicyDelete *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyGetResponse: + ((_cb__CbPolicyGetResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyGet: + ((_cb__CbPolicyGet *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyCreateResponse: + ((_cb__CbPolicyCreateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__cb__CbPolicyCreate: + ((_cb__CbPolicyCreate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__HcbOptionsType: + ((cb__HcbOptionsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__BlockedPortInfoType: + ((cb__BlockedPortInfoType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__TimedCounterType: + ((cb__TimedCounterType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType: + ((cb__CircuitBreakerHardwarePolicyType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType: + ((cb__CircuitBreakerFilterStatisticsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerCapabilitiesType: + ((cb__CircuitBreakerCapabilitiesType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerFilterInfoType: + ((cb__CircuitBreakerFilterInfoType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerFilterType: + ((cb__CircuitBreakerFilterType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerPacketType: + ((cb__CircuitBreakerPacketType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerPacketETHType: + ((cb__CircuitBreakerPacketETHType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerPacketIPType: + ((cb__CircuitBreakerPacketIPType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerPacketTCPType: + ((cb__CircuitBreakerPacketTCPType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerPacketUDPType: + ((cb__CircuitBreakerPacketUDPType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerIPPacketType: + ((cb__CircuitBreakerIPPacketType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerIPv6Type: + ((cb__CircuitBreakerIPv6Type *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerIPv4Type: + ((cb__CircuitBreakerIPv4Type *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType: + ((cb__CircuitBreakerIPLayeredTCPFlagsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType: + ((cb__CircuitBreakerIPLayeredPortType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType: + ((cb__CircuitBreakerIPLayeredPortRangeType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType: + ((cb__CircuitBreakerIPLayeredPortSimpleType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType: + ((cb__CircuitBreakerIPv6AddressAndMaskType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType: + ((cb__CircuitBreakerIPv4AddressAndMaskType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerPolicyInfoType: + ((cb__CircuitBreakerPolicyInfoType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerPolicyType: + ((cb__CircuitBreakerPolicyType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerDefaultFilterType: + ((cb__CircuitBreakerDefaultFilterType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType: + ((cb__CircuitBreakerAntiSpoofingFilterType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse: + ((_emi__GetGeneralAlertSubscriptionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetGeneralAlertSubscription: + ((_emi__GetGeneralAlertSubscription *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse: + ((_emi__EnumerateGeneralAlertSubscriptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions: + ((_emi__EnumerateGeneralAlertSubscriptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__SubscribeForGeneralAlertResponse: + ((_emi__SubscribeForGeneralAlertResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__SubscribeForGeneralAlert: + ((_emi__SubscribeForGeneralAlert *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__CancelAlertSubscriptionResponse: + ((_emi__CancelAlertSubscriptionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__CancelAlertSubscription: + ((_emi__CancelAlertSubscription *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetSensorAttributesResponse: + ((_emi__GetSensorAttributesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetSensorAttributes: + ((_emi__GetSensorAttributes *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateSensorsResponse: + ((_emi__EnumerateSensorsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateSensors: + ((_emi__EnumerateSensors *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetEventLogTimestampClockResponse: + ((_emi__GetEventLogTimestampClockResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetEventLogTimestampClock: + ((_emi__GetEventLogTimestampClock *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__SetEventLogTimestampClockResponse: + ((_emi__SetEventLogTimestampClockResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__SetEventLogTimestampClock: + ((_emi__SetEventLogTimestampClock *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__FreezeEventLogResponse: + ((_emi__FreezeEventLogResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__FreezeEventLog: + ((_emi__FreezeEventLog *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__ClearEventLogResponse: + ((_emi__ClearEventLogResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__ClearEventLog: + ((_emi__ClearEventLog *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetEventLogStatusResponse: + ((_emi__GetEventLogStatusResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetEventLogStatus: + ((_emi__GetEventLogStatus *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__ReadEventLogRecordsResponse: + ((_emi__ReadEventLogRecordsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__ReadEventLogRecords: + ((_emi__ReadEventLogRecords *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__RemoveEventFilterResponse: + ((_emi__RemoveEventFilterResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__RemoveEventFilter: + ((_emi__RemoveEventFilter *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__UpdateEventFilterResponse: + ((_emi__UpdateEventFilterResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__UpdateEventFilter: + ((_emi__UpdateEventFilter *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetEventFilterResponse: + ((_emi__GetEventFilterResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetEventFilter: + ((_emi__GetEventFilter *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateEventFiltersResponse: + ((_emi__EnumerateEventFiltersResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateEventFilters: + ((_emi__EnumerateEventFilters *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__AddEventFilterResponse: + ((_emi__AddEventFilterResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__AddEventFilter: + ((_emi__AddEventFilter *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetAlertCommunityStringResponse: + ((_emi__GetAlertCommunityStringResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetAlertCommunityString: + ((_emi__GetAlertCommunityString *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__SetAlertCommunityStringResponse: + ((_emi__SetAlertCommunityStringResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__SetAlertCommunityString: + ((_emi__SetAlertCommunityString *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateAlertPoliciesResponse: + ((_emi__EnumerateAlertPoliciesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateAlertPolicies: + ((_emi__EnumerateAlertPolicies *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetAlertSubscriptionResponse: + ((_emi__GetAlertSubscriptionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__GetAlertSubscription: + ((_emi__GetAlertSubscription *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse: + ((_emi__EnumerateAlertSubscriptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__EnumerateAlertSubscriptions: + ((_emi__EnumerateAlertSubscriptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__SubscribeForAlertResponse: + ((_emi__SubscribeForAlertResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__emi__SubscribeForAlert: + ((_emi__SubscribeForAlert *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__AlertSubscriptionGeneralType: + ((emi__AlertSubscriptionGeneralType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__AlertSubscriptionSoapType: + ((emi__AlertSubscriptionSoapType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__AlertSubscriptionSNMPType: + ((emi__AlertSubscriptionSNMPType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__AlertCredentialsType: + ((emi__AlertCredentialsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__ByteStr: + ((emi__ByteStr *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__SensorAttributesType: + ((emi__SensorAttributesType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__SensorHandleArrayType: + ((emi__SensorHandleArrayType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__EventLogRecordArrayType: + ((emi__EventLogRecordArrayType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__EventFilterHandleArrayType: + ((emi__EventFilterHandleArrayType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__AlertSubscriptionHandleArrayType: + ((emi__AlertSubscriptionHandleArrayType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__AlertSubscriptionType: + ((emi__AlertSubscriptionType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__EventFilterType: + ((emi__EventFilterType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__EventLogRecordType: + ((emi__EventLogRecordType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__ByteData: + ((emi__ByteData *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType: + ((emi__AlertSubscriptionPolicyIDArrayType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse: + ((_stra__RemoveStorageFpaclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__RemoveStorageFpaclEntry: + ((_stra__RemoveStorageFpaclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse: + ((_stra__UpdateStorageFpaclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__UpdateStorageFpaclEntry: + ((_stra__UpdateStorageFpaclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__GetStorageAllocEntryResponse: + ((_stra__GetStorageAllocEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__GetStorageAllocEntry: + ((_stra__GetStorageAllocEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse: + ((_stra__EnumerateStorageAllocEntriesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__EnumerateStorageAllocEntries: + ((_stra__EnumerateStorageAllocEntries *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AddStorageFpaclEntryResponse: + ((_stra__AddStorageFpaclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AddStorageFpaclEntry: + ((_stra__AddStorageFpaclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__RemoveStorageEaclEntryResponse: + ((_stra__RemoveStorageEaclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__RemoveStorageEaclEntry: + ((_stra__RemoveStorageEaclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__GetStorageEaclEntryResponse: + ((_stra__GetStorageEaclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__GetStorageEaclEntry: + ((_stra__GetStorageEaclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse: + ((_stra__EnumerateStorageEaclEntriesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__EnumerateStorageEaclEntries: + ((_stra__EnumerateStorageEaclEntries *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AddStorageEaclEntryResponse: + ((_stra__AddStorageEaclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AddStorageEaclEntry: + ((_stra__AddStorageEaclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AdminRemoveApplicationResponse: + ((_stra__AdminRemoveApplicationResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AdminRemoveApplication: + ((_stra__AdminRemoveApplication *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AdminGetApplicationAttributesResponse: + ((_stra__AdminGetApplicationAttributesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AdminGetApplicationAttributes: + ((_stra__AdminGetApplicationAttributes *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse: + ((_stra__AdminGetRegisteredApplicationsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__AdminGetRegisteredApplications: + ((_stra__AdminGetRegisteredApplications *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__SetGlobalStorageAttributesResponse: + ((_stra__SetGlobalStorageAttributesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__SetGlobalStorageAttributes: + ((_stra__SetGlobalStorageAttributes *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__GetGlobalStorageAttributesResponse: + ((_stra__GetGlobalStorageAttributesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__stra__GetGlobalStorageAttributes: + ((_stra__GetGlobalStorageAttributes *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__StorageApplicationAttributesType: + ((stra__StorageApplicationAttributesType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__StorageSnrpApplicationAttributeType: + ((stra__StorageSnrpApplicationAttributeType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__StorageApplicationHandleListType: + ((stra__StorageApplicationHandleListType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__GlobalStorageAttributesType: + ((stra__GlobalStorageAttributesType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__GUID: + ((stra__GUID *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__StorageAllocEntryHandleListType: + ((stra__StorageAllocEntryHandleListType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__StorageAllocSnrpEntryType: + ((stra__StorageAllocSnrpEntryType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__StorageAllocEntryType: + ((stra__StorageAllocEntryType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__StorageEaclEntryHandleListType: + ((stra__StorageEaclEntryHandleListType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_stra__StorageEaclEntryType: + ((stra__StorageEaclEntryType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Get8021XPxeTimeoutResponse: + ((_net__Get8021XPxeTimeoutResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Get8021XPxeTimeout: + ((_net__Get8021XPxeTimeout *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Set8021XPxeTimeoutResponse: + ((_net__Set8021XPxeTimeoutResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Set8021XPxeTimeout: + ((_net__Set8021XPxeTimeout *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Get8021XActiveS0Response: + ((_net__Get8021XActiveS0Response *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Get8021XActiveS0: + ((_net__Get8021XActiveS0 *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Set8021XActiveS0Response: + ((_net__Set8021XActiveS0Response *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Set8021XActiveS0: + ((_net__Set8021XActiveS0 *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Set8021XWiredProfileResponse: + ((_net__Set8021XWiredProfileResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Set8021XWiredProfile: + ((_net__Set8021XWiredProfile *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Get8021XWiredProfileResponse: + ((_net__Get8021XWiredProfileResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__Get8021XWiredProfile: + ((_net__Get8021XWiredProfile *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetInterfaceSettingsResponse: + ((_net__SetInterfaceSettingsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetInterfaceSettings: + ((_net__SetInterfaceSettings *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetInterfaceSettingsResponse: + ((_net__GetInterfaceSettingsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetInterfaceSettings: + ((_net__GetInterfaceSettings *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__EnumerateInterfacesResponse: + ((_net__EnumerateInterfacesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__EnumerateInterfaces: + ((_net__EnumerateInterfaces *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetPingResponseResponse: + ((_net__GetPingResponseResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetPingResponse: + ((_net__GetPingResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetPingResponseResponse: + ((_net__SetPingResponseResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetPingResponse: + ((_net__SetPingResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetVlanParametersResponse: + ((_net__GetVlanParametersResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetVlanParameters: + ((_net__GetVlanParameters *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetVlanParametersResponse: + ((_net__SetVlanParametersResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetVlanParameters: + ((_net__SetVlanParameters *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetTcpIpParametersResponse: + ((_net__GetTcpIpParametersResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetTcpIpParameters: + ((_net__GetTcpIpParameters *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetTcpIpParametersResponse: + ((_net__SetTcpIpParametersResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetTcpIpParameters: + ((_net__SetTcpIpParameters *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetDomainNameResponse: + ((_net__GetDomainNameResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetDomainName: + ((_net__GetDomainName *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetDomainNameResponse: + ((_net__SetDomainNameResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetDomainName: + ((_net__SetDomainName *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetHostNameResponse: + ((_net__GetHostNameResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__GetHostName: + ((_net__GetHostName *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetHostNameResponse: + ((_net__SetHostNameResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__net__SetHostName: + ((_net__SetHostName *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_net__InterfaceDescriptorGetType: + ((net__InterfaceDescriptorGetType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_net__InterfaceDescriptorSetType: + ((net__InterfaceDescriptorSetType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_net__IPv4ParametersType: + ((net__IPv4ParametersType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_net__StaticIPv4ParametersType: + ((net__StaticIPv4ParametersType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__XProfileType: + ((xcfg__XProfileType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType: + ((xcfg__XProfileEAPFAST_USCORETLSType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType: + ((xcfg__XProfileEAPFAST_USCOREGTCType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type: + ((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType: + ((xcfg__XProfileEAP_USCOREGTCType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type: + ((xcfg__XProfilePEAP_USCOREMSCHAPv2Type *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type: + ((xcfg__XProfileTTLS_USCOREMSCHAPv2Type *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__XProfileTLSType: + ((xcfg__XProfileTLSType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__ServerIdentityType: + ((xcfg__ServerIdentityType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__ManualPACType: + ((xcfg__ManualPACType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__CertificateNameType: + ((xcfg__CertificateNameType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xcfg__UserCredentialsType: + ((xcfg__UserCredentialsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetAclEnabledStateResponse: + ((_sai__GetAclEnabledStateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetAclEnabledState: + ((_sai__GetAclEnabledState *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetAclEnabledStateResponse: + ((_sai__SetAclEnabledStateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetAclEnabledState: + ((_sai__SetAclEnabledState *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetConfigurationServerFQDNResponse: + ((_sai__GetConfigurationServerFQDNResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetConfigurationServerFQDN: + ((_sai__GetConfigurationServerFQDN *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetConfigurationServerFQDNResponse: + ((_sai__SetConfigurationServerFQDNResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetConfigurationServerFQDN: + ((_sai__SetConfigurationServerFQDN *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnableVpnRoutingResponse: + ((_sai__EnableVpnRoutingResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnableVpnRouting: + ((_sai__EnableVpnRouting *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTLSCredentialsResponse: + ((_sai__GetTLSCredentialsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTLSCredentials: + ((_sai__GetTLSCredentials *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTLSCredentialsResponse: + ((_sai__SetTLSCredentialsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTLSCredentials: + ((_sai__SetTLSCredentials *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreUpdateCertificateResponse: + ((_sai__CertStoreUpdateCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreUpdateCertificate: + ((_sai__CertStoreUpdateCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse: + ((_sai__CertStoreGetPKCS10RequestResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreGetPKCS10Request: + ((_sai__CertStoreGetPKCS10Request *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreRemoveCertificateResponse: + ((_sai__CertStoreRemoveCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreRemoveCertificate: + ((_sai__CertStoreRemoveCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreGetCertificateResponse: + ((_sai__CertStoreGetCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreGetCertificate: + ((_sai__CertStoreGetCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse: + ((_sai__CertStoreEnumerateCertificatesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreEnumerateCertificates: + ((_sai__CertStoreEnumerateCertificates *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreAddCertificateResponse: + ((_sai__CertStoreAddCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreAddCertificate: + ((_sai__CertStoreAddCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreRemoveKeyResponse: + ((_sai__CertStoreRemoveKeyResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreRemoveKey: + ((_sai__CertStoreRemoveKey *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreGetKeyResponse: + ((_sai__CertStoreGetKeyResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreGetKey: + ((_sai__CertStoreGetKey *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreEnumerateKeysResponse: + ((_sai__CertStoreEnumerateKeysResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreEnumerateKeys: + ((_sai__CertStoreEnumerateKeys *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreAddKeyResponse: + ((_sai__CertStoreAddKeyResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CertStoreAddKey: + ((_sai__CertStoreAddKey *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetGlobalPowerPolicyResponse: + ((_sai__GetGlobalPowerPolicyResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetGlobalPowerPolicy: + ((_sai__GetGlobalPowerPolicy *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetGlobalPowerPolicyResponse: + ((_sai__SetGlobalPowerPolicyResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetGlobalPowerPolicy: + ((_sai__SetGlobalPowerPolicy *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetActivePowerPackageResponse: + ((_sai__SetActivePowerPackageResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetActivePowerPackage: + ((_sai__SetActivePowerPackage *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetPowerPackageResponse: + ((_sai__GetPowerPackageResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetPowerPackage: + ((_sai__GetPowerPackage *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetActivePowerPackageResponse: + ((_sai__GetActivePowerPackageResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetActivePowerPackage: + ((_sai__GetActivePowerPackage *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnumeratePowerPackagesResponse: + ((_sai__EnumeratePowerPackagesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnumeratePowerPackages: + ((_sai__EnumeratePowerPackages *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetEnvironmentDetectionResponse: + ((_sai__GetEnvironmentDetectionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetEnvironmentDetection: + ((_sai__GetEnvironmentDetection *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetEnvironmentDetectionResponse: + ((_sai__SetEnvironmentDetectionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetEnvironmentDetection: + ((_sai__SetEnvironmentDetection *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetRealmAuthOptionsResponse: + ((_sai__SetRealmAuthOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetRealmAuthOptions: + ((_sai__SetRealmAuthOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetRealmAuthOptionsResponse: + ((_sai__GetRealmAuthOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetRealmAuthOptions: + ((_sai__GetRealmAuthOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__ExtendProvisioningPeriodResponse: + ((_sai__ExtendProvisioningPeriodResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__ExtendProvisioningPeriod: + ((_sai__ExtendProvisioningPeriod *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetProvisioningPIDResponse: + ((_sai__GetProvisioningPIDResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetProvisioningPID: + ((_sai__GetProvisioningPID *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetProvisioningAuditRecordResponse: + ((_sai__GetProvisioningAuditRecordResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetProvisioningAuditRecord: + ((_sai__GetProvisioningAuditRecord *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse: + ((_sai__SetZeroTouchConfigurationModeResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetZeroTouchConfigurationMode: + ((_sai__SetZeroTouchConfigurationMode *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse: + ((_sai__GetZeroTouchConfigurationModeResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetZeroTouchConfigurationMode: + ((_sai__GetZeroTouchConfigurationMode *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnableCertificateHashEntryResponse: + ((_sai__EnableCertificateHashEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnableCertificateHashEntry: + ((_sai__EnableCertificateHashEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__DeleteCertificateHashEntryResponse: + ((_sai__DeleteCertificateHashEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__DeleteCertificateHashEntry: + ((_sai__DeleteCertificateHashEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__AddCertificateHashEntryResponse: + ((_sai__AddCertificateHashEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__AddCertificateHashEntry: + ((_sai__AddCertificateHashEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetCertificateHashEntryResponse: + ((_sai__GetCertificateHashEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetCertificateHashEntry: + ((_sai__GetCertificateHashEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse: + ((_sai__EnumerateCertificateHashEntriesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnumerateCertificateHashEntries: + ((_sai__EnumerateCertificateHashEntries *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetProvisioningServerOTPResponse: + ((_sai__GetProvisioningServerOTPResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetProvisioningServerOTP: + ((_sai__GetProvisioningServerOTP *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetProvisioningServerOTPResponse: + ((_sai__SetProvisioningServerOTPResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetProvisioningServerOTP: + ((_sai__SetProvisioningServerOTP *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetMEBxPasswordResponse: + ((_sai__SetMEBxPasswordResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetMEBxPassword: + ((_sai__SetMEBxPassword *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__PartialUnprovisionResponse: + ((_sai__PartialUnprovisionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__PartialUnprovision: + ((_sai__PartialUnprovision *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTLSPSKResponse: + ((_sai__SetTLSPSKResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTLSPSK: + ((_sai__SetTLSPSK *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetPowerSavingOptionsResponse: + ((_sai__GetPowerSavingOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetPowerSavingOptions: + ((_sai__GetPowerSavingOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetPowerSavingOptionsResponse: + ((_sai__SetPowerSavingOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetPowerSavingOptions: + ((_sai__SetPowerSavingOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetPkiCapabilitiesResponse: + ((_sai__GetPkiCapabilitiesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetPkiCapabilities: + ((_sai__GetPkiCapabilities *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetServerCertificateReqResponse: + ((_sai__GetServerCertificateReqResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetServerCertificateReq: + ((_sai__GetServerCertificateReq *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetCRLResponse: + ((_sai__GetCRLResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetCRL: + ((_sai__GetCRL *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetCRLResponse: + ((_sai__SetCRLResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetCRL: + ((_sai__SetCRL *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTrustedFqdnCNResponse: + ((_sai__GetTrustedFqdnCNResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTrustedFqdnCN: + ((_sai__GetTrustedFqdnCN *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTrustedFqdnCNResponse: + ((_sai__SetTrustedFqdnCNResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTrustedFqdnCN: + ((_sai__SetTrustedFqdnCN *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse: + ((_sai__EnumerateTrustedRootCertificatesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnumerateTrustedRootCertificates: + ((_sai__EnumerateTrustedRootCertificates *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse: + ((_sai__DeleteTrustedRootCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__DeleteTrustedRootCertificate: + ((_sai__DeleteTrustedRootCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTrustedRootCertificateResponse: + ((_sai__GetTrustedRootCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTrustedRootCertificate: + ((_sai__GetTrustedRootCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__AddTrustedRootCertificateResponse: + ((_sai__AddTrustedRootCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__AddTrustedRootCertificate: + ((_sai__AddTrustedRootCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTlsOptionsResponse: + ((_sai__GetTlsOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTlsOptions: + ((_sai__GetTlsOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTlsOptionsResponse: + ((_sai__SetTlsOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTlsOptions: + ((_sai__SetTlsOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetEnabledInterfacesResponse: + ((_sai__GetEnabledInterfacesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetEnabledInterfaces: + ((_sai__GetEnabledInterfaces *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetEnabledInterfacesResponse: + ((_sai__SetEnabledInterfacesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetEnabledInterfaces: + ((_sai__SetEnabledInterfaces *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetKerberosOptionsResponse: + ((_sai__GetKerberosOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetKerberosOptions: + ((_sai__GetKerberosOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetKerberosOptionsResponse: + ((_sai__SetKerberosOptionsResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetKerberosOptions: + ((_sai__SetKerberosOptions *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetDigestRealmResponse: + ((_sai__GetDigestRealmResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetDigestRealm: + ((_sai__GetDigestRealm *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetAdminAclEntryExResponse: + ((_sai__SetAdminAclEntryExResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetAdminAclEntryEx: + ((_sai__SetAdminAclEntryEx *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__UpdateUserAclEntryExResponse: + ((_sai__UpdateUserAclEntryExResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__UpdateUserAclEntryEx: + ((_sai__UpdateUserAclEntryEx *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetUserAclEntryExResponse: + ((_sai__GetUserAclEntryExResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetUserAclEntryEx: + ((_sai__GetUserAclEntryEx *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__AddUserAclEntryExResponse: + ((_sai__AddUserAclEntryExResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__AddUserAclEntryEx: + ((_sai__AddUserAclEntryEx *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetCoreVersionResponse: + ((_sai__GetCoreVersionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetCoreVersion: + ((_sai__GetCoreVersion *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse: + ((_sai__ResetFlashWearOutProtectionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__ResetFlashWearOutProtection: + ((_sai__ResetFlashWearOutProtection *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CommitChangesResponse: + ((_sai__CommitChangesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__CommitChanges: + ((_sai__CommitChanges *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__UnprovisionResponse: + ((_sai__UnprovisionResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__Unprovision: + ((_sai__Unprovision *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetProvisioningModeResponse: + ((_sai__SetProvisioningModeResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetProvisioningMode: + ((_sai__SetProvisioningMode *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetProvisioningModeResponse: + ((_sai__GetProvisioningModeResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetProvisioningMode: + ((_sai__GetProvisioningMode *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__UpdateCoreFromUrlResponse: + ((_sai__UpdateCoreFromUrlResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__UpdateCoreFromUrl: + ((_sai__UpdateCoreFromUrl *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTLSCertificateResponse: + ((_sai__GetTLSCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetTLSCertificate: + ((_sai__GetTLSCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTLSCertificateResponse: + ((_sai__SetTLSCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTLSCertificate: + ((_sai__SetTLSCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetRngKeyResponse: + ((_sai__SetRngKeyResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetRngKey: + ((_sai__SetRngKey *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse: + ((_sai__SetTLSKeyAndCertificateResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTLSKeyAndCertificate: + ((_sai__SetTLSKeyAndCertificate *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTlsEnabledResponse: + ((_sai__SetTlsEnabledResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetTlsEnabled: + ((_sai__SetTlsEnabled *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__RemoveUserAclEntryResponse: + ((_sai__RemoveUserAclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__RemoveUserAclEntry: + ((_sai__RemoveUserAclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__UpdateUserAclEntryResponse: + ((_sai__UpdateUserAclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__UpdateUserAclEntry: + ((_sai__UpdateUserAclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetAdminAclEntryResponse: + ((_sai__GetAdminAclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetAdminAclEntry: + ((_sai__GetAdminAclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetUserAclEntryResponse: + ((_sai__GetUserAclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__GetUserAclEntry: + ((_sai__GetUserAclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnumerateUserAclEntriesResponse: + ((_sai__EnumerateUserAclEntriesResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__EnumerateUserAclEntries: + ((_sai__EnumerateUserAclEntries *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetAdminAclEntryResponse: + ((_sai__SetAdminAclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__SetAdminAclEntry: + ((_sai__SetAdminAclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__AddUserAclEntryResponse: + ((_sai__AddUserAclEntryResponse *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE__sai__AddUserAclEntry: + ((_sai__AddUserAclEntry *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__GlobalPowerPolicyType: + ((sai__GlobalPowerPolicyType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__EnvironmentDetectionType: + ((sai__EnvironmentDetectionType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__EnvironmentDetectionDomainType: + ((sai__EnvironmentDetectionDomainType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__ProvisioningAuditRecordType: + ((sai__ProvisioningAuditRecordType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__CertHashEntryType: + ((sai__CertHashEntryType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__PkiCapsType: + ((sai__PkiCapsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__CrlType: + ((sai__CrlType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__CertificateType: + ((sai__CertificateType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__TlsOptionsType: + ((sai__TlsOptionsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__KerberosOptionsType: + ((sai__KerberosOptionsType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__KerberosSpnType: + ((sai__KerberosSpnType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__AdminAclEntryExType: + ((sai__AdminAclEntryExType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__UserAclEntryExType: + ((sai__UserAclEntryExType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__UserEntryKerberosType: + ((sai__UserEntryKerberosType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__UserEntryDigestType: + ((sai__UserEntryDigestType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__AmtVersion: + ((sai__AmtVersion *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__UpdateCoreUrlKeyType: + ((sai__UpdateCoreUrlKeyType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__CertificateChainType: + ((sai__CertificateChainType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__RngKeyType: + ((sai__RngKeyType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__RsaKeyType: + ((sai__RsaKeyType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__UserAclRealmListType: + ((sai__UserAclRealmListType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__UserAclEntryHandleListType: + ((sai__UserAclEntryHandleListType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__AdminAclEntryType: + ((sai__AdminAclEntryType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_sai__UserAclEntryType: + ((sai__UserAclEntryType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cstr__KeyPairType: + ((cstr__KeyPairType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cstr__RSAKeyPairType: + ((cstr__RSAKeyPairType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cmn__NodeAddressType: + ((cmn__NodeAddressType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_cmn__URLType: + ((cmn__URLType *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xsd__base64Binary: + ((xsd__base64Binary *)ptr)->soap_serialize(soap); + break; + case SOAP_TYPE_xsd__anyURI: + soap_serialize_xsd__anyURI(soap, (const std::string *)ptr); + break; + case SOAP_TYPE_std__string: + soap_serialize_std__string(soap, (const std::string *)ptr); + break; + case SOAP_TYPE___wcxs__GetWirelessSettings: + soap_serialize___wcxs__GetWirelessSettings(soap, (const struct __wcxs__GetWirelessSettings *)ptr); + break; + case SOAP_TYPE___wcxs__GetWirelessCapabilities: + soap_serialize___wcxs__GetWirelessCapabilities(soap, (const struct __wcxs__GetWirelessCapabilities *)ptr); + break; + case SOAP_TYPE___wcxs__EnumerateWirelessProfiles: + soap_serialize___wcxs__EnumerateWirelessProfiles(soap, (const struct __wcxs__EnumerateWirelessProfiles *)ptr); + break; + case SOAP_TYPE___wcxs__UpdateWirelessProfile: + soap_serialize___wcxs__UpdateWirelessProfile(soap, (const struct __wcxs__UpdateWirelessProfile *)ptr); + break; + case SOAP_TYPE___wcxs__RemoveWirelessProfile: + soap_serialize___wcxs__RemoveWirelessProfile(soap, (const struct __wcxs__RemoveWirelessProfile *)ptr); + break; + case SOAP_TYPE___wcxs__GetWirelessProfile: + soap_serialize___wcxs__GetWirelessProfile(soap, (const struct __wcxs__GetWirelessProfile *)ptr); + break; + case SOAP_TYPE___wcxs__AddWirelessProfile: + soap_serialize___wcxs__AddWirelessProfile(soap, (const struct __wcxs__AddWirelessProfile *)ptr); + break; + case SOAP_TYPE___tim__SetHighAccuracyTimeSynch: + soap_serialize___tim__SetHighAccuracyTimeSynch(soap, (const struct __tim__SetHighAccuracyTimeSynch *)ptr); + break; + case SOAP_TYPE___tim__GetLowAccuracyTimeSynch: + soap_serialize___tim__GetLowAccuracyTimeSynch(soap, (const struct __tim__GetLowAccuracyTimeSynch *)ptr); + break; + case SOAP_TYPE___stra__RemoveStorageFpaclEntry: + soap_serialize___stra__RemoveStorageFpaclEntry(soap, (const struct __stra__RemoveStorageFpaclEntry *)ptr); + break; + case SOAP_TYPE___stra__UpdateStorageFpaclEntry: + soap_serialize___stra__UpdateStorageFpaclEntry(soap, (const struct __stra__UpdateStorageFpaclEntry *)ptr); + break; + case SOAP_TYPE___stra__GetStorageAllocEntry: + soap_serialize___stra__GetStorageAllocEntry(soap, (const struct __stra__GetStorageAllocEntry *)ptr); + break; + case SOAP_TYPE___stra__EnumerateStorageAllocEntries: + soap_serialize___stra__EnumerateStorageAllocEntries(soap, (const struct __stra__EnumerateStorageAllocEntries *)ptr); + break; + case SOAP_TYPE___stra__AddStorageFpaclEntry: + soap_serialize___stra__AddStorageFpaclEntry(soap, (const struct __stra__AddStorageFpaclEntry *)ptr); + break; + case SOAP_TYPE___stra__RemoveStorageEaclEntry: + soap_serialize___stra__RemoveStorageEaclEntry(soap, (const struct __stra__RemoveStorageEaclEntry *)ptr); + break; + case SOAP_TYPE___stra__GetStorageEaclEntry: + soap_serialize___stra__GetStorageEaclEntry(soap, (const struct __stra__GetStorageEaclEntry *)ptr); + break; + case SOAP_TYPE___stra__EnumerateStorageEaclEntries: + soap_serialize___stra__EnumerateStorageEaclEntries(soap, (const struct __stra__EnumerateStorageEaclEntries *)ptr); + break; + case SOAP_TYPE___stra__AddStorageEaclEntry: + soap_serialize___stra__AddStorageEaclEntry(soap, (const struct __stra__AddStorageEaclEntry *)ptr); + break; + case SOAP_TYPE___stra__AdminRemoveApplication: + soap_serialize___stra__AdminRemoveApplication(soap, (const struct __stra__AdminRemoveApplication *)ptr); + break; + case SOAP_TYPE___stra__AdminGetApplicationAttributes: + soap_serialize___stra__AdminGetApplicationAttributes(soap, (const struct __stra__AdminGetApplicationAttributes *)ptr); + break; + case SOAP_TYPE___stra__AdminGetRegisteredApplications: + soap_serialize___stra__AdminGetRegisteredApplications(soap, (const struct __stra__AdminGetRegisteredApplications *)ptr); + break; + case SOAP_TYPE___stra__SetGlobalStorageAttributes: + soap_serialize___stra__SetGlobalStorageAttributes(soap, (const struct __stra__SetGlobalStorageAttributes *)ptr); + break; + case SOAP_TYPE___stra__GetGlobalStorageAttributes: + soap_serialize___stra__GetGlobalStorageAttributes(soap, (const struct __stra__GetGlobalStorageAttributes *)ptr); + break; + case SOAP_TYPE___str__ExecuteStorageOperation: + soap_serialize___str__ExecuteStorageOperation(soap, (const struct __str__ExecuteStorageOperation *)ptr); + break; + case SOAP_TYPE___sai__GetAclEnabledState: + soap_serialize___sai__GetAclEnabledState(soap, (const struct __sai__GetAclEnabledState *)ptr); + break; + case SOAP_TYPE___sai__SetAclEnabledState: + soap_serialize___sai__SetAclEnabledState(soap, (const struct __sai__SetAclEnabledState *)ptr); + break; + case SOAP_TYPE___sai__SetConfigurationServerFQDN: + soap_serialize___sai__SetConfigurationServerFQDN(soap, (const struct __sai__SetConfigurationServerFQDN *)ptr); + break; + case SOAP_TYPE___sai__GetConfigurationServerFQDN: + soap_serialize___sai__GetConfigurationServerFQDN(soap, (const struct __sai__GetConfigurationServerFQDN *)ptr); + break; + case SOAP_TYPE___sai__EnableVpnRouting: + soap_serialize___sai__EnableVpnRouting(soap, (const struct __sai__EnableVpnRouting *)ptr); + break; + case SOAP_TYPE___sai__GetTLSCredentials: + soap_serialize___sai__GetTLSCredentials(soap, (const struct __sai__GetTLSCredentials *)ptr); + break; + case SOAP_TYPE___sai__SetTLSCredentials: + soap_serialize___sai__SetTLSCredentials(soap, (const struct __sai__SetTLSCredentials *)ptr); + break; + case SOAP_TYPE___sai__CertStoreUpdateCertificate: + soap_serialize___sai__CertStoreUpdateCertificate(soap, (const struct __sai__CertStoreUpdateCertificate *)ptr); + break; + case SOAP_TYPE___sai__CertStoreGetPKCS10Request: + soap_serialize___sai__CertStoreGetPKCS10Request(soap, (const struct __sai__CertStoreGetPKCS10Request *)ptr); + break; + case SOAP_TYPE___sai__CertStoreRemoveCertificate: + soap_serialize___sai__CertStoreRemoveCertificate(soap, (const struct __sai__CertStoreRemoveCertificate *)ptr); + break; + case SOAP_TYPE___sai__CertStoreEnumerateCertificates: + soap_serialize___sai__CertStoreEnumerateCertificates(soap, (const struct __sai__CertStoreEnumerateCertificates *)ptr); + break; + case SOAP_TYPE___sai__CertStoreGetCertificate: + soap_serialize___sai__CertStoreGetCertificate(soap, (const struct __sai__CertStoreGetCertificate *)ptr); + break; + case SOAP_TYPE___sai__CertStoreAddCertificate: + soap_serialize___sai__CertStoreAddCertificate(soap, (const struct __sai__CertStoreAddCertificate *)ptr); + break; + case SOAP_TYPE___sai__CertStoreRemoveKey: + soap_serialize___sai__CertStoreRemoveKey(soap, (const struct __sai__CertStoreRemoveKey *)ptr); + break; + case SOAP_TYPE___sai__CertStoreGetKey: + soap_serialize___sai__CertStoreGetKey(soap, (const struct __sai__CertStoreGetKey *)ptr); + break; + case SOAP_TYPE___sai__CertStoreEnumerateKeys: + soap_serialize___sai__CertStoreEnumerateKeys(soap, (const struct __sai__CertStoreEnumerateKeys *)ptr); + break; + case SOAP_TYPE___sai__CertStoreAddKey: + soap_serialize___sai__CertStoreAddKey(soap, (const struct __sai__CertStoreAddKey *)ptr); + break; + case SOAP_TYPE___sai__GetGlobalPowerPolicy: + soap_serialize___sai__GetGlobalPowerPolicy(soap, (const struct __sai__GetGlobalPowerPolicy *)ptr); + break; + case SOAP_TYPE___sai__SetGlobalPowerPolicy: + soap_serialize___sai__SetGlobalPowerPolicy(soap, (const struct __sai__SetGlobalPowerPolicy *)ptr); + break; + case SOAP_TYPE___sai__SetActivePowerPackage: + soap_serialize___sai__SetActivePowerPackage(soap, (const struct __sai__SetActivePowerPackage *)ptr); + break; + case SOAP_TYPE___sai__GetActivePowerPackage: + soap_serialize___sai__GetActivePowerPackage(soap, (const struct __sai__GetActivePowerPackage *)ptr); + break; + case SOAP_TYPE___sai__GetPowerPackage: + soap_serialize___sai__GetPowerPackage(soap, (const struct __sai__GetPowerPackage *)ptr); + break; + case SOAP_TYPE___sai__EnumeratePowerPackages: + soap_serialize___sai__EnumeratePowerPackages(soap, (const struct __sai__EnumeratePowerPackages *)ptr); + break; + case SOAP_TYPE___sai__GetEnvironmentDetection: + soap_serialize___sai__GetEnvironmentDetection(soap, (const struct __sai__GetEnvironmentDetection *)ptr); + break; + case SOAP_TYPE___sai__SetEnvironmentDetection: + soap_serialize___sai__SetEnvironmentDetection(soap, (const struct __sai__SetEnvironmentDetection *)ptr); + break; + case SOAP_TYPE___sai__SetRealmAuthOptions: + soap_serialize___sai__SetRealmAuthOptions(soap, (const struct __sai__SetRealmAuthOptions *)ptr); + break; + case SOAP_TYPE___sai__GetRealmAuthOptions: + soap_serialize___sai__GetRealmAuthOptions(soap, (const struct __sai__GetRealmAuthOptions *)ptr); + break; + case SOAP_TYPE___sai__ExtendProvisioningPeriod: + soap_serialize___sai__ExtendProvisioningPeriod(soap, (const struct __sai__ExtendProvisioningPeriod *)ptr); + break; + case SOAP_TYPE___sai__GetProvisioningPID: + soap_serialize___sai__GetProvisioningPID(soap, (const struct __sai__GetProvisioningPID *)ptr); + break; + case SOAP_TYPE___sai__GetProvisioningAuditRecord: + soap_serialize___sai__GetProvisioningAuditRecord(soap, (const struct __sai__GetProvisioningAuditRecord *)ptr); + break; + case SOAP_TYPE___sai__SetZeroTouchConfigurationMode: + soap_serialize___sai__SetZeroTouchConfigurationMode(soap, (const struct __sai__SetZeroTouchConfigurationMode *)ptr); + break; + case SOAP_TYPE___sai__GetZeroTouchConfigurationMode: + soap_serialize___sai__GetZeroTouchConfigurationMode(soap, (const struct __sai__GetZeroTouchConfigurationMode *)ptr); + break; + case SOAP_TYPE___sai__EnableCertificateHashEntry: + soap_serialize___sai__EnableCertificateHashEntry(soap, (const struct __sai__EnableCertificateHashEntry *)ptr); + break; + case SOAP_TYPE___sai__DeleteCertificateHashEntry: + soap_serialize___sai__DeleteCertificateHashEntry(soap, (const struct __sai__DeleteCertificateHashEntry *)ptr); + break; + case SOAP_TYPE___sai__AddCertificateHashEntry: + soap_serialize___sai__AddCertificateHashEntry(soap, (const struct __sai__AddCertificateHashEntry *)ptr); + break; + case SOAP_TYPE___sai__GetCertificateHashEntry: + soap_serialize___sai__GetCertificateHashEntry(soap, (const struct __sai__GetCertificateHashEntry *)ptr); + break; + case SOAP_TYPE___sai__EnumerateCertificateHashEntries: + soap_serialize___sai__EnumerateCertificateHashEntries(soap, (const struct __sai__EnumerateCertificateHashEntries *)ptr); + break; + case SOAP_TYPE___sai__GetProvisioningServerOTP: + soap_serialize___sai__GetProvisioningServerOTP(soap, (const struct __sai__GetProvisioningServerOTP *)ptr); + break; + case SOAP_TYPE___sai__SetProvisioningServerOTP: + soap_serialize___sai__SetProvisioningServerOTP(soap, (const struct __sai__SetProvisioningServerOTP *)ptr); + break; + case SOAP_TYPE___sai__SetMEBxPassword: + soap_serialize___sai__SetMEBxPassword(soap, (const struct __sai__SetMEBxPassword *)ptr); + break; + case SOAP_TYPE___sai__PartialUnprovision: + soap_serialize___sai__PartialUnprovision(soap, (const struct __sai__PartialUnprovision *)ptr); + break; + case SOAP_TYPE___sai__SetTLSPSK: + soap_serialize___sai__SetTLSPSK(soap, (const struct __sai__SetTLSPSK *)ptr); + break; + case SOAP_TYPE___sai__GetPowerSavingOptions: + soap_serialize___sai__GetPowerSavingOptions(soap, (const struct __sai__GetPowerSavingOptions *)ptr); + break; + case SOAP_TYPE___sai__SetPowerSavingOptions: + soap_serialize___sai__SetPowerSavingOptions(soap, (const struct __sai__SetPowerSavingOptions *)ptr); + break; + case SOAP_TYPE___sai__GetPkiCapabilities: + soap_serialize___sai__GetPkiCapabilities(soap, (const struct __sai__GetPkiCapabilities *)ptr); + break; + case SOAP_TYPE___sai__GetServerCertificateReq: + soap_serialize___sai__GetServerCertificateReq(soap, (const struct __sai__GetServerCertificateReq *)ptr); + break; + case SOAP_TYPE___sai__GetCRL: + soap_serialize___sai__GetCRL(soap, (const struct __sai__GetCRL *)ptr); + break; + case SOAP_TYPE___sai__SetCRL: + soap_serialize___sai__SetCRL(soap, (const struct __sai__SetCRL *)ptr); + break; + case SOAP_TYPE___sai__GetTrustedFqdnCN: + soap_serialize___sai__GetTrustedFqdnCN(soap, (const struct __sai__GetTrustedFqdnCN *)ptr); + break; + case SOAP_TYPE___sai__SetTrustedFqdnCN: + soap_serialize___sai__SetTrustedFqdnCN(soap, (const struct __sai__SetTrustedFqdnCN *)ptr); + break; + case SOAP_TYPE___sai__EnumerateTrustedRootCertificates: + soap_serialize___sai__EnumerateTrustedRootCertificates(soap, (const struct __sai__EnumerateTrustedRootCertificates *)ptr); + break; + case SOAP_TYPE___sai__DeleteTrustedRootCertificate: + soap_serialize___sai__DeleteTrustedRootCertificate(soap, (const struct __sai__DeleteTrustedRootCertificate *)ptr); + break; + case SOAP_TYPE___sai__GetTrustedRootCertificate: + soap_serialize___sai__GetTrustedRootCertificate(soap, (const struct __sai__GetTrustedRootCertificate *)ptr); + break; + case SOAP_TYPE___sai__AddTrustedRootCertificate: + soap_serialize___sai__AddTrustedRootCertificate(soap, (const struct __sai__AddTrustedRootCertificate *)ptr); + break; + case SOAP_TYPE___sai__GetTlsOptions: + soap_serialize___sai__GetTlsOptions(soap, (const struct __sai__GetTlsOptions *)ptr); + break; + case SOAP_TYPE___sai__SetTlsOptions: + soap_serialize___sai__SetTlsOptions(soap, (const struct __sai__SetTlsOptions *)ptr); + break; + case SOAP_TYPE___sai__GetEnabledInterfaces: + soap_serialize___sai__GetEnabledInterfaces(soap, (const struct __sai__GetEnabledInterfaces *)ptr); + break; + case SOAP_TYPE___sai__SetEnabledInterfaces: + soap_serialize___sai__SetEnabledInterfaces(soap, (const struct __sai__SetEnabledInterfaces *)ptr); + break; + case SOAP_TYPE___sai__GetKerberosOptions: + soap_serialize___sai__GetKerberosOptions(soap, (const struct __sai__GetKerberosOptions *)ptr); + break; + case SOAP_TYPE___sai__SetKerberosOptions: + soap_serialize___sai__SetKerberosOptions(soap, (const struct __sai__SetKerberosOptions *)ptr); + break; + case SOAP_TYPE___sai__GetDigestRealm: + soap_serialize___sai__GetDigestRealm(soap, (const struct __sai__GetDigestRealm *)ptr); + break; + case SOAP_TYPE___sai__SetAdminAclEntryEx: + soap_serialize___sai__SetAdminAclEntryEx(soap, (const struct __sai__SetAdminAclEntryEx *)ptr); + break; + case SOAP_TYPE___sai__UpdateUserAclEntryEx: + soap_serialize___sai__UpdateUserAclEntryEx(soap, (const struct __sai__UpdateUserAclEntryEx *)ptr); + break; + case SOAP_TYPE___sai__GetUserAclEntryEx: + soap_serialize___sai__GetUserAclEntryEx(soap, (const struct __sai__GetUserAclEntryEx *)ptr); + break; + case SOAP_TYPE___sai__AddUserAclEntryEx: + soap_serialize___sai__AddUserAclEntryEx(soap, (const struct __sai__AddUserAclEntryEx *)ptr); + break; + case SOAP_TYPE___sai__GetCoreVersion: + soap_serialize___sai__GetCoreVersion(soap, (const struct __sai__GetCoreVersion *)ptr); + break; + case SOAP_TYPE___sai__CommitChanges: + soap_serialize___sai__CommitChanges(soap, (const struct __sai__CommitChanges *)ptr); + break; + case SOAP_TYPE___sai__Unprovision: + soap_serialize___sai__Unprovision(soap, (const struct __sai__Unprovision *)ptr); + break; + case SOAP_TYPE___sai__SetProvisioningMode: + soap_serialize___sai__SetProvisioningMode(soap, (const struct __sai__SetProvisioningMode *)ptr); + break; + case SOAP_TYPE___sai__GetProvisioningMode: + soap_serialize___sai__GetProvisioningMode(soap, (const struct __sai__GetProvisioningMode *)ptr); + break; + case SOAP_TYPE___sai__UpdateCoreFromUrl: + soap_serialize___sai__UpdateCoreFromUrl(soap, (const struct __sai__UpdateCoreFromUrl *)ptr); + break; + case SOAP_TYPE___sai__GetTLSCertificate: + soap_serialize___sai__GetTLSCertificate(soap, (const struct __sai__GetTLSCertificate *)ptr); + break; + case SOAP_TYPE___sai__SetTLSCertificate: + soap_serialize___sai__SetTLSCertificate(soap, (const struct __sai__SetTLSCertificate *)ptr); + break; + case SOAP_TYPE___sai__SetTLSKeyAndCertificate: + soap_serialize___sai__SetTLSKeyAndCertificate(soap, (const struct __sai__SetTLSKeyAndCertificate *)ptr); + break; + case SOAP_TYPE___sai__SetRngKey: + soap_serialize___sai__SetRngKey(soap, (const struct __sai__SetRngKey *)ptr); + break; + case SOAP_TYPE___sai__SetTlsEnabled: + soap_serialize___sai__SetTlsEnabled(soap, (const struct __sai__SetTlsEnabled *)ptr); + break; + case SOAP_TYPE___sai__RemoveUserAclEntry: + soap_serialize___sai__RemoveUserAclEntry(soap, (const struct __sai__RemoveUserAclEntry *)ptr); + break; + case SOAP_TYPE___sai__UpdateUserAclEntry: + soap_serialize___sai__UpdateUserAclEntry(soap, (const struct __sai__UpdateUserAclEntry *)ptr); + break; + case SOAP_TYPE___sai__GetUserAclEntry: + soap_serialize___sai__GetUserAclEntry(soap, (const struct __sai__GetUserAclEntry *)ptr); + break; + case SOAP_TYPE___sai__EnumerateUserAclEntries: + soap_serialize___sai__EnumerateUserAclEntries(soap, (const struct __sai__EnumerateUserAclEntries *)ptr); + break; + case SOAP_TYPE___sai__AddUserAclEntry: + soap_serialize___sai__AddUserAclEntry(soap, (const struct __sai__AddUserAclEntry *)ptr); + break; + case SOAP_TYPE___sai__SetAdminAclEntry: + soap_serialize___sai__SetAdminAclEntry(soap, (const struct __sai__SetAdminAclEntry *)ptr); + break; + case SOAP_TYPE___sai__GetAdminAclEntry: + soap_serialize___sai__GetAdminAclEntry(soap, (const struct __sai__GetAdminAclEntry *)ptr); + break; + case SOAP_TYPE___sai__ResetFlashWearOutProtection: + soap_serialize___sai__ResetFlashWearOutProtection(soap, (const struct __sai__ResetFlashWearOutProtection *)ptr); + break; + case SOAP_TYPE___rci__GetSystemPowerState: + soap_serialize___rci__GetSystemPowerState(soap, (const struct __rci__GetSystemPowerState *)ptr); + break; + case SOAP_TYPE___rci__RemoteControl: + soap_serialize___rci__RemoteControl(soap, (const struct __rci__RemoteControl *)ptr); + break; + case SOAP_TYPE___rci__GetRemoteControlCapabilities: + soap_serialize___rci__GetRemoteControlCapabilities(soap, (const struct __rci__GetRemoteControlCapabilities *)ptr); + break; + case SOAP_TYPE___net__Get8021XPxeTimeout: + soap_serialize___net__Get8021XPxeTimeout(soap, (const struct __net__Get8021XPxeTimeout *)ptr); + break; + case SOAP_TYPE___net__Set8021XPxeTimeout: + soap_serialize___net__Set8021XPxeTimeout(soap, (const struct __net__Set8021XPxeTimeout *)ptr); + break; + case SOAP_TYPE___net__Get8021XActiveS0: + soap_serialize___net__Get8021XActiveS0(soap, (const struct __net__Get8021XActiveS0 *)ptr); + break; + case SOAP_TYPE___net__Set8021XActiveS0: + soap_serialize___net__Set8021XActiveS0(soap, (const struct __net__Set8021XActiveS0 *)ptr); + break; + case SOAP_TYPE___net__Get8021XWiredProfile: + soap_serialize___net__Get8021XWiredProfile(soap, (const struct __net__Get8021XWiredProfile *)ptr); + break; + case SOAP_TYPE___net__Set8021XWiredProfile: + soap_serialize___net__Set8021XWiredProfile(soap, (const struct __net__Set8021XWiredProfile *)ptr); + break; + case SOAP_TYPE___net__SetInterfaceSettings: + soap_serialize___net__SetInterfaceSettings(soap, (const struct __net__SetInterfaceSettings *)ptr); + break; + case SOAP_TYPE___net__GetInterfaceSettings: + soap_serialize___net__GetInterfaceSettings(soap, (const struct __net__GetInterfaceSettings *)ptr); + break; + case SOAP_TYPE___net__EnumerateInterfaces: + soap_serialize___net__EnumerateInterfaces(soap, (const struct __net__EnumerateInterfaces *)ptr); + break; + case SOAP_TYPE___net__GetPingResponse: + soap_serialize___net__GetPingResponse(soap, (const struct __net__GetPingResponse *)ptr); + break; + case SOAP_TYPE___net__SetPingResponse: + soap_serialize___net__SetPingResponse(soap, (const struct __net__SetPingResponse *)ptr); + break; + case SOAP_TYPE___net__GetVlanParameters: + soap_serialize___net__GetVlanParameters(soap, (const struct __net__GetVlanParameters *)ptr); + break; + case SOAP_TYPE___net__SetVlanParameters: + soap_serialize___net__SetVlanParameters(soap, (const struct __net__SetVlanParameters *)ptr); + break; + case SOAP_TYPE___net__GetTcpIpParameters: + soap_serialize___net__GetTcpIpParameters(soap, (const struct __net__GetTcpIpParameters *)ptr); + break; + case SOAP_TYPE___net__SetTcpIpParameters: + soap_serialize___net__SetTcpIpParameters(soap, (const struct __net__SetTcpIpParameters *)ptr); + break; + case SOAP_TYPE___net__GetDomainName: + soap_serialize___net__GetDomainName(soap, (const struct __net__GetDomainName *)ptr); + break; + case SOAP_TYPE___net__SetDomainName: + soap_serialize___net__SetDomainName(soap, (const struct __net__SetDomainName *)ptr); + break; + case SOAP_TYPE___net__GetHostName: + soap_serialize___net__GetHostName(soap, (const struct __net__GetHostName *)ptr); + break; + case SOAP_TYPE___net__SetHostName: + soap_serialize___net__SetHostName(soap, (const struct __net__SetHostName *)ptr); + break; + case SOAP_TYPE___inf__GetIderSessionLog: + soap_serialize___inf__GetIderSessionLog(soap, (const struct __inf__GetIderSessionLog *)ptr); + break; + case SOAP_TYPE___inf__GetSecurityParameters: + soap_serialize___inf__GetSecurityParameters(soap, (const struct __inf__GetSecurityParameters *)ptr); + break; + case SOAP_TYPE___inf__GetNetworkState: + soap_serialize___inf__GetNetworkState(soap, (const struct __inf__GetNetworkState *)ptr); + break; + case SOAP_TYPE___inf__GetEnabledInterfaces: + soap_serialize___inf__GetEnabledInterfaces(soap, (const struct __inf__GetEnabledInterfaces *)ptr); + break; + case SOAP_TYPE___inf__GetPasswordModel: + soap_serialize___inf__GetPasswordModel(soap, (const struct __inf__GetPasswordModel *)ptr); + break; + case SOAP_TYPE___inf__GetAdminNetAclEntryStatus: + soap_serialize___inf__GetAdminNetAclEntryStatus(soap, (const struct __inf__GetAdminNetAclEntryStatus *)ptr); + break; + case SOAP_TYPE___inf__GetAdminAclEntryStatus: + soap_serialize___inf__GetAdminAclEntryStatus(soap, (const struct __inf__GetAdminAclEntryStatus *)ptr); + break; + case SOAP_TYPE___inf__GetConfigServerInfo: + soap_serialize___inf__GetConfigServerInfo(soap, (const struct __inf__GetConfigServerInfo *)ptr); + break; + case SOAP_TYPE___inf__GetHostName: + soap_serialize___inf__GetHostName(soap, (const struct __inf__GetHostName *)ptr); + break; + case SOAP_TYPE___inf__GetVlanParameters: + soap_serialize___inf__GetVlanParameters(soap, (const struct __inf__GetVlanParameters *)ptr); + break; + case SOAP_TYPE___inf__GetProvisioningState: + soap_serialize___inf__GetProvisioningState(soap, (const struct __inf__GetProvisioningState *)ptr); + break; + case SOAP_TYPE___inf__GetProvisioningMode: + soap_serialize___inf__GetProvisioningMode(soap, (const struct __inf__GetProvisioningMode *)ptr); + break; + case SOAP_TYPE___inf__GetCodeVersions: + soap_serialize___inf__GetCodeVersions(soap, (const struct __inf__GetCodeVersions *)ptr); + break; + case SOAP_TYPE___inf__GetCoreVersion: + soap_serialize___inf__GetCoreVersion(soap, (const struct __inf__GetCoreVersion *)ptr); + break; + case SOAP_TYPE___idr__GetIderSessionLog: + soap_serialize___idr__GetIderSessionLog(soap, (const struct __idr__GetIderSessionLog *)ptr); + break; + case SOAP_TYPE___idr__GetRedirectionListenerState: + soap_serialize___idr__GetRedirectionListenerState(soap, (const struct __idr__GetRedirectionListenerState *)ptr); + break; + case SOAP_TYPE___idr__SetRedirectionListenerState: + soap_serialize___idr__SetRedirectionListenerState(soap, (const struct __idr__SetRedirectionListenerState *)ptr); + break; + case SOAP_TYPE___hwa__GetAssetData: + soap_serialize___hwa__GetAssetData(soap, (const struct __hwa__GetAssetData *)ptr); + break; + case SOAP_TYPE___hwa__EnumerateAssetTypes: + soap_serialize___hwa__EnumerateAssetTypes(soap, (const struct __hwa__EnumerateAssetTypes *)ptr); + break; + case SOAP_TYPE___emi__GetGeneralAlertSubscription: + soap_serialize___emi__GetGeneralAlertSubscription(soap, (const struct __emi__GetGeneralAlertSubscription *)ptr); + break; + case SOAP_TYPE___emi__EnumerateGeneralAlertSubscriptions: + soap_serialize___emi__EnumerateGeneralAlertSubscriptions(soap, (const struct __emi__EnumerateGeneralAlertSubscriptions *)ptr); + break; + case SOAP_TYPE___emi__SubscribeForGeneralAlert: + soap_serialize___emi__SubscribeForGeneralAlert(soap, (const struct __emi__SubscribeForGeneralAlert *)ptr); + break; + case SOAP_TYPE___emi__GetSensorAttributes: + soap_serialize___emi__GetSensorAttributes(soap, (const struct __emi__GetSensorAttributes *)ptr); + break; + case SOAP_TYPE___emi__EnumerateSensors: + soap_serialize___emi__EnumerateSensors(soap, (const struct __emi__EnumerateSensors *)ptr); + break; + case SOAP_TYPE___emi__GetEventLogTimestampClock: + soap_serialize___emi__GetEventLogTimestampClock(soap, (const struct __emi__GetEventLogTimestampClock *)ptr); + break; + case SOAP_TYPE___emi__SetEventLogTimestampClock: + soap_serialize___emi__SetEventLogTimestampClock(soap, (const struct __emi__SetEventLogTimestampClock *)ptr); + break; + case SOAP_TYPE___emi__FreezeEventLog: + soap_serialize___emi__FreezeEventLog(soap, (const struct __emi__FreezeEventLog *)ptr); + break; + case SOAP_TYPE___emi__ClearEventLog: + soap_serialize___emi__ClearEventLog(soap, (const struct __emi__ClearEventLog *)ptr); + break; + case SOAP_TYPE___emi__ReadEventLogRecords: + soap_serialize___emi__ReadEventLogRecords(soap, (const struct __emi__ReadEventLogRecords *)ptr); + break; + case SOAP_TYPE___emi__GetEventLogStatus: + soap_serialize___emi__GetEventLogStatus(soap, (const struct __emi__GetEventLogStatus *)ptr); + break; + case SOAP_TYPE___emi__RemoveEventFilter: + soap_serialize___emi__RemoveEventFilter(soap, (const struct __emi__RemoveEventFilter *)ptr); + break; + case SOAP_TYPE___emi__UpdateEventFilter: + soap_serialize___emi__UpdateEventFilter(soap, (const struct __emi__UpdateEventFilter *)ptr); + break; + case SOAP_TYPE___emi__GetEventFilter: + soap_serialize___emi__GetEventFilter(soap, (const struct __emi__GetEventFilter *)ptr); + break; + case SOAP_TYPE___emi__CancelAlertSubscription: + soap_serialize___emi__CancelAlertSubscription(soap, (const struct __emi__CancelAlertSubscription *)ptr); + break; + case SOAP_TYPE___emi__EnumerateAlertPolicies: + soap_serialize___emi__EnumerateAlertPolicies(soap, (const struct __emi__EnumerateAlertPolicies *)ptr); + break; + case SOAP_TYPE___emi__EnumerateAlertSubscriptions: + soap_serialize___emi__EnumerateAlertSubscriptions(soap, (const struct __emi__EnumerateAlertSubscriptions *)ptr); + break; + case SOAP_TYPE___emi__SubscribeForAlert: + soap_serialize___emi__SubscribeForAlert(soap, (const struct __emi__SubscribeForAlert *)ptr); + break; + case SOAP_TYPE___emi__AddEventFilter: + soap_serialize___emi__AddEventFilter(soap, (const struct __emi__AddEventFilter *)ptr); + break; + case SOAP_TYPE___emi__GetAlertCommunityString: + soap_serialize___emi__GetAlertCommunityString(soap, (const struct __emi__GetAlertCommunityString *)ptr); + break; + case SOAP_TYPE___emi__SetAlertCommunityString: + soap_serialize___emi__SetAlertCommunityString(soap, (const struct __emi__SetAlertCommunityString *)ptr); + break; + case SOAP_TYPE___emi__GetAlertSubscription: + soap_serialize___emi__GetAlertSubscription(soap, (const struct __emi__GetAlertSubscription *)ptr); + break; + case SOAP_TYPE___emi__EnumerateEventFilters: + soap_serialize___emi__EnumerateEventFilters(soap, (const struct __emi__EnumerateEventFilters *)ptr); + break; + case SOAP_TYPE___cb__GetHcbState: + soap_serialize___cb__GetHcbState(soap, (const struct __cb__GetHcbState *)ptr); + break; + case SOAP_TYPE___cb__ClearHcbState: + soap_serialize___cb__ClearHcbState(soap, (const struct __cb__ClearHcbState *)ptr); + break; + case SOAP_TYPE___cb__GetHcbOptions: + soap_serialize___cb__GetHcbOptions(soap, (const struct __cb__GetHcbOptions *)ptr); + break; + case SOAP_TYPE___cb__SetHcbOptions: + soap_serialize___cb__SetHcbOptions(soap, (const struct __cb__SetHcbOptions *)ptr); + break; + case SOAP_TYPE___cb__CbQueryCapabilities: + soap_serialize___cb__CbQueryCapabilities(soap, (const struct __cb__CbQueryCapabilities *)ptr); + break; + case SOAP_TYPE___cb__CbFilterEnumerate: + soap_serialize___cb__CbFilterEnumerate(soap, (const struct __cb__CbFilterEnumerate *)ptr); + break; + case SOAP_TYPE___cb__CbFilterDelete: + soap_serialize___cb__CbFilterDelete(soap, (const struct __cb__CbFilterDelete *)ptr); + break; + case SOAP_TYPE___cb__CbFilterGet: + soap_serialize___cb__CbFilterGet(soap, (const struct __cb__CbFilterGet *)ptr); + break; + case SOAP_TYPE___cb__CbFilterCreate: + soap_serialize___cb__CbFilterCreate(soap, (const struct __cb__CbFilterCreate *)ptr); + break; + case SOAP_TYPE___cb__CbPolicyGetActiveStatistics: + soap_serialize___cb__CbPolicyGetActiveStatistics(soap, (const struct __cb__CbPolicyGetActiveStatistics *)ptr); + break; + case SOAP_TYPE___cb__CbPolicyGetEnabled: + soap_serialize___cb__CbPolicyGetEnabled(soap, (const struct __cb__CbPolicyGetEnabled *)ptr); + break; + case SOAP_TYPE___cb__CbPolicyDisable: + soap_serialize___cb__CbPolicyDisable(soap, (const struct __cb__CbPolicyDisable *)ptr); + break; + case SOAP_TYPE___cb__CbPolicyEnable: + soap_serialize___cb__CbPolicyEnable(soap, (const struct __cb__CbPolicyEnable *)ptr); + break; + case SOAP_TYPE___cb__CbPolicyEnumerate: + soap_serialize___cb__CbPolicyEnumerate(soap, (const struct __cb__CbPolicyEnumerate *)ptr); + break; + case SOAP_TYPE___cb__CbPolicyDelete: + soap_serialize___cb__CbPolicyDelete(soap, (const struct __cb__CbPolicyDelete *)ptr); + break; + case SOAP_TYPE___cb__CbPolicyGet: + soap_serialize___cb__CbPolicyGet(soap, (const struct __cb__CbPolicyGet *)ptr); + break; + case SOAP_TYPE___cb__CbPolicyCreate: + soap_serialize___cb__CbPolicyCreate(soap, (const struct __cb__CbPolicyCreate *)ptr); + break; + case SOAP_TYPE___apr__ConsoleWatchdogQueryCapabilities: + soap_serialize___apr__ConsoleWatchdogQueryCapabilities(soap, (const struct __apr__ConsoleWatchdogQueryCapabilities *)ptr); + break; + case SOAP_TYPE___apr__ConsoleWatchdogGetCbPolicy: + soap_serialize___apr__ConsoleWatchdogGetCbPolicy(soap, (const struct __apr__ConsoleWatchdogGetCbPolicy *)ptr); + break; + case SOAP_TYPE___apr__ConsoleWatchdogSetCbPolicy: + soap_serialize___apr__ConsoleWatchdogSetCbPolicy(soap, (const struct __apr__ConsoleWatchdogSetCbPolicy *)ptr); + break; + case SOAP_TYPE___apr__ConsoleWatchdogGetActions: + soap_serialize___apr__ConsoleWatchdogGetActions(soap, (const struct __apr__ConsoleWatchdogGetActions *)ptr); + break; + case SOAP_TYPE___apr__ConsoleWatchdogSetActions: + soap_serialize___apr__ConsoleWatchdogSetActions(soap, (const struct __apr__ConsoleWatchdogSetActions *)ptr); + break; + case SOAP_TYPE___apr__ConsoleWatchdogEnumerate: + soap_serialize___apr__ConsoleWatchdogEnumerate(soap, (const struct __apr__ConsoleWatchdogEnumerate *)ptr); + break; + case SOAP_TYPE___apr__ConsoleWatchdogDelete: + soap_serialize___apr__ConsoleWatchdogDelete(soap, (const struct __apr__ConsoleWatchdogDelete *)ptr); + break; + case SOAP_TYPE___apr__ConsoleWatchdogCreate: + soap_serialize___apr__ConsoleWatchdogCreate(soap, (const struct __apr__ConsoleWatchdogCreate *)ptr); + break; + case SOAP_TYPE___apl__AgentWatchdogRegister: + soap_serialize___apl__AgentWatchdogRegister(soap, (const struct __apl__AgentWatchdogRegister *)ptr); + break; + case SOAP_TYPE___apl__AgentWatchdogHeartbeat: + soap_serialize___apl__AgentWatchdogHeartbeat(soap, (const struct __apl__AgentWatchdogHeartbeat *)ptr); + break; + case SOAP_TYPE___apl__AgentWatchdogShutdown: + soap_serialize___apl__AgentWatchdogShutdown(soap, (const struct __apl__AgentWatchdogShutdown *)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsResponse: + soap_serialize_PointerTo_wcxs__GetWirelessSettingsResponse(soap, (_wcxs__GetWirelessSettingsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsRequest: + soap_serialize_PointerTo_wcxs__GetWirelessSettingsRequest(soap, (_wcxs__GetWirelessSettingsRequest *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesResponse: + soap_serialize_PointerTo_wcxs__GetWirelessCapabilitiesResponse(soap, (_wcxs__GetWirelessCapabilitiesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesRequest: + soap_serialize_PointerTo_wcxs__GetWirelessCapabilitiesRequest(soap, (_wcxs__GetWirelessCapabilitiesRequest *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesResponse: + soap_serialize_PointerTo_wcxs__EnumerateWirelessProfilesResponse(soap, (_wcxs__EnumerateWirelessProfilesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesRequest: + soap_serialize_PointerTo_wcxs__EnumerateWirelessProfilesRequest(soap, (_wcxs__EnumerateWirelessProfilesRequest *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileResponse: + soap_serialize_PointerTo_wcxs__UpdateWirelessProfileResponse(soap, (_wcxs__UpdateWirelessProfileResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileRequest: + soap_serialize_PointerTo_wcxs__UpdateWirelessProfileRequest(soap, (_wcxs__UpdateWirelessProfileRequest *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileResponse: + soap_serialize_PointerTo_wcxs__RemoveWirelessProfileResponse(soap, (_wcxs__RemoveWirelessProfileResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileRequest: + soap_serialize_PointerTo_wcxs__RemoveWirelessProfileRequest(soap, (_wcxs__RemoveWirelessProfileRequest *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileResponse: + soap_serialize_PointerTo_wcxs__GetWirelessProfileResponse(soap, (_wcxs__GetWirelessProfileResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileRequest: + soap_serialize_PointerTo_wcxs__GetWirelessProfileRequest(soap, (_wcxs__GetWirelessProfileRequest *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileResponse: + soap_serialize_PointerTo_wcxs__AddWirelessProfileResponse(soap, (_wcxs__AddWirelessProfileResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileRequest: + soap_serialize_PointerTo_wcxs__AddWirelessProfileRequest(soap, (_wcxs__AddWirelessProfileRequest *const*)ptr); + break; + case SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynchResponse: + soap_serialize_PointerTo_tim__SetHighAccuracyTimeSynchResponse(soap, (_tim__SetHighAccuracyTimeSynchResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynch: + soap_serialize_PointerTo_tim__SetHighAccuracyTimeSynch(soap, (_tim__SetHighAccuracyTimeSynch *const*)ptr); + break; + case SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynchResponse: + soap_serialize_PointerTo_tim__GetLowAccuracyTimeSynchResponse(soap, (_tim__GetLowAccuracyTimeSynchResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynch: + soap_serialize_PointerTo_tim__GetLowAccuracyTimeSynch(soap, (_tim__GetLowAccuracyTimeSynch *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntryResponse: + soap_serialize_PointerTo_stra__RemoveStorageFpaclEntryResponse(soap, (_stra__RemoveStorageFpaclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntry: + soap_serialize_PointerTo_stra__RemoveStorageFpaclEntry(soap, (_stra__RemoveStorageFpaclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntryResponse: + soap_serialize_PointerTo_stra__UpdateStorageFpaclEntryResponse(soap, (_stra__UpdateStorageFpaclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntry: + soap_serialize_PointerTo_stra__UpdateStorageFpaclEntry(soap, (_stra__UpdateStorageFpaclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__GetStorageAllocEntryResponse: + soap_serialize_PointerTo_stra__GetStorageAllocEntryResponse(soap, (_stra__GetStorageAllocEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__GetStorageAllocEntry: + soap_serialize_PointerTo_stra__GetStorageAllocEntry(soap, (_stra__GetStorageAllocEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntriesResponse: + soap_serialize_PointerTo_stra__EnumerateStorageAllocEntriesResponse(soap, (_stra__EnumerateStorageAllocEntriesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntries: + soap_serialize_PointerTo_stra__EnumerateStorageAllocEntries(soap, (_stra__EnumerateStorageAllocEntries *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntryResponse: + soap_serialize_PointerTo_stra__AddStorageFpaclEntryResponse(soap, (_stra__AddStorageFpaclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntry: + soap_serialize_PointerTo_stra__AddStorageFpaclEntry(soap, (_stra__AddStorageFpaclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntryResponse: + soap_serialize_PointerTo_stra__RemoveStorageEaclEntryResponse(soap, (_stra__RemoveStorageEaclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntry: + soap_serialize_PointerTo_stra__RemoveStorageEaclEntry(soap, (_stra__RemoveStorageEaclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__GetStorageEaclEntryResponse: + soap_serialize_PointerTo_stra__GetStorageEaclEntryResponse(soap, (_stra__GetStorageEaclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__GetStorageEaclEntry: + soap_serialize_PointerTo_stra__GetStorageEaclEntry(soap, (_stra__GetStorageEaclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntriesResponse: + soap_serialize_PointerTo_stra__EnumerateStorageEaclEntriesResponse(soap, (_stra__EnumerateStorageEaclEntriesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntries: + soap_serialize_PointerTo_stra__EnumerateStorageEaclEntries(soap, (_stra__EnumerateStorageEaclEntries *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AddStorageEaclEntryResponse: + soap_serialize_PointerTo_stra__AddStorageEaclEntryResponse(soap, (_stra__AddStorageEaclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AddStorageEaclEntry: + soap_serialize_PointerTo_stra__AddStorageEaclEntry(soap, (_stra__AddStorageEaclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AdminRemoveApplicationResponse: + soap_serialize_PointerTo_stra__AdminRemoveApplicationResponse(soap, (_stra__AdminRemoveApplicationResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AdminRemoveApplication: + soap_serialize_PointerTo_stra__AdminRemoveApplication(soap, (_stra__AdminRemoveApplication *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributesResponse: + soap_serialize_PointerTo_stra__AdminGetApplicationAttributesResponse(soap, (_stra__AdminGetApplicationAttributesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributes: + soap_serialize_PointerTo_stra__AdminGetApplicationAttributes(soap, (_stra__AdminGetApplicationAttributes *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplicationsResponse: + soap_serialize_PointerTo_stra__AdminGetRegisteredApplicationsResponse(soap, (_stra__AdminGetRegisteredApplicationsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplications: + soap_serialize_PointerTo_stra__AdminGetRegisteredApplications(soap, (_stra__AdminGetRegisteredApplications *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributesResponse: + soap_serialize_PointerTo_stra__SetGlobalStorageAttributesResponse(soap, (_stra__SetGlobalStorageAttributesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributes: + soap_serialize_PointerTo_stra__SetGlobalStorageAttributes(soap, (_stra__SetGlobalStorageAttributes *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributesResponse: + soap_serialize_PointerTo_stra__GetGlobalStorageAttributesResponse(soap, (_stra__GetGlobalStorageAttributesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributes: + soap_serialize_PointerTo_stra__GetGlobalStorageAttributes(soap, (_stra__GetGlobalStorageAttributes *const*)ptr); + break; + case SOAP_TYPE_PointerTo_str__ExecuteStorageOperationResponse: + soap_serialize_PointerTo_str__ExecuteStorageOperationResponse(soap, (_str__ExecuteStorageOperationResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_str__ExecuteStorageOperation: + soap_serialize_PointerTo_str__ExecuteStorageOperation(soap, (_str__ExecuteStorageOperation *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetAclEnabledStateResponse: + soap_serialize_PointerTo_sai__GetAclEnabledStateResponse(soap, (_sai__GetAclEnabledStateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetAclEnabledState: + soap_serialize_PointerTo_sai__GetAclEnabledState(soap, (_sai__GetAclEnabledState *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetAclEnabledStateResponse: + soap_serialize_PointerTo_sai__SetAclEnabledStateResponse(soap, (_sai__SetAclEnabledStateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetAclEnabledState: + soap_serialize_PointerTo_sai__SetAclEnabledState(soap, (_sai__SetAclEnabledState *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDNResponse: + soap_serialize_PointerTo_sai__SetConfigurationServerFQDNResponse(soap, (_sai__SetConfigurationServerFQDNResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDN: + soap_serialize_PointerTo_sai__SetConfigurationServerFQDN(soap, (_sai__SetConfigurationServerFQDN *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDNResponse: + soap_serialize_PointerTo_sai__GetConfigurationServerFQDNResponse(soap, (_sai__GetConfigurationServerFQDNResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDN: + soap_serialize_PointerTo_sai__GetConfigurationServerFQDN(soap, (_sai__GetConfigurationServerFQDN *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnableVpnRoutingResponse: + soap_serialize_PointerTo_sai__EnableVpnRoutingResponse(soap, (_sai__EnableVpnRoutingResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnableVpnRouting: + soap_serialize_PointerTo_sai__EnableVpnRouting(soap, (_sai__EnableVpnRouting *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTLSCredentialsResponse: + soap_serialize_PointerTo_sai__GetTLSCredentialsResponse(soap, (_sai__GetTLSCredentialsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTLSCredentials: + soap_serialize_PointerTo_sai__GetTLSCredentials(soap, (_sai__GetTLSCredentials *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTLSCredentialsResponse: + soap_serialize_PointerTo_sai__SetTLSCredentialsResponse(soap, (_sai__SetTLSCredentialsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTLSCredentials: + soap_serialize_PointerTo_sai__SetTLSCredentials(soap, (_sai__SetTLSCredentials *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificateResponse: + soap_serialize_PointerTo_sai__CertStoreUpdateCertificateResponse(soap, (_sai__CertStoreUpdateCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificate: + soap_serialize_PointerTo_sai__CertStoreUpdateCertificate(soap, (_sai__CertStoreUpdateCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10RequestResponse: + soap_serialize_PointerTo_sai__CertStoreGetPKCS10RequestResponse(soap, (_sai__CertStoreGetPKCS10RequestResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10Request: + soap_serialize_PointerTo_sai__CertStoreGetPKCS10Request(soap, (_sai__CertStoreGetPKCS10Request *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificateResponse: + soap_serialize_PointerTo_sai__CertStoreRemoveCertificateResponse(soap, (_sai__CertStoreRemoveCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificate: + soap_serialize_PointerTo_sai__CertStoreRemoveCertificate(soap, (_sai__CertStoreRemoveCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificatesResponse: + soap_serialize_PointerTo_sai__CertStoreEnumerateCertificatesResponse(soap, (_sai__CertStoreEnumerateCertificatesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificates: + soap_serialize_PointerTo_sai__CertStoreEnumerateCertificates(soap, (_sai__CertStoreEnumerateCertificates *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreGetCertificateResponse: + soap_serialize_PointerTo_sai__CertStoreGetCertificateResponse(soap, (_sai__CertStoreGetCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreGetCertificate: + soap_serialize_PointerTo_sai__CertStoreGetCertificate(soap, (_sai__CertStoreGetCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreAddCertificateResponse: + soap_serialize_PointerTo_sai__CertStoreAddCertificateResponse(soap, (_sai__CertStoreAddCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreAddCertificate: + soap_serialize_PointerTo_sai__CertStoreAddCertificate(soap, (_sai__CertStoreAddCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveKeyResponse: + soap_serialize_PointerTo_sai__CertStoreRemoveKeyResponse(soap, (_sai__CertStoreRemoveKeyResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreRemoveKey: + soap_serialize_PointerTo_sai__CertStoreRemoveKey(soap, (_sai__CertStoreRemoveKey *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreGetKeyResponse: + soap_serialize_PointerTo_sai__CertStoreGetKeyResponse(soap, (_sai__CertStoreGetKeyResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreGetKey: + soap_serialize_PointerTo_sai__CertStoreGetKey(soap, (_sai__CertStoreGetKey *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeysResponse: + soap_serialize_PointerTo_sai__CertStoreEnumerateKeysResponse(soap, (_sai__CertStoreEnumerateKeysResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeys: + soap_serialize_PointerTo_sai__CertStoreEnumerateKeys(soap, (_sai__CertStoreEnumerateKeys *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreAddKeyResponse: + soap_serialize_PointerTo_sai__CertStoreAddKeyResponse(soap, (_sai__CertStoreAddKeyResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CertStoreAddKey: + soap_serialize_PointerTo_sai__CertStoreAddKey(soap, (_sai__CertStoreAddKey *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicyResponse: + soap_serialize_PointerTo_sai__GetGlobalPowerPolicyResponse(soap, (_sai__GetGlobalPowerPolicyResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicy: + soap_serialize_PointerTo_sai__GetGlobalPowerPolicy(soap, (_sai__GetGlobalPowerPolicy *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicyResponse: + soap_serialize_PointerTo_sai__SetGlobalPowerPolicyResponse(soap, (_sai__SetGlobalPowerPolicyResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicy: + soap_serialize_PointerTo_sai__SetGlobalPowerPolicy(soap, (_sai__SetGlobalPowerPolicy *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetActivePowerPackageResponse: + soap_serialize_PointerTo_sai__SetActivePowerPackageResponse(soap, (_sai__SetActivePowerPackageResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetActivePowerPackage: + soap_serialize_PointerTo_sai__SetActivePowerPackage(soap, (_sai__SetActivePowerPackage *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetActivePowerPackageResponse: + soap_serialize_PointerTo_sai__GetActivePowerPackageResponse(soap, (_sai__GetActivePowerPackageResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetActivePowerPackage: + soap_serialize_PointerTo_sai__GetActivePowerPackage(soap, (_sai__GetActivePowerPackage *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetPowerPackageResponse: + soap_serialize_PointerTo_sai__GetPowerPackageResponse(soap, (_sai__GetPowerPackageResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetPowerPackage: + soap_serialize_PointerTo_sai__GetPowerPackage(soap, (_sai__GetPowerPackage *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnumeratePowerPackagesResponse: + soap_serialize_PointerTo_sai__EnumeratePowerPackagesResponse(soap, (_sai__EnumeratePowerPackagesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnumeratePowerPackages: + soap_serialize_PointerTo_sai__EnumeratePowerPackages(soap, (_sai__EnumeratePowerPackages *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetEnvironmentDetectionResponse: + soap_serialize_PointerTo_sai__GetEnvironmentDetectionResponse(soap, (_sai__GetEnvironmentDetectionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetEnvironmentDetection: + soap_serialize_PointerTo_sai__GetEnvironmentDetection(soap, (_sai__GetEnvironmentDetection *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetEnvironmentDetectionResponse: + soap_serialize_PointerTo_sai__SetEnvironmentDetectionResponse(soap, (_sai__SetEnvironmentDetectionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetEnvironmentDetection: + soap_serialize_PointerTo_sai__SetEnvironmentDetection(soap, (_sai__SetEnvironmentDetection *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetRealmAuthOptionsResponse: + soap_serialize_PointerTo_sai__SetRealmAuthOptionsResponse(soap, (_sai__SetRealmAuthOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetRealmAuthOptions: + soap_serialize_PointerTo_sai__SetRealmAuthOptions(soap, (_sai__SetRealmAuthOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetRealmAuthOptionsResponse: + soap_serialize_PointerTo_sai__GetRealmAuthOptionsResponse(soap, (_sai__GetRealmAuthOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetRealmAuthOptions: + soap_serialize_PointerTo_sai__GetRealmAuthOptions(soap, (_sai__GetRealmAuthOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriodResponse: + soap_serialize_PointerTo_sai__ExtendProvisioningPeriodResponse(soap, (_sai__ExtendProvisioningPeriodResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriod: + soap_serialize_PointerTo_sai__ExtendProvisioningPeriod(soap, (_sai__ExtendProvisioningPeriod *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetProvisioningPIDResponse: + soap_serialize_PointerTo_sai__GetProvisioningPIDResponse(soap, (_sai__GetProvisioningPIDResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetProvisioningPID: + soap_serialize_PointerTo_sai__GetProvisioningPID(soap, (_sai__GetProvisioningPID *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecordResponse: + soap_serialize_PointerTo_sai__GetProvisioningAuditRecordResponse(soap, (_sai__GetProvisioningAuditRecordResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecord: + soap_serialize_PointerTo_sai__GetProvisioningAuditRecord(soap, (_sai__GetProvisioningAuditRecord *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationModeResponse: + soap_serialize_PointerTo_sai__SetZeroTouchConfigurationModeResponse(soap, (_sai__SetZeroTouchConfigurationModeResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationMode: + soap_serialize_PointerTo_sai__SetZeroTouchConfigurationMode(soap, (_sai__SetZeroTouchConfigurationMode *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationModeResponse: + soap_serialize_PointerTo_sai__GetZeroTouchConfigurationModeResponse(soap, (_sai__GetZeroTouchConfigurationModeResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationMode: + soap_serialize_PointerTo_sai__GetZeroTouchConfigurationMode(soap, (_sai__GetZeroTouchConfigurationMode *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntryResponse: + soap_serialize_PointerTo_sai__EnableCertificateHashEntryResponse(soap, (_sai__EnableCertificateHashEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntry: + soap_serialize_PointerTo_sai__EnableCertificateHashEntry(soap, (_sai__EnableCertificateHashEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntryResponse: + soap_serialize_PointerTo_sai__DeleteCertificateHashEntryResponse(soap, (_sai__DeleteCertificateHashEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntry: + soap_serialize_PointerTo_sai__DeleteCertificateHashEntry(soap, (_sai__DeleteCertificateHashEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__AddCertificateHashEntryResponse: + soap_serialize_PointerTo_sai__AddCertificateHashEntryResponse(soap, (_sai__AddCertificateHashEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__AddCertificateHashEntry: + soap_serialize_PointerTo_sai__AddCertificateHashEntry(soap, (_sai__AddCertificateHashEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetCertificateHashEntryResponse: + soap_serialize_PointerTo_sai__GetCertificateHashEntryResponse(soap, (_sai__GetCertificateHashEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetCertificateHashEntry: + soap_serialize_PointerTo_sai__GetCertificateHashEntry(soap, (_sai__GetCertificateHashEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntriesResponse: + soap_serialize_PointerTo_sai__EnumerateCertificateHashEntriesResponse(soap, (_sai__EnumerateCertificateHashEntriesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntries: + soap_serialize_PointerTo_sai__EnumerateCertificateHashEntries(soap, (_sai__EnumerateCertificateHashEntries *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTPResponse: + soap_serialize_PointerTo_sai__GetProvisioningServerOTPResponse(soap, (_sai__GetProvisioningServerOTPResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTP: + soap_serialize_PointerTo_sai__GetProvisioningServerOTP(soap, (_sai__GetProvisioningServerOTP *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTPResponse: + soap_serialize_PointerTo_sai__SetProvisioningServerOTPResponse(soap, (_sai__SetProvisioningServerOTPResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTP: + soap_serialize_PointerTo_sai__SetProvisioningServerOTP(soap, (_sai__SetProvisioningServerOTP *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetMEBxPasswordResponse: + soap_serialize_PointerTo_sai__SetMEBxPasswordResponse(soap, (_sai__SetMEBxPasswordResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetMEBxPassword: + soap_serialize_PointerTo_sai__SetMEBxPassword(soap, (_sai__SetMEBxPassword *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__PartialUnprovisionResponse: + soap_serialize_PointerTo_sai__PartialUnprovisionResponse(soap, (_sai__PartialUnprovisionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__PartialUnprovision: + soap_serialize_PointerTo_sai__PartialUnprovision(soap, (_sai__PartialUnprovision *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTLSPSKResponse: + soap_serialize_PointerTo_sai__SetTLSPSKResponse(soap, (_sai__SetTLSPSKResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTLSPSK: + soap_serialize_PointerTo_sai__SetTLSPSK(soap, (_sai__SetTLSPSK *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetPowerSavingOptionsResponse: + soap_serialize_PointerTo_sai__GetPowerSavingOptionsResponse(soap, (_sai__GetPowerSavingOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetPowerSavingOptions: + soap_serialize_PointerTo_sai__GetPowerSavingOptions(soap, (_sai__GetPowerSavingOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetPowerSavingOptionsResponse: + soap_serialize_PointerTo_sai__SetPowerSavingOptionsResponse(soap, (_sai__SetPowerSavingOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetPowerSavingOptions: + soap_serialize_PointerTo_sai__SetPowerSavingOptions(soap, (_sai__SetPowerSavingOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetPkiCapabilitiesResponse: + soap_serialize_PointerTo_sai__GetPkiCapabilitiesResponse(soap, (_sai__GetPkiCapabilitiesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetPkiCapabilities: + soap_serialize_PointerTo_sai__GetPkiCapabilities(soap, (_sai__GetPkiCapabilities *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetServerCertificateReqResponse: + soap_serialize_PointerTo_sai__GetServerCertificateReqResponse(soap, (_sai__GetServerCertificateReqResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetServerCertificateReq: + soap_serialize_PointerTo_sai__GetServerCertificateReq(soap, (_sai__GetServerCertificateReq *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetCRLResponse: + soap_serialize_PointerTo_sai__GetCRLResponse(soap, (_sai__GetCRLResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetCRL: + soap_serialize_PointerTo_sai__GetCRL(soap, (_sai__GetCRL *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetCRLResponse: + soap_serialize_PointerTo_sai__SetCRLResponse(soap, (_sai__SetCRLResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetCRL: + soap_serialize_PointerTo_sai__SetCRL(soap, (_sai__SetCRL *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCNResponse: + soap_serialize_PointerTo_sai__GetTrustedFqdnCNResponse(soap, (_sai__GetTrustedFqdnCNResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCN: + soap_serialize_PointerTo_sai__GetTrustedFqdnCN(soap, (_sai__GetTrustedFqdnCN *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCNResponse: + soap_serialize_PointerTo_sai__SetTrustedFqdnCNResponse(soap, (_sai__SetTrustedFqdnCNResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCN: + soap_serialize_PointerTo_sai__SetTrustedFqdnCN(soap, (_sai__SetTrustedFqdnCN *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificatesResponse: + soap_serialize_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(soap, (_sai__EnumerateTrustedRootCertificatesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificates: + soap_serialize_PointerTo_sai__EnumerateTrustedRootCertificates(soap, (_sai__EnumerateTrustedRootCertificates *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificateResponse: + soap_serialize_PointerTo_sai__DeleteTrustedRootCertificateResponse(soap, (_sai__DeleteTrustedRootCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificate: + soap_serialize_PointerTo_sai__DeleteTrustedRootCertificate(soap, (_sai__DeleteTrustedRootCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificateResponse: + soap_serialize_PointerTo_sai__GetTrustedRootCertificateResponse(soap, (_sai__GetTrustedRootCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificate: + soap_serialize_PointerTo_sai__GetTrustedRootCertificate(soap, (_sai__GetTrustedRootCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificateResponse: + soap_serialize_PointerTo_sai__AddTrustedRootCertificateResponse(soap, (_sai__AddTrustedRootCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificate: + soap_serialize_PointerTo_sai__AddTrustedRootCertificate(soap, (_sai__AddTrustedRootCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTlsOptionsResponse: + soap_serialize_PointerTo_sai__GetTlsOptionsResponse(soap, (_sai__GetTlsOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTlsOptions: + soap_serialize_PointerTo_sai__GetTlsOptions(soap, (_sai__GetTlsOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTlsOptionsResponse: + soap_serialize_PointerTo_sai__SetTlsOptionsResponse(soap, (_sai__SetTlsOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTlsOptions: + soap_serialize_PointerTo_sai__SetTlsOptions(soap, (_sai__SetTlsOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetEnabledInterfacesResponse: + soap_serialize_PointerTo_sai__GetEnabledInterfacesResponse(soap, (_sai__GetEnabledInterfacesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetEnabledInterfaces: + soap_serialize_PointerTo_sai__GetEnabledInterfaces(soap, (_sai__GetEnabledInterfaces *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetEnabledInterfacesResponse: + soap_serialize_PointerTo_sai__SetEnabledInterfacesResponse(soap, (_sai__SetEnabledInterfacesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetEnabledInterfaces: + soap_serialize_PointerTo_sai__SetEnabledInterfaces(soap, (_sai__SetEnabledInterfaces *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetKerberosOptionsResponse: + soap_serialize_PointerTo_sai__GetKerberosOptionsResponse(soap, (_sai__GetKerberosOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetKerberosOptions: + soap_serialize_PointerTo_sai__GetKerberosOptions(soap, (_sai__GetKerberosOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetKerberosOptionsResponse: + soap_serialize_PointerTo_sai__SetKerberosOptionsResponse(soap, (_sai__SetKerberosOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetKerberosOptions: + soap_serialize_PointerTo_sai__SetKerberosOptions(soap, (_sai__SetKerberosOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetDigestRealmResponse: + soap_serialize_PointerTo_sai__GetDigestRealmResponse(soap, (_sai__GetDigestRealmResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetDigestRealm: + soap_serialize_PointerTo_sai__GetDigestRealm(soap, (_sai__GetDigestRealm *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntryExResponse: + soap_serialize_PointerTo_sai__SetAdminAclEntryExResponse(soap, (_sai__SetAdminAclEntryExResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntryEx: + soap_serialize_PointerTo_sai__SetAdminAclEntryEx(soap, (_sai__SetAdminAclEntryEx *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryExResponse: + soap_serialize_PointerTo_sai__UpdateUserAclEntryExResponse(soap, (_sai__UpdateUserAclEntryExResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryEx: + soap_serialize_PointerTo_sai__UpdateUserAclEntryEx(soap, (_sai__UpdateUserAclEntryEx *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetUserAclEntryExResponse: + soap_serialize_PointerTo_sai__GetUserAclEntryExResponse(soap, (_sai__GetUserAclEntryExResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetUserAclEntryEx: + soap_serialize_PointerTo_sai__GetUserAclEntryEx(soap, (_sai__GetUserAclEntryEx *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__AddUserAclEntryExResponse: + soap_serialize_PointerTo_sai__AddUserAclEntryExResponse(soap, (_sai__AddUserAclEntryExResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__AddUserAclEntryEx: + soap_serialize_PointerTo_sai__AddUserAclEntryEx(soap, (_sai__AddUserAclEntryEx *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetCoreVersionResponse: + soap_serialize_PointerTo_sai__GetCoreVersionResponse(soap, (_sai__GetCoreVersionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetCoreVersion: + soap_serialize_PointerTo_sai__GetCoreVersion(soap, (_sai__GetCoreVersion *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CommitChangesResponse: + soap_serialize_PointerTo_sai__CommitChangesResponse(soap, (_sai__CommitChangesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__CommitChanges: + soap_serialize_PointerTo_sai__CommitChanges(soap, (_sai__CommitChanges *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__UnprovisionResponse: + soap_serialize_PointerTo_sai__UnprovisionResponse(soap, (_sai__UnprovisionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__Unprovision: + soap_serialize_PointerTo_sai__Unprovision(soap, (_sai__Unprovision *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetProvisioningModeResponse: + soap_serialize_PointerTo_sai__SetProvisioningModeResponse(soap, (_sai__SetProvisioningModeResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetProvisioningMode: + soap_serialize_PointerTo_sai__SetProvisioningMode(soap, (_sai__SetProvisioningMode *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetProvisioningModeResponse: + soap_serialize_PointerTo_sai__GetProvisioningModeResponse(soap, (_sai__GetProvisioningModeResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetProvisioningMode: + soap_serialize_PointerTo_sai__GetProvisioningMode(soap, (_sai__GetProvisioningMode *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrlResponse: + soap_serialize_PointerTo_sai__UpdateCoreFromUrlResponse(soap, (_sai__UpdateCoreFromUrlResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrl: + soap_serialize_PointerTo_sai__UpdateCoreFromUrl(soap, (_sai__UpdateCoreFromUrl *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTLSCertificateResponse: + soap_serialize_PointerTo_sai__GetTLSCertificateResponse(soap, (_sai__GetTLSCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetTLSCertificate: + soap_serialize_PointerTo_sai__GetTLSCertificate(soap, (_sai__GetTLSCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTLSCertificateResponse: + soap_serialize_PointerTo_sai__SetTLSCertificateResponse(soap, (_sai__SetTLSCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTLSCertificate: + soap_serialize_PointerTo_sai__SetTLSCertificate(soap, (_sai__SetTLSCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificateResponse: + soap_serialize_PointerTo_sai__SetTLSKeyAndCertificateResponse(soap, (_sai__SetTLSKeyAndCertificateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificate: + soap_serialize_PointerTo_sai__SetTLSKeyAndCertificate(soap, (_sai__SetTLSKeyAndCertificate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetRngKeyResponse: + soap_serialize_PointerTo_sai__SetRngKeyResponse(soap, (_sai__SetRngKeyResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetRngKey: + soap_serialize_PointerTo_sai__SetRngKey(soap, (_sai__SetRngKey *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTlsEnabledResponse: + soap_serialize_PointerTo_sai__SetTlsEnabledResponse(soap, (_sai__SetTlsEnabledResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetTlsEnabled: + soap_serialize_PointerTo_sai__SetTlsEnabled(soap, (_sai__SetTlsEnabled *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__RemoveUserAclEntryResponse: + soap_serialize_PointerTo_sai__RemoveUserAclEntryResponse(soap, (_sai__RemoveUserAclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__RemoveUserAclEntry: + soap_serialize_PointerTo_sai__RemoveUserAclEntry(soap, (_sai__RemoveUserAclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryResponse: + soap_serialize_PointerTo_sai__UpdateUserAclEntryResponse(soap, (_sai__UpdateUserAclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__UpdateUserAclEntry: + soap_serialize_PointerTo_sai__UpdateUserAclEntry(soap, (_sai__UpdateUserAclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetUserAclEntryResponse: + soap_serialize_PointerTo_sai__GetUserAclEntryResponse(soap, (_sai__GetUserAclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetUserAclEntry: + soap_serialize_PointerTo_sai__GetUserAclEntry(soap, (_sai__GetUserAclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntriesResponse: + soap_serialize_PointerTo_sai__EnumerateUserAclEntriesResponse(soap, (_sai__EnumerateUserAclEntriesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntries: + soap_serialize_PointerTo_sai__EnumerateUserAclEntries(soap, (_sai__EnumerateUserAclEntries *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__AddUserAclEntryResponse: + soap_serialize_PointerTo_sai__AddUserAclEntryResponse(soap, (_sai__AddUserAclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__AddUserAclEntry: + soap_serialize_PointerTo_sai__AddUserAclEntry(soap, (_sai__AddUserAclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntryResponse: + soap_serialize_PointerTo_sai__SetAdminAclEntryResponse(soap, (_sai__SetAdminAclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__SetAdminAclEntry: + soap_serialize_PointerTo_sai__SetAdminAclEntry(soap, (_sai__SetAdminAclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetAdminAclEntryResponse: + soap_serialize_PointerTo_sai__GetAdminAclEntryResponse(soap, (_sai__GetAdminAclEntryResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__GetAdminAclEntry: + soap_serialize_PointerTo_sai__GetAdminAclEntry(soap, (_sai__GetAdminAclEntry *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtectionResponse: + soap_serialize_PointerTo_sai__ResetFlashWearOutProtectionResponse(soap, (_sai__ResetFlashWearOutProtectionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtection: + soap_serialize_PointerTo_sai__ResetFlashWearOutProtection(soap, (_sai__ResetFlashWearOutProtection *const*)ptr); + break; + case SOAP_TYPE_PointerTo_rci__GetSystemPowerStateResponse: + soap_serialize_PointerTo_rci__GetSystemPowerStateResponse(soap, (_rci__GetSystemPowerStateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_rci__GetSystemPowerState: + soap_serialize_PointerTo_rci__GetSystemPowerState(soap, (_rci__GetSystemPowerState *const*)ptr); + break; + case SOAP_TYPE_PointerTo_rci__RemoteControlResponse: + soap_serialize_PointerTo_rci__RemoteControlResponse(soap, (_rci__RemoteControlResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_rci__RemoteControl: + soap_serialize_PointerTo_rci__RemoteControl(soap, (_rci__RemoteControl *const*)ptr); + break; + case SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilitiesResponse: + soap_serialize_PointerTo_rci__GetRemoteControlCapabilitiesResponse(soap, (_rci__GetRemoteControlCapabilitiesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilities: + soap_serialize_PointerTo_rci__GetRemoteControlCapabilities(soap, (_rci__GetRemoteControlCapabilities *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Get8021XPxeTimeoutResponse: + soap_serialize_PointerTo_net__Get8021XPxeTimeoutResponse(soap, (_net__Get8021XPxeTimeoutResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Get8021XPxeTimeout: + soap_serialize_PointerTo_net__Get8021XPxeTimeout(soap, (_net__Get8021XPxeTimeout *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Set8021XPxeTimeoutResponse: + soap_serialize_PointerTo_net__Set8021XPxeTimeoutResponse(soap, (_net__Set8021XPxeTimeoutResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Set8021XPxeTimeout: + soap_serialize_PointerTo_net__Set8021XPxeTimeout(soap, (_net__Set8021XPxeTimeout *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Get8021XActiveS0Response: + soap_serialize_PointerTo_net__Get8021XActiveS0Response(soap, (_net__Get8021XActiveS0Response *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Get8021XActiveS0: + soap_serialize_PointerTo_net__Get8021XActiveS0(soap, (_net__Get8021XActiveS0 *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Set8021XActiveS0Response: + soap_serialize_PointerTo_net__Set8021XActiveS0Response(soap, (_net__Set8021XActiveS0Response *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Set8021XActiveS0: + soap_serialize_PointerTo_net__Set8021XActiveS0(soap, (_net__Set8021XActiveS0 *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Get8021XWiredProfileResponse: + soap_serialize_PointerTo_net__Get8021XWiredProfileResponse(soap, (_net__Get8021XWiredProfileResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Get8021XWiredProfile: + soap_serialize_PointerTo_net__Get8021XWiredProfile(soap, (_net__Get8021XWiredProfile *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Set8021XWiredProfileResponse: + soap_serialize_PointerTo_net__Set8021XWiredProfileResponse(soap, (_net__Set8021XWiredProfileResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__Set8021XWiredProfile: + soap_serialize_PointerTo_net__Set8021XWiredProfile(soap, (_net__Set8021XWiredProfile *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetInterfaceSettingsResponse: + soap_serialize_PointerTo_net__SetInterfaceSettingsResponse(soap, (_net__SetInterfaceSettingsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetInterfaceSettings: + soap_serialize_PointerTo_net__SetInterfaceSettings(soap, (_net__SetInterfaceSettings *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetInterfaceSettingsResponse: + soap_serialize_PointerTo_net__GetInterfaceSettingsResponse(soap, (_net__GetInterfaceSettingsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetInterfaceSettings: + soap_serialize_PointerTo_net__GetInterfaceSettings(soap, (_net__GetInterfaceSettings *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__EnumerateInterfacesResponse: + soap_serialize_PointerTo_net__EnumerateInterfacesResponse(soap, (_net__EnumerateInterfacesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__EnumerateInterfaces: + soap_serialize_PointerTo_net__EnumerateInterfaces(soap, (_net__EnumerateInterfaces *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetPingResponseResponse: + soap_serialize_PointerTo_net__GetPingResponseResponse(soap, (_net__GetPingResponseResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetPingResponse: + soap_serialize_PointerTo_net__GetPingResponse(soap, (_net__GetPingResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetPingResponseResponse: + soap_serialize_PointerTo_net__SetPingResponseResponse(soap, (_net__SetPingResponseResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetPingResponse: + soap_serialize_PointerTo_net__SetPingResponse(soap, (_net__SetPingResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetVlanParametersResponse: + soap_serialize_PointerTo_net__GetVlanParametersResponse(soap, (_net__GetVlanParametersResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetVlanParameters: + soap_serialize_PointerTo_net__GetVlanParameters(soap, (_net__GetVlanParameters *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetVlanParametersResponse: + soap_serialize_PointerTo_net__SetVlanParametersResponse(soap, (_net__SetVlanParametersResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetVlanParameters: + soap_serialize_PointerTo_net__SetVlanParameters(soap, (_net__SetVlanParameters *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetTcpIpParametersResponse: + soap_serialize_PointerTo_net__GetTcpIpParametersResponse(soap, (_net__GetTcpIpParametersResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetTcpIpParameters: + soap_serialize_PointerTo_net__GetTcpIpParameters(soap, (_net__GetTcpIpParameters *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetTcpIpParametersResponse: + soap_serialize_PointerTo_net__SetTcpIpParametersResponse(soap, (_net__SetTcpIpParametersResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetTcpIpParameters: + soap_serialize_PointerTo_net__SetTcpIpParameters(soap, (_net__SetTcpIpParameters *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetDomainNameResponse: + soap_serialize_PointerTo_net__GetDomainNameResponse(soap, (_net__GetDomainNameResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetDomainName: + soap_serialize_PointerTo_net__GetDomainName(soap, (_net__GetDomainName *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetDomainNameResponse: + soap_serialize_PointerTo_net__SetDomainNameResponse(soap, (_net__SetDomainNameResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetDomainName: + soap_serialize_PointerTo_net__SetDomainName(soap, (_net__SetDomainName *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetHostNameResponse: + soap_serialize_PointerTo_net__GetHostNameResponse(soap, (_net__GetHostNameResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__GetHostName: + soap_serialize_PointerTo_net__GetHostName(soap, (_net__GetHostName *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetHostNameResponse: + soap_serialize_PointerTo_net__SetHostNameResponse(soap, (_net__SetHostNameResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_net__SetHostName: + soap_serialize_PointerTo_net__SetHostName(soap, (_net__SetHostName *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetIderSessionLogResponse: + soap_serialize_PointerTo_inf__GetIderSessionLogResponse(soap, (_inf__GetIderSessionLogResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetIderSessionLog: + soap_serialize_PointerTo_inf__GetIderSessionLog(soap, (_inf__GetIderSessionLog *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetSecurityParametersResponse: + soap_serialize_PointerTo_inf__GetSecurityParametersResponse(soap, (_inf__GetSecurityParametersResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetSecurityParameters: + soap_serialize_PointerTo_inf__GetSecurityParameters(soap, (_inf__GetSecurityParameters *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetNetworkStateResponse: + soap_serialize_PointerTo_inf__GetNetworkStateResponse(soap, (_inf__GetNetworkStateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetNetworkState: + soap_serialize_PointerTo_inf__GetNetworkState(soap, (_inf__GetNetworkState *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetEnabledInterfacesResponse: + soap_serialize_PointerTo_inf__GetEnabledInterfacesResponse(soap, (_inf__GetEnabledInterfacesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetEnabledInterfaces: + soap_serialize_PointerTo_inf__GetEnabledInterfaces(soap, (_inf__GetEnabledInterfaces *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetPasswordModelResponse: + soap_serialize_PointerTo_inf__GetPasswordModelResponse(soap, (_inf__GetPasswordModelResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetPasswordModel: + soap_serialize_PointerTo_inf__GetPasswordModel(soap, (_inf__GetPasswordModel *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatusResponse: + soap_serialize_PointerTo_inf__GetAdminNetAclEntryStatusResponse(soap, (_inf__GetAdminNetAclEntryStatusResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatus: + soap_serialize_PointerTo_inf__GetAdminNetAclEntryStatus(soap, (_inf__GetAdminNetAclEntryStatus *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatusResponse: + soap_serialize_PointerTo_inf__GetAdminAclEntryStatusResponse(soap, (_inf__GetAdminAclEntryStatusResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatus: + soap_serialize_PointerTo_inf__GetAdminAclEntryStatus(soap, (_inf__GetAdminAclEntryStatus *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetConfigServerInfoResponse: + soap_serialize_PointerTo_inf__GetConfigServerInfoResponse(soap, (_inf__GetConfigServerInfoResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetConfigServerInfo: + soap_serialize_PointerTo_inf__GetConfigServerInfo(soap, (_inf__GetConfigServerInfo *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetHostNameResponse: + soap_serialize_PointerTo_inf__GetHostNameResponse(soap, (_inf__GetHostNameResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetHostName: + soap_serialize_PointerTo_inf__GetHostName(soap, (_inf__GetHostName *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetVlanParametersResponse: + soap_serialize_PointerTo_inf__GetVlanParametersResponse(soap, (_inf__GetVlanParametersResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetVlanParameters: + soap_serialize_PointerTo_inf__GetVlanParameters(soap, (_inf__GetVlanParameters *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetProvisioningStateResponse: + soap_serialize_PointerTo_inf__GetProvisioningStateResponse(soap, (_inf__GetProvisioningStateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetProvisioningState: + soap_serialize_PointerTo_inf__GetProvisioningState(soap, (_inf__GetProvisioningState *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetProvisioningModeResponse: + soap_serialize_PointerTo_inf__GetProvisioningModeResponse(soap, (_inf__GetProvisioningModeResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetProvisioningMode: + soap_serialize_PointerTo_inf__GetProvisioningMode(soap, (_inf__GetProvisioningMode *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetCodeVersionsResponse: + soap_serialize_PointerTo_inf__GetCodeVersionsResponse(soap, (_inf__GetCodeVersionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetCodeVersions: + soap_serialize_PointerTo_inf__GetCodeVersions(soap, (_inf__GetCodeVersions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetCoreVersionResponse: + soap_serialize_PointerTo_inf__GetCoreVersionResponse(soap, (_inf__GetCoreVersionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_inf__GetCoreVersion: + soap_serialize_PointerTo_inf__GetCoreVersion(soap, (_inf__GetCoreVersion *const*)ptr); + break; + case SOAP_TYPE_PointerTo_idr__GetIderSessionLogResponse: + soap_serialize_PointerTo_idr__GetIderSessionLogResponse(soap, (_idr__GetIderSessionLogResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_idr__GetIderSessionLog: + soap_serialize_PointerTo_idr__GetIderSessionLog(soap, (_idr__GetIderSessionLog *const*)ptr); + break; + case SOAP_TYPE_PointerTo_idr__GetRedirectionListenerStateResponse: + soap_serialize_PointerTo_idr__GetRedirectionListenerStateResponse(soap, (_idr__GetRedirectionListenerStateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_idr__GetRedirectionListenerState: + soap_serialize_PointerTo_idr__GetRedirectionListenerState(soap, (_idr__GetRedirectionListenerState *const*)ptr); + break; + case SOAP_TYPE_PointerTo_idr__SetRedirectionListenerStateResponse: + soap_serialize_PointerTo_idr__SetRedirectionListenerStateResponse(soap, (_idr__SetRedirectionListenerStateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_idr__SetRedirectionListenerState: + soap_serialize_PointerTo_idr__SetRedirectionListenerState(soap, (_idr__SetRedirectionListenerState *const*)ptr); + break; + case SOAP_TYPE_PointerTo_hwa__GetAssetDataResponse: + soap_serialize_PointerTo_hwa__GetAssetDataResponse(soap, (_hwa__GetAssetDataResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_hwa__GetAssetData: + soap_serialize_PointerTo_hwa__GetAssetData(soap, (_hwa__GetAssetData *const*)ptr); + break; + case SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypesResponse: + soap_serialize_PointerTo_hwa__EnumerateAssetTypesResponse(soap, (_hwa__EnumerateAssetTypesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypes: + soap_serialize_PointerTo_hwa__EnumerateAssetTypes(soap, (_hwa__EnumerateAssetTypes *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscriptionResponse: + soap_serialize_PointerTo_emi__GetGeneralAlertSubscriptionResponse(soap, (_emi__GetGeneralAlertSubscriptionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscription: + soap_serialize_PointerTo_emi__GetGeneralAlertSubscription(soap, (_emi__GetGeneralAlertSubscription *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse: + soap_serialize_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(soap, (_emi__EnumerateGeneralAlertSubscriptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptions: + soap_serialize_PointerTo_emi__EnumerateGeneralAlertSubscriptions(soap, (_emi__EnumerateGeneralAlertSubscriptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlertResponse: + soap_serialize_PointerTo_emi__SubscribeForGeneralAlertResponse(soap, (_emi__SubscribeForGeneralAlertResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlert: + soap_serialize_PointerTo_emi__SubscribeForGeneralAlert(soap, (_emi__SubscribeForGeneralAlert *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetSensorAttributesResponse: + soap_serialize_PointerTo_emi__GetSensorAttributesResponse(soap, (_emi__GetSensorAttributesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetSensorAttributes: + soap_serialize_PointerTo_emi__GetSensorAttributes(soap, (_emi__GetSensorAttributes *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateSensorsResponse: + soap_serialize_PointerTo_emi__EnumerateSensorsResponse(soap, (_emi__EnumerateSensorsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateSensors: + soap_serialize_PointerTo_emi__EnumerateSensors(soap, (_emi__EnumerateSensors *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClockResponse: + soap_serialize_PointerTo_emi__GetEventLogTimestampClockResponse(soap, (_emi__GetEventLogTimestampClockResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClock: + soap_serialize_PointerTo_emi__GetEventLogTimestampClock(soap, (_emi__GetEventLogTimestampClock *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClockResponse: + soap_serialize_PointerTo_emi__SetEventLogTimestampClockResponse(soap, (_emi__SetEventLogTimestampClockResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClock: + soap_serialize_PointerTo_emi__SetEventLogTimestampClock(soap, (_emi__SetEventLogTimestampClock *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__FreezeEventLogResponse: + soap_serialize_PointerTo_emi__FreezeEventLogResponse(soap, (_emi__FreezeEventLogResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__FreezeEventLog: + soap_serialize_PointerTo_emi__FreezeEventLog(soap, (_emi__FreezeEventLog *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__ClearEventLogResponse: + soap_serialize_PointerTo_emi__ClearEventLogResponse(soap, (_emi__ClearEventLogResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__ClearEventLog: + soap_serialize_PointerTo_emi__ClearEventLog(soap, (_emi__ClearEventLog *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__ReadEventLogRecordsResponse: + soap_serialize_PointerTo_emi__ReadEventLogRecordsResponse(soap, (_emi__ReadEventLogRecordsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__ReadEventLogRecords: + soap_serialize_PointerTo_emi__ReadEventLogRecords(soap, (_emi__ReadEventLogRecords *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetEventLogStatusResponse: + soap_serialize_PointerTo_emi__GetEventLogStatusResponse(soap, (_emi__GetEventLogStatusResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetEventLogStatus: + soap_serialize_PointerTo_emi__GetEventLogStatus(soap, (_emi__GetEventLogStatus *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__RemoveEventFilterResponse: + soap_serialize_PointerTo_emi__RemoveEventFilterResponse(soap, (_emi__RemoveEventFilterResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__RemoveEventFilter: + soap_serialize_PointerTo_emi__RemoveEventFilter(soap, (_emi__RemoveEventFilter *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__UpdateEventFilterResponse: + soap_serialize_PointerTo_emi__UpdateEventFilterResponse(soap, (_emi__UpdateEventFilterResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__UpdateEventFilter: + soap_serialize_PointerTo_emi__UpdateEventFilter(soap, (_emi__UpdateEventFilter *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetEventFilterResponse: + soap_serialize_PointerTo_emi__GetEventFilterResponse(soap, (_emi__GetEventFilterResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetEventFilter: + soap_serialize_PointerTo_emi__GetEventFilter(soap, (_emi__GetEventFilter *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__CancelAlertSubscriptionResponse: + soap_serialize_PointerTo_emi__CancelAlertSubscriptionResponse(soap, (_emi__CancelAlertSubscriptionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__CancelAlertSubscription: + soap_serialize_PointerTo_emi__CancelAlertSubscription(soap, (_emi__CancelAlertSubscription *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateAlertPoliciesResponse: + soap_serialize_PointerTo_emi__EnumerateAlertPoliciesResponse(soap, (_emi__EnumerateAlertPoliciesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateAlertPolicies: + soap_serialize_PointerTo_emi__EnumerateAlertPolicies(soap, (_emi__EnumerateAlertPolicies *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptionsResponse: + soap_serialize_PointerTo_emi__EnumerateAlertSubscriptionsResponse(soap, (_emi__EnumerateAlertSubscriptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptions: + soap_serialize_PointerTo_emi__EnumerateAlertSubscriptions(soap, (_emi__EnumerateAlertSubscriptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__SubscribeForAlertResponse: + soap_serialize_PointerTo_emi__SubscribeForAlertResponse(soap, (_emi__SubscribeForAlertResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__SubscribeForAlert: + soap_serialize_PointerTo_emi__SubscribeForAlert(soap, (_emi__SubscribeForAlert *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__AddEventFilterResponse: + soap_serialize_PointerTo_emi__AddEventFilterResponse(soap, (_emi__AddEventFilterResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__AddEventFilter: + soap_serialize_PointerTo_emi__AddEventFilter(soap, (_emi__AddEventFilter *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetAlertCommunityStringResponse: + soap_serialize_PointerTo_emi__GetAlertCommunityStringResponse(soap, (_emi__GetAlertCommunityStringResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetAlertCommunityString: + soap_serialize_PointerTo_emi__GetAlertCommunityString(soap, (_emi__GetAlertCommunityString *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__SetAlertCommunityStringResponse: + soap_serialize_PointerTo_emi__SetAlertCommunityStringResponse(soap, (_emi__SetAlertCommunityStringResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__SetAlertCommunityString: + soap_serialize_PointerTo_emi__SetAlertCommunityString(soap, (_emi__SetAlertCommunityString *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetAlertSubscriptionResponse: + soap_serialize_PointerTo_emi__GetAlertSubscriptionResponse(soap, (_emi__GetAlertSubscriptionResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__GetAlertSubscription: + soap_serialize_PointerTo_emi__GetAlertSubscription(soap, (_emi__GetAlertSubscription *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateEventFiltersResponse: + soap_serialize_PointerTo_emi__EnumerateEventFiltersResponse(soap, (_emi__EnumerateEventFiltersResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_emi__EnumerateEventFilters: + soap_serialize_PointerTo_emi__EnumerateEventFilters(soap, (_emi__EnumerateEventFilters *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__GetHcbStateResponse: + soap_serialize_PointerTo_cb__GetHcbStateResponse(soap, (_cb__GetHcbStateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__GetHcbState: + soap_serialize_PointerTo_cb__GetHcbState(soap, (_cb__GetHcbState *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__ClearHcbStateResponse: + soap_serialize_PointerTo_cb__ClearHcbStateResponse(soap, (_cb__ClearHcbStateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__ClearHcbState: + soap_serialize_PointerTo_cb__ClearHcbState(soap, (_cb__ClearHcbState *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__GetHcbOptionsResponse: + soap_serialize_PointerTo_cb__GetHcbOptionsResponse(soap, (_cb__GetHcbOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__GetHcbOptions: + soap_serialize_PointerTo_cb__GetHcbOptions(soap, (_cb__GetHcbOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__SetHcbOptionsResponse: + soap_serialize_PointerTo_cb__SetHcbOptionsResponse(soap, (_cb__SetHcbOptionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__SetHcbOptions: + soap_serialize_PointerTo_cb__SetHcbOptions(soap, (_cb__SetHcbOptions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbQueryCapabilitiesResponse: + soap_serialize_PointerTo_cb__CbQueryCapabilitiesResponse(soap, (_cb__CbQueryCapabilitiesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbQueryCapabilities: + soap_serialize_PointerTo_cb__CbQueryCapabilities(soap, (_cb__CbQueryCapabilities *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbFilterEnumerateResponse: + soap_serialize_PointerTo_cb__CbFilterEnumerateResponse(soap, (_cb__CbFilterEnumerateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbFilterEnumerate: + soap_serialize_PointerTo_cb__CbFilterEnumerate(soap, (_cb__CbFilterEnumerate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbFilterDeleteResponse: + soap_serialize_PointerTo_cb__CbFilterDeleteResponse(soap, (_cb__CbFilterDeleteResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbFilterDelete: + soap_serialize_PointerTo_cb__CbFilterDelete(soap, (_cb__CbFilterDelete *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbFilterGetResponse: + soap_serialize_PointerTo_cb__CbFilterGetResponse(soap, (_cb__CbFilterGetResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbFilterGet: + soap_serialize_PointerTo_cb__CbFilterGet(soap, (_cb__CbFilterGet *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbFilterCreateResponse: + soap_serialize_PointerTo_cb__CbFilterCreateResponse(soap, (_cb__CbFilterCreateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbFilterCreate: + soap_serialize_PointerTo_cb__CbFilterCreate(soap, (_cb__CbFilterCreate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatisticsResponse: + soap_serialize_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(soap, (_cb__CbPolicyGetActiveStatisticsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatistics: + soap_serialize_PointerTo_cb__CbPolicyGetActiveStatistics(soap, (_cb__CbPolicyGetActiveStatistics *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabledResponse: + soap_serialize_PointerTo_cb__CbPolicyGetEnabledResponse(soap, (_cb__CbPolicyGetEnabledResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabled: + soap_serialize_PointerTo_cb__CbPolicyGetEnabled(soap, (_cb__CbPolicyGetEnabled *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyDisableResponse: + soap_serialize_PointerTo_cb__CbPolicyDisableResponse(soap, (_cb__CbPolicyDisableResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyDisable: + soap_serialize_PointerTo_cb__CbPolicyDisable(soap, (_cb__CbPolicyDisable *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyEnableResponse: + soap_serialize_PointerTo_cb__CbPolicyEnableResponse(soap, (_cb__CbPolicyEnableResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyEnable: + soap_serialize_PointerTo_cb__CbPolicyEnable(soap, (_cb__CbPolicyEnable *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyEnumerateResponse: + soap_serialize_PointerTo_cb__CbPolicyEnumerateResponse(soap, (_cb__CbPolicyEnumerateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyEnumerate: + soap_serialize_PointerTo_cb__CbPolicyEnumerate(soap, (_cb__CbPolicyEnumerate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyDeleteResponse: + soap_serialize_PointerTo_cb__CbPolicyDeleteResponse(soap, (_cb__CbPolicyDeleteResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyDelete: + soap_serialize_PointerTo_cb__CbPolicyDelete(soap, (_cb__CbPolicyDelete *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyGetResponse: + soap_serialize_PointerTo_cb__CbPolicyGetResponse(soap, (_cb__CbPolicyGetResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyGet: + soap_serialize_PointerTo_cb__CbPolicyGet(soap, (_cb__CbPolicyGet *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyCreateResponse: + soap_serialize_PointerTo_cb__CbPolicyCreateResponse(soap, (_cb__CbPolicyCreateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_cb__CbPolicyCreate: + soap_serialize_PointerTo_cb__CbPolicyCreate(soap, (_cb__CbPolicyCreate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse: + soap_serialize_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, (_apr__ConsoleWatchdogQueryCapabilitiesResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilities: + soap_serialize_PointerTo_apr__ConsoleWatchdogQueryCapabilities(soap, (_apr__ConsoleWatchdogQueryCapabilities *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse: + soap_serialize_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(soap, (_apr__ConsoleWatchdogGetCbPolicyResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicy: + soap_serialize_PointerTo_apr__ConsoleWatchdogGetCbPolicy(soap, (_apr__ConsoleWatchdogGetCbPolicy *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse: + soap_serialize_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(soap, (_apr__ConsoleWatchdogSetCbPolicyResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicy: + soap_serialize_PointerTo_apr__ConsoleWatchdogSetCbPolicy(soap, (_apr__ConsoleWatchdogSetCbPolicy *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActionsResponse: + soap_serialize_PointerTo_apr__ConsoleWatchdogGetActionsResponse(soap, (_apr__ConsoleWatchdogGetActionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActions: + soap_serialize_PointerTo_apr__ConsoleWatchdogGetActions(soap, (_apr__ConsoleWatchdogGetActions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActionsResponse: + soap_serialize_PointerTo_apr__ConsoleWatchdogSetActionsResponse(soap, (_apr__ConsoleWatchdogSetActionsResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActions: + soap_serialize_PointerTo_apr__ConsoleWatchdogSetActions(soap, (_apr__ConsoleWatchdogSetActions *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerateResponse: + soap_serialize_PointerTo_apr__ConsoleWatchdogEnumerateResponse(soap, (_apr__ConsoleWatchdogEnumerateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerate: + soap_serialize_PointerTo_apr__ConsoleWatchdogEnumerate(soap, (_apr__ConsoleWatchdogEnumerate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDeleteResponse: + soap_serialize_PointerTo_apr__ConsoleWatchdogDeleteResponse(soap, (_apr__ConsoleWatchdogDeleteResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDelete: + soap_serialize_PointerTo_apr__ConsoleWatchdogDelete(soap, (_apr__ConsoleWatchdogDelete *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreateResponse: + soap_serialize_PointerTo_apr__ConsoleWatchdogCreateResponse(soap, (_apr__ConsoleWatchdogCreateResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreate: + soap_serialize_PointerTo_apr__ConsoleWatchdogCreate(soap, (_apr__ConsoleWatchdogCreate *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apl__AgentWatchdogRegisterResponse: + soap_serialize_PointerTo_apl__AgentWatchdogRegisterResponse(soap, (_apl__AgentWatchdogRegisterResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apl__AgentWatchdogRegister: + soap_serialize_PointerTo_apl__AgentWatchdogRegister(soap, (_apl__AgentWatchdogRegister *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeatResponse: + soap_serialize_PointerTo_apl__AgentWatchdogHeartbeatResponse(soap, (_apl__AgentWatchdogHeartbeatResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeat: + soap_serialize_PointerTo_apl__AgentWatchdogHeartbeat(soap, (_apl__AgentWatchdogHeartbeat *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdownResponse: + soap_serialize_PointerTo_apl__AgentWatchdogShutdownResponse(soap, (_apl__AgentWatchdogShutdownResponse *const*)ptr); + break; + case SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdown: + soap_serialize_PointerTo_apl__AgentWatchdogShutdown(soap, (_apl__AgentWatchdogShutdown *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType: + soap_serialize_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(soap, (cb__CircuitBreakerIPLayeredTCPFlagsType *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__WirelessSettingsType: + soap_serialize_PointerTowcxs__WirelessSettingsType(soap, (wcxs__WirelessSettingsType *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__WirelessCapabilitiesType: + soap_serialize_PointerTowcxs__WirelessCapabilitiesType(soap, (wcxs__WirelessCapabilitiesType *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__ProfileType: + soap_serialize_PointerTowcxs__ProfileType(soap, (wcxs__ProfileType *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingsType: + soap_serialize_PointerTowcxs__ProfileSecuritySettingsType(soap, (wcxs__ProfileSecuritySettingsType *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingRSNType: + soap_serialize_PointerTowcxs__ProfileSecuritySettingRSNType(soap, (wcxs__ProfileSecuritySettingRSNType *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingWPAType: + soap_serialize_PointerTowcxs__ProfileSecuritySettingWPAType(soap, (wcxs__ProfileSecuritySettingWPAType *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__DataEncryptionCCMPType: + soap_serialize_PointerTowcxs__DataEncryptionCCMPType(soap, (wcxs__DataEncryptionCCMPType *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__DataEncryptionTKIPType: + soap_serialize_PointerTowcxs__DataEncryptionTKIPType(soap, (wcxs__DataEncryptionTKIPType *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__RawKey256Type: + soap_serialize_PointerTowcxs__RawKey256Type(soap, (xsd__base64Binary *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__PassPhrase63Type: + soap_serialize_PointerTowcxs__PassPhrase63Type(soap, (std::string *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__WEP128Type: + soap_serialize_PointerTowcxs__WEP128Type(soap, (wcxs__WEP128Type *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__WEP64Type: + soap_serialize_PointerTowcxs__WEP64Type(soap, (wcxs__WEP64Type *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__RawKey128Type: + soap_serialize_PointerTowcxs__RawKey128Type(soap, (xsd__base64Binary *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__PassPhraseWEP128Type: + soap_serialize_PointerTowcxs__PassPhraseWEP128Type(soap, (std::string *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__RawKey64Type: + soap_serialize_PointerTowcxs__RawKey64Type(soap, (xsd__base64Binary *const*)ptr); + break; + case SOAP_TYPE_PointerTowcxs__PassPhrase5Type: + soap_serialize_PointerTowcxs__PassPhrase5Type(soap, (std::string *const*)ptr); + break; + case SOAP_TYPE_PointerTorci__OemParametersType: + soap_serialize_PointerTorci__OemParametersType(soap, (unsigned short *const*)ptr); + break; + case SOAP_TYPE_PointerTorci__BootOptionsType: + soap_serialize_PointerTorci__BootOptionsType(soap, (unsigned short *const*)ptr); + break; + case SOAP_TYPE_PointerTorci__SpecialCommandParameterType: + soap_serialize_PointerTorci__SpecialCommandParameterType(soap, (unsigned short *const*)ptr); + break; + case SOAP_TYPE_PointerTorci__SpecialCommandType: + soap_serialize_PointerTorci__SpecialCommandType(soap, (enum rci__SpecialCommandType *const*)ptr); + break; + case SOAP_TYPE_PointerToinf__IderSessionLogEntryType: + soap_serialize_PointerToinf__IderSessionLogEntryType(soap, (inf__IderSessionLogEntryType *const*)ptr); + break; + case SOAP_TYPE_PointerToinf__FirmwareVersionType: + soap_serialize_PointerToinf__FirmwareVersionType(soap, (inf__FirmwareVersionType *const*)ptr); + break; + case SOAP_TYPE_PointerToidr__IderSessionLogEntryType: + soap_serialize_PointerToidr__IderSessionLogEntryType(soap, (idr__IderSessionLogEntryType *const*)ptr); + break; + case SOAP_TYPE_PointerToapl__GUID: + soap_serialize_PointerToapl__GUID(soap, (apl__GUID *const*)ptr); + break; + case SOAP_TYPE_PointerToapr__AgentPresenceCapabilitiesType: + soap_serialize_PointerToapr__AgentPresenceCapabilitiesType(soap, (apr__AgentPresenceCapabilitiesType *const*)ptr); + break; + case SOAP_TYPE_PointerToapr__CircuitBreakerHardwarePolicyType: + soap_serialize_PointerToapr__CircuitBreakerHardwarePolicyType(soap, (apr__CircuitBreakerHardwarePolicyType *const*)ptr); + break; + case SOAP_TYPE_PointerToapr__ConsoleWatchdogActionType: + soap_serialize_PointerToapr__ConsoleWatchdogActionType(soap, (apr__ConsoleWatchdogActionType *const*)ptr); + break; + case SOAP_TYPE_PointerToapr__ConsoleWatchdogEntryType: + soap_serialize_PointerToapr__ConsoleWatchdogEntryType(soap, (apr__ConsoleWatchdogEntryType *const*)ptr); + break; + case SOAP_TYPE_PointerToapr__CbActionType: + soap_serialize_PointerToapr__CbActionType(soap, (enum apr__CbActionType *const*)ptr); + break; + case SOAP_TYPE_PointerToapr__GUID: + soap_serialize_PointerToapr__GUID(soap, (apr__GUID *const*)ptr); + break; + case SOAP_TYPE_PointerTohwa__AssetDataArrayType: + soap_serialize_PointerTohwa__AssetDataArrayType(soap, (hwa__AssetDataArrayType *const*)ptr); + break; + case SOAP_TYPE_PointerTohwa__AssetTypeArrayType: + soap_serialize_PointerTohwa__AssetTypeArrayType(soap, (hwa__AssetTypeArrayType *const*)ptr); + break; + case SOAP_TYPE_PointerTohwa__GUID: + soap_serialize_PointerTohwa__GUID(soap, (hwa__GUID *const*)ptr); + break; + case SOAP_TYPE_PointerToxsd__base64Binary: + soap_serialize_PointerToxsd__base64Binary(soap, (xsd__base64Binary *const*)ptr); + break; + case SOAP_TYPE_PointerTohwa__AssetDataType: + soap_serialize_PointerTohwa__AssetDataType(soap, (hwa__AssetDataType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__BlockedPortInfoType: + soap_serialize_PointerTocb__BlockedPortInfoType(soap, (cb__BlockedPortInfoType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__HcbTriggerReasonType: + soap_serialize_PointerTocb__HcbTriggerReasonType(soap, (enum cb__HcbTriggerReasonType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__TimeType: + soap_serialize_PointerTocb__TimeType(soap, (unsigned int *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__HcbOptionsType: + soap_serialize_PointerTocb__HcbOptionsType(soap, (cb__HcbOptionsType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerCapabilitiesType: + soap_serialize_PointerTocb__CircuitBreakerCapabilitiesType(soap, (cb__CircuitBreakerCapabilitiesType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerFilterInfoType: + soap_serialize_PointerTocb__CircuitBreakerFilterInfoType(soap, (cb__CircuitBreakerFilterInfoType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerFilterStatisticsType: + soap_serialize_PointerTocb__CircuitBreakerFilterStatisticsType(soap, (cb__CircuitBreakerFilterStatisticsType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerApplicationType: + soap_serialize_PointerTocb__CircuitBreakerApplicationType(soap, (enum cb__CircuitBreakerApplicationType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerHardwarePolicyType: + soap_serialize_PointerTocb__CircuitBreakerHardwarePolicyType(soap, (cb__CircuitBreakerHardwarePolicyType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerPolicyInfoType: + soap_serialize_PointerTocb__CircuitBreakerPolicyInfoType(soap, (cb__CircuitBreakerPolicyInfoType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__TimedCounterType: + soap_serialize_PointerTocb__TimedCounterType(soap, (cb__TimedCounterType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerFilterType: + soap_serialize_PointerTocb__CircuitBreakerFilterType(soap, (cb__CircuitBreakerFilterType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketType: + soap_serialize_PointerTocb__CircuitBreakerPacketType(soap, (cb__CircuitBreakerPacketType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketETHType: + soap_serialize_PointerTocb__CircuitBreakerPacketETHType(soap, (cb__CircuitBreakerPacketETHType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketIPType: + soap_serialize_PointerTocb__CircuitBreakerPacketIPType(soap, (cb__CircuitBreakerPacketIPType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketUDPType: + soap_serialize_PointerTocb__CircuitBreakerPacketUDPType(soap, (cb__CircuitBreakerPacketUDPType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerPacketTCPType: + soap_serialize_PointerTocb__CircuitBreakerPacketTCPType(soap, (cb__CircuitBreakerPacketTCPType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortType: + soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortType(soap, (cb__CircuitBreakerIPLayeredPortType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerIPPacketType: + soap_serialize_PointerTocb__CircuitBreakerIPPacketType(soap, (cb__CircuitBreakerIPPacketType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv6Type: + soap_serialize_PointerTocb__CircuitBreakerIPv6Type(soap, (cb__CircuitBreakerIPv6Type *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv4Type: + soap_serialize_PointerTocb__CircuitBreakerIPv4Type(soap, (cb__CircuitBreakerIPv4Type *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv6AddressAndMaskType: + soap_serialize_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(soap, (cb__CircuitBreakerIPv6AddressAndMaskType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerIPv4AddressAndMaskType: + soap_serialize_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(soap, (cb__CircuitBreakerIPv4AddressAndMaskType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortRangeType: + soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, (cb__CircuitBreakerIPLayeredPortRangeType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortSimpleType: + soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(soap, (cb__CircuitBreakerIPLayeredPortSimpleType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerPolicyType: + soap_serialize_PointerTocb__CircuitBreakerPolicyType(soap, (cb__CircuitBreakerPolicyType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerDefaultFilterType: + soap_serialize_PointerTocb__CircuitBreakerDefaultFilterType(soap, (cb__CircuitBreakerDefaultFilterType *const*)ptr); + break; + case SOAP_TYPE_PointerTocb__CircuitBreakerAntiSpoofingFilterType: + soap_serialize_PointerTocb__CircuitBreakerAntiSpoofingFilterType(soap, (cb__CircuitBreakerAntiSpoofingFilterType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__AlertSubscriptionGeneralType: + soap_serialize_PointerToemi__AlertSubscriptionGeneralType(soap, (emi__AlertSubscriptionGeneralType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__SensorAttributesType: + soap_serialize_PointerToemi__SensorAttributesType(soap, (emi__SensorAttributesType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__SensorHandleArrayType: + soap_serialize_PointerToemi__SensorHandleArrayType(soap, (emi__SensorHandleArrayType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__EventLogRecordArrayType: + soap_serialize_PointerToemi__EventLogRecordArrayType(soap, (emi__EventLogRecordArrayType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__EventFilterHandleArrayType: + soap_serialize_PointerToemi__EventFilterHandleArrayType(soap, (emi__EventFilterHandleArrayType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__EventFilterType: + soap_serialize_PointerToemi__EventFilterType(soap, (emi__EventFilterType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__ByteStr: + soap_serialize_PointerToemi__ByteStr(soap, (emi__ByteStr *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDArrayType: + soap_serialize_PointerToemi__AlertSubscriptionPolicyIDArrayType(soap, (emi__AlertSubscriptionPolicyIDArrayType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__AlertSubscriptionHandleArrayType: + soap_serialize_PointerToemi__AlertSubscriptionHandleArrayType(soap, (emi__AlertSubscriptionHandleArrayType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDType: + soap_serialize_PointerToemi__AlertSubscriptionPolicyIDType(soap, (unsigned char *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__AlertSubscriptionType: + soap_serialize_PointerToemi__AlertSubscriptionType(soap, (emi__AlertSubscriptionType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__AlertSubscriptionSoapType: + soap_serialize_PointerToemi__AlertSubscriptionSoapType(soap, (emi__AlertSubscriptionSoapType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__AlertSubscriptionSNMPType: + soap_serialize_PointerToemi__AlertSubscriptionSNMPType(soap, (emi__AlertSubscriptionSNMPType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__AlertCredentialsType: + soap_serialize_PointerToemi__AlertCredentialsType(soap, (emi__AlertCredentialsType *const*)ptr); + break; + case SOAP_TYPE_PointerTocmn__URLType: + soap_serialize_PointerTocmn__URLType(soap, (cmn__URLType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__CommunityStringType: + soap_serialize_PointerToemi__CommunityStringType(soap, (std::string *const*)ptr); + break; + case SOAP_TYPE_PointerTocmn__NodeAddressType: + soap_serialize_PointerTocmn__NodeAddressType(soap, (cmn__NodeAddressType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__EventLogRecordType: + soap_serialize_PointerToemi__EventLogRecordType(soap, (emi__EventLogRecordType *const*)ptr); + break; + case SOAP_TYPE_PointerToemi__ByteData: + soap_serialize_PointerToemi__ByteData(soap, (emi__ByteData *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__StorageAllocEntryHandleListType: + soap_serialize_PointerTostra__StorageAllocEntryHandleListType(soap, (stra__StorageAllocEntryHandleListType *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__StorageAllocEntryType: + soap_serialize_PointerTostra__StorageAllocEntryType(soap, (stra__StorageAllocEntryType *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__StorageEaclEntryHandleListType: + soap_serialize_PointerTostra__StorageEaclEntryHandleListType(soap, (stra__StorageEaclEntryHandleListType *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__StorageEaclEntryType: + soap_serialize_PointerTostra__StorageEaclEntryType(soap, (stra__StorageEaclEntryType *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__StorageApplicationAttributesType: + soap_serialize_PointerTostra__StorageApplicationAttributesType(soap, (stra__StorageApplicationAttributesType *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__StorageApplicationHandleListType: + soap_serialize_PointerTostra__StorageApplicationHandleListType(soap, (stra__StorageApplicationHandleListType *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__GlobalStorageAttributesType: + soap_serialize_PointerTostra__GlobalStorageAttributesType(soap, (stra__GlobalStorageAttributesType *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__StorageSnrpApplicationAttributeType: + soap_serialize_PointerTostra__StorageSnrpApplicationAttributeType(soap, (stra__StorageSnrpApplicationAttributeType *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__GUID: + soap_serialize_PointerTostra__GUID(soap, (stra__GUID *const*)ptr); + break; + case SOAP_TYPE_PointerTostra__StorageAllocSnrpEntryType: + soap_serialize_PointerTostra__StorageAllocSnrpEntryType(soap, (stra__StorageAllocSnrpEntryType *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__XProfileType: + soap_serialize_PointerToxcfg__XProfileType(soap, (xcfg__XProfileType *const*)ptr); + break; + case SOAP_TYPE_PointerTonet__InterfaceDescriptorSetType: + soap_serialize_PointerTonet__InterfaceDescriptorSetType(soap, (net__InterfaceDescriptorSetType *const*)ptr); + break; + case SOAP_TYPE_PointerTonet__InterfaceDescriptorGetType: + soap_serialize_PointerTonet__InterfaceDescriptorGetType(soap, (net__InterfaceDescriptorGetType *const*)ptr); + break; + case SOAP_TYPE_PointerTocmn__InterfaceHandleType: + soap_serialize_PointerTocmn__InterfaceHandleType(soap, (unsigned int *const*)ptr); + break; + case SOAP_TYPE_PointerTonet__StaticIPv4ParametersType: + soap_serialize_PointerTonet__StaticIPv4ParametersType(soap, (net__StaticIPv4ParametersType *const*)ptr); + break; + case SOAP_TYPE_PointerTonet__IPv4ParametersType: + soap_serialize_PointerTonet__IPv4ParametersType(soap, (net__IPv4ParametersType *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCORETLSType: + soap_serialize_PointerToxcfg__XProfileEAPFAST_USCORETLSType(soap, (xcfg__XProfileEAPFAST_USCORETLSType *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREGTCType: + soap_serialize_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(soap, (xcfg__XProfileEAPFAST_USCOREGTCType *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type: + soap_serialize_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__XProfileEAP_USCOREGTCType: + soap_serialize_PointerToxcfg__XProfileEAP_USCOREGTCType(soap, (xcfg__XProfileEAP_USCOREGTCType *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type: + soap_serialize_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, (xcfg__XProfilePEAP_USCOREMSCHAPv2Type *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type: + soap_serialize_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, (xcfg__XProfileTTLS_USCOREMSCHAPv2Type *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__XProfileTLSType: + soap_serialize_PointerToxcfg__XProfileTLSType(soap, (xcfg__XProfileTLSType *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__ManualPACType: + soap_serialize_PointerToxcfg__ManualPACType(soap, (xcfg__ManualPACType *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__UserCredentialsType: + soap_serialize_PointerToxcfg__UserCredentialsType(soap, (xcfg__UserCredentialsType *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__ServerIdentityType: + soap_serialize_PointerToxcfg__ServerIdentityType(soap, (xcfg__ServerIdentityType *const*)ptr); + break; + case SOAP_TYPE_PointerToxcfg__CertificateNameType: + soap_serialize_PointerToxcfg__CertificateNameType(soap, (xcfg__CertificateNameType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__CertificateHandleType: + soap_serialize_PointerTosai__CertificateHandleType(soap, (unsigned int *const*)ptr); + break; + case SOAP_TYPE_PointerTocstr__KeyPairType: + soap_serialize_PointerTocstr__KeyPairType(soap, (cstr__KeyPairType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__GlobalPowerPolicyType: + soap_serialize_PointerTosai__GlobalPowerPolicyType(soap, (sai__GlobalPowerPolicyType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__EnvironmentDetectionType: + soap_serialize_PointerTosai__EnvironmentDetectionType(soap, (sai__EnvironmentDetectionType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__ProvisioningAuditRecordType: + soap_serialize_PointerTosai__ProvisioningAuditRecordType(soap, (sai__ProvisioningAuditRecordType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__CertHashEntryType: + soap_serialize_PointerTosai__CertHashEntryType(soap, (sai__CertHashEntryType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__ProvisioningOTPType: + soap_serialize_PointerTosai__ProvisioningOTPType(soap, (xsd__base64Binary *const*)ptr); + break; + case SOAP_TYPE_PointerTounsignedShort: + soap_serialize_PointerTounsignedShort(soap, (unsigned short *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__PowerStateType: + soap_serialize_PointerTosai__PowerStateType(soap, (enum sai__PowerStateType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__PkiCapsType: + soap_serialize_PointerTosai__PkiCapsType(soap, (sai__PkiCapsType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__CrlType: + soap_serialize_PointerTosai__CrlType(soap, (sai__CrlType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__CertificateType: + soap_serialize_PointerTosai__CertificateType(soap, (sai__CertificateType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__TlsOptionsType: + soap_serialize_PointerTosai__TlsOptionsType(soap, (sai__TlsOptionsType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__KerberosOptionsType: + soap_serialize_PointerTosai__KerberosOptionsType(soap, (sai__KerberosOptionsType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__AdminAclEntryExType: + soap_serialize_PointerTosai__AdminAclEntryExType(soap, (sai__AdminAclEntryExType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__UserAclEntryExType: + soap_serialize_PointerTosai__UserAclEntryExType(soap, (sai__UserAclEntryExType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__UpdateCoreUrlKeyType: + soap_serialize_PointerTosai__UpdateCoreUrlKeyType(soap, (sai__UpdateCoreUrlKeyType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__AmtVersion: + soap_serialize_PointerTosai__AmtVersion(soap, (sai__AmtVersion *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__RngKeyType: + soap_serialize_PointerTosai__RngKeyType(soap, (sai__RngKeyType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__CertificateChainType: + soap_serialize_PointerTosai__CertificateChainType(soap, (sai__CertificateChainType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__RsaKeyType: + soap_serialize_PointerTosai__RsaKeyType(soap, (sai__RsaKeyType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__UserAclEntryHandleListType: + soap_serialize_PointerTosai__UserAclEntryHandleListType(soap, (sai__UserAclEntryHandleListType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__AdminAclEntryType: + soap_serialize_PointerTosai__AdminAclEntryType(soap, (sai__AdminAclEntryType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__UserAclEntryType: + soap_serialize_PointerTosai__UserAclEntryType(soap, (sai__UserAclEntryType *const*)ptr); + break; + case SOAP_TYPE_PointerTounsignedInt: + soap_serialize_PointerTounsignedInt(soap, (unsigned int *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__EnvironmentDetectionDomainType: + soap_serialize_PointerTosai__EnvironmentDetectionDomainType(soap, (sai__EnvironmentDetectionDomainType *const*)ptr); + break; + case SOAP_TYPE_PointerTobool: + soap_serialize_PointerTobool(soap, (bool *const*)ptr); + break; + case SOAP_TYPE_PointerTostd__string: + soap_serialize_PointerTostd__string(soap, (std::string *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__KerberosSpnType: + soap_serialize_PointerTosai__KerberosSpnType(soap, (sai__KerberosSpnType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__UserEntryKerberosType: + soap_serialize_PointerTosai__UserEntryKerberosType(soap, (sai__UserEntryKerberosType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__UserEntryDigestType: + soap_serialize_PointerTosai__UserEntryDigestType(soap, (sai__UserEntryDigestType *const*)ptr); + break; + case SOAP_TYPE_PointerTosai__UserAclRealmListType: + soap_serialize_PointerTosai__UserAclRealmListType(soap, (sai__UserAclRealmListType *const*)ptr); + break; + case SOAP_TYPE_PointerTocstr__RSAKeyPairType: + soap_serialize_PointerTocstr__RSAKeyPairType(soap, (cstr__RSAKeyPairType *const*)ptr); + break; + case SOAP_TYPE_PointerTocmn__IPv6AddressStringType: + soap_serialize_PointerTocmn__IPv6AddressStringType(soap, (std::string *const*)ptr); + break; + case SOAP_TYPE_PointerTocmn__IPv4AddressStringType: + soap_serialize_PointerTocmn__IPv4AddressStringType(soap, (std::string *const*)ptr); + break; + case SOAP_TYPE_PointerTocmn__HostNameType: + soap_serialize_PointerTocmn__HostNameType(soap, (std::string *const*)ptr); + break; + case SOAP_TYPE_PointerTounsignedByte: + soap_serialize_PointerTounsignedByte(soap, (unsigned char *const*)ptr); + break; + case SOAP_TYPE__QName: + soap_serialize_string(soap, (char**)&ptr); + break; + case SOAP_TYPE_string: + soap_serialize_string(soap, (char**)&ptr); + break; + } +} +#endif + +SOAP_FMAC3 void * SOAP_FMAC4 soap_instantiate(struct soap *soap, int t, const char *type, const char *arrayType, size_t *n) +{ + switch (t) + { + case SOAP_TYPE_std__string: + return (void*)soap_instantiate_std__string(soap, -1, type, arrayType, n); + case SOAP_TYPE_xsd__base64Binary: + return (void*)soap_instantiate_xsd__base64Binary(soap, -1, type, arrayType, n); + case SOAP_TYPE_cmn__NodeAddressType: + return (void*)soap_instantiate_cmn__NodeAddressType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cstr__RSAKeyPairType: + return (void*)soap_instantiate_cstr__RSAKeyPairType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cstr__KeyPairType: + return (void*)soap_instantiate_cstr__KeyPairType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__UserAclEntryType: + return (void*)soap_instantiate_sai__UserAclEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__AdminAclEntryType: + return (void*)soap_instantiate_sai__AdminAclEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__UserAclEntryHandleListType: + return (void*)soap_instantiate_sai__UserAclEntryHandleListType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__UserAclRealmListType: + return (void*)soap_instantiate_sai__UserAclRealmListType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__RsaKeyType: + return (void*)soap_instantiate_sai__RsaKeyType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__RngKeyType: + return (void*)soap_instantiate_sai__RngKeyType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__CertificateChainType: + return (void*)soap_instantiate_sai__CertificateChainType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__UpdateCoreUrlKeyType: + return (void*)soap_instantiate_sai__UpdateCoreUrlKeyType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__AmtVersion: + return (void*)soap_instantiate_sai__AmtVersion(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__UserEntryDigestType: + return (void*)soap_instantiate_sai__UserEntryDigestType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__UserEntryKerberosType: + return (void*)soap_instantiate_sai__UserEntryKerberosType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__UserAclEntryExType: + return (void*)soap_instantiate_sai__UserAclEntryExType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__AdminAclEntryExType: + return (void*)soap_instantiate_sai__AdminAclEntryExType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__KerberosSpnType: + return (void*)soap_instantiate_sai__KerberosSpnType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__KerberosOptionsType: + return (void*)soap_instantiate_sai__KerberosOptionsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__TlsOptionsType: + return (void*)soap_instantiate_sai__TlsOptionsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__CertificateType: + return (void*)soap_instantiate_sai__CertificateType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__CrlType: + return (void*)soap_instantiate_sai__CrlType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__PkiCapsType: + return (void*)soap_instantiate_sai__PkiCapsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__CertHashEntryType: + return (void*)soap_instantiate_sai__CertHashEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__ProvisioningAuditRecordType: + return (void*)soap_instantiate_sai__ProvisioningAuditRecordType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__EnvironmentDetectionDomainType: + return (void*)soap_instantiate_sai__EnvironmentDetectionDomainType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__EnvironmentDetectionType: + return (void*)soap_instantiate_sai__EnvironmentDetectionType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__GlobalPowerPolicyType: + return (void*)soap_instantiate_sai__GlobalPowerPolicyType(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__AddUserAclEntry: + return (void*)soap_instantiate__sai__AddUserAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__AddUserAclEntryResponse: + return (void*)soap_instantiate__sai__AddUserAclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetAdminAclEntry: + return (void*)soap_instantiate__sai__SetAdminAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetAdminAclEntryResponse: + return (void*)soap_instantiate__sai__SetAdminAclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnumerateUserAclEntries: + return (void*)soap_instantiate__sai__EnumerateUserAclEntries(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnumerateUserAclEntriesResponse: + return (void*)soap_instantiate__sai__EnumerateUserAclEntriesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetUserAclEntry: + return (void*)soap_instantiate__sai__GetUserAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetUserAclEntryResponse: + return (void*)soap_instantiate__sai__GetUserAclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetAdminAclEntry: + return (void*)soap_instantiate__sai__GetAdminAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetAdminAclEntryResponse: + return (void*)soap_instantiate__sai__GetAdminAclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__UpdateUserAclEntry: + return (void*)soap_instantiate__sai__UpdateUserAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__UpdateUserAclEntryResponse: + return (void*)soap_instantiate__sai__UpdateUserAclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__RemoveUserAclEntry: + return (void*)soap_instantiate__sai__RemoveUserAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__RemoveUserAclEntryResponse: + return (void*)soap_instantiate__sai__RemoveUserAclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTlsEnabled: + return (void*)soap_instantiate__sai__SetTlsEnabled(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTlsEnabledResponse: + return (void*)soap_instantiate__sai__SetTlsEnabledResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTLSKeyAndCertificate: + return (void*)soap_instantiate__sai__SetTLSKeyAndCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse: + return (void*)soap_instantiate__sai__SetTLSKeyAndCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetRngKey: + return (void*)soap_instantiate__sai__SetRngKey(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetRngKeyResponse: + return (void*)soap_instantiate__sai__SetRngKeyResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTLSCertificate: + return (void*)soap_instantiate__sai__SetTLSCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTLSCertificateResponse: + return (void*)soap_instantiate__sai__SetTLSCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTLSCertificate: + return (void*)soap_instantiate__sai__GetTLSCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTLSCertificateResponse: + return (void*)soap_instantiate__sai__GetTLSCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__UpdateCoreFromUrl: + return (void*)soap_instantiate__sai__UpdateCoreFromUrl(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__UpdateCoreFromUrlResponse: + return (void*)soap_instantiate__sai__UpdateCoreFromUrlResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetProvisioningMode: + return (void*)soap_instantiate__sai__GetProvisioningMode(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetProvisioningModeResponse: + return (void*)soap_instantiate__sai__GetProvisioningModeResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetProvisioningMode: + return (void*)soap_instantiate__sai__SetProvisioningMode(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetProvisioningModeResponse: + return (void*)soap_instantiate__sai__SetProvisioningModeResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__Unprovision: + return (void*)soap_instantiate__sai__Unprovision(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__UnprovisionResponse: + return (void*)soap_instantiate__sai__UnprovisionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CommitChanges: + return (void*)soap_instantiate__sai__CommitChanges(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CommitChangesResponse: + return (void*)soap_instantiate__sai__CommitChangesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__ResetFlashWearOutProtection: + return (void*)soap_instantiate__sai__ResetFlashWearOutProtection(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse: + return (void*)soap_instantiate__sai__ResetFlashWearOutProtectionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetCoreVersion: + return (void*)soap_instantiate__sai__GetCoreVersion(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetCoreVersionResponse: + return (void*)soap_instantiate__sai__GetCoreVersionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__AddUserAclEntryEx: + return (void*)soap_instantiate__sai__AddUserAclEntryEx(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__AddUserAclEntryExResponse: + return (void*)soap_instantiate__sai__AddUserAclEntryExResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetUserAclEntryEx: + return (void*)soap_instantiate__sai__GetUserAclEntryEx(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetUserAclEntryExResponse: + return (void*)soap_instantiate__sai__GetUserAclEntryExResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__UpdateUserAclEntryEx: + return (void*)soap_instantiate__sai__UpdateUserAclEntryEx(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__UpdateUserAclEntryExResponse: + return (void*)soap_instantiate__sai__UpdateUserAclEntryExResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetAdminAclEntryEx: + return (void*)soap_instantiate__sai__SetAdminAclEntryEx(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetAdminAclEntryExResponse: + return (void*)soap_instantiate__sai__SetAdminAclEntryExResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetDigestRealm: + return (void*)soap_instantiate__sai__GetDigestRealm(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetDigestRealmResponse: + return (void*)soap_instantiate__sai__GetDigestRealmResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetKerberosOptions: + return (void*)soap_instantiate__sai__SetKerberosOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetKerberosOptionsResponse: + return (void*)soap_instantiate__sai__SetKerberosOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetKerberosOptions: + return (void*)soap_instantiate__sai__GetKerberosOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetKerberosOptionsResponse: + return (void*)soap_instantiate__sai__GetKerberosOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetEnabledInterfaces: + return (void*)soap_instantiate__sai__SetEnabledInterfaces(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetEnabledInterfacesResponse: + return (void*)soap_instantiate__sai__SetEnabledInterfacesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetEnabledInterfaces: + return (void*)soap_instantiate__sai__GetEnabledInterfaces(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetEnabledInterfacesResponse: + return (void*)soap_instantiate__sai__GetEnabledInterfacesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTlsOptions: + return (void*)soap_instantiate__sai__SetTlsOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTlsOptionsResponse: + return (void*)soap_instantiate__sai__SetTlsOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTlsOptions: + return (void*)soap_instantiate__sai__GetTlsOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTlsOptionsResponse: + return (void*)soap_instantiate__sai__GetTlsOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__AddTrustedRootCertificate: + return (void*)soap_instantiate__sai__AddTrustedRootCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__AddTrustedRootCertificateResponse: + return (void*)soap_instantiate__sai__AddTrustedRootCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTrustedRootCertificate: + return (void*)soap_instantiate__sai__GetTrustedRootCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTrustedRootCertificateResponse: + return (void*)soap_instantiate__sai__GetTrustedRootCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__DeleteTrustedRootCertificate: + return (void*)soap_instantiate__sai__DeleteTrustedRootCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse: + return (void*)soap_instantiate__sai__DeleteTrustedRootCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnumerateTrustedRootCertificates: + return (void*)soap_instantiate__sai__EnumerateTrustedRootCertificates(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse: + return (void*)soap_instantiate__sai__EnumerateTrustedRootCertificatesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTrustedFqdnCN: + return (void*)soap_instantiate__sai__SetTrustedFqdnCN(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTrustedFqdnCNResponse: + return (void*)soap_instantiate__sai__SetTrustedFqdnCNResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTrustedFqdnCN: + return (void*)soap_instantiate__sai__GetTrustedFqdnCN(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTrustedFqdnCNResponse: + return (void*)soap_instantiate__sai__GetTrustedFqdnCNResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetCRL: + return (void*)soap_instantiate__sai__SetCRL(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetCRLResponse: + return (void*)soap_instantiate__sai__SetCRLResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetCRL: + return (void*)soap_instantiate__sai__GetCRL(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetCRLResponse: + return (void*)soap_instantiate__sai__GetCRLResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetServerCertificateReq: + return (void*)soap_instantiate__sai__GetServerCertificateReq(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetServerCertificateReqResponse: + return (void*)soap_instantiate__sai__GetServerCertificateReqResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetPkiCapabilities: + return (void*)soap_instantiate__sai__GetPkiCapabilities(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetPkiCapabilitiesResponse: + return (void*)soap_instantiate__sai__GetPkiCapabilitiesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetPowerSavingOptions: + return (void*)soap_instantiate__sai__SetPowerSavingOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetPowerSavingOptionsResponse: + return (void*)soap_instantiate__sai__SetPowerSavingOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetPowerSavingOptions: + return (void*)soap_instantiate__sai__GetPowerSavingOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetPowerSavingOptionsResponse: + return (void*)soap_instantiate__sai__GetPowerSavingOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTLSPSK: + return (void*)soap_instantiate__sai__SetTLSPSK(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTLSPSKResponse: + return (void*)soap_instantiate__sai__SetTLSPSKResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__PartialUnprovision: + return (void*)soap_instantiate__sai__PartialUnprovision(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__PartialUnprovisionResponse: + return (void*)soap_instantiate__sai__PartialUnprovisionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetMEBxPassword: + return (void*)soap_instantiate__sai__SetMEBxPassword(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetMEBxPasswordResponse: + return (void*)soap_instantiate__sai__SetMEBxPasswordResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetProvisioningServerOTP: + return (void*)soap_instantiate__sai__SetProvisioningServerOTP(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetProvisioningServerOTPResponse: + return (void*)soap_instantiate__sai__SetProvisioningServerOTPResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetProvisioningServerOTP: + return (void*)soap_instantiate__sai__GetProvisioningServerOTP(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetProvisioningServerOTPResponse: + return (void*)soap_instantiate__sai__GetProvisioningServerOTPResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnumerateCertificateHashEntries: + return (void*)soap_instantiate__sai__EnumerateCertificateHashEntries(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse: + return (void*)soap_instantiate__sai__EnumerateCertificateHashEntriesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetCertificateHashEntry: + return (void*)soap_instantiate__sai__GetCertificateHashEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetCertificateHashEntryResponse: + return (void*)soap_instantiate__sai__GetCertificateHashEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__AddCertificateHashEntry: + return (void*)soap_instantiate__sai__AddCertificateHashEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__AddCertificateHashEntryResponse: + return (void*)soap_instantiate__sai__AddCertificateHashEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__DeleteCertificateHashEntry: + return (void*)soap_instantiate__sai__DeleteCertificateHashEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__DeleteCertificateHashEntryResponse: + return (void*)soap_instantiate__sai__DeleteCertificateHashEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnableCertificateHashEntry: + return (void*)soap_instantiate__sai__EnableCertificateHashEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnableCertificateHashEntryResponse: + return (void*)soap_instantiate__sai__EnableCertificateHashEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetZeroTouchConfigurationMode: + return (void*)soap_instantiate__sai__GetZeroTouchConfigurationMode(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse: + return (void*)soap_instantiate__sai__GetZeroTouchConfigurationModeResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetZeroTouchConfigurationMode: + return (void*)soap_instantiate__sai__SetZeroTouchConfigurationMode(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse: + return (void*)soap_instantiate__sai__SetZeroTouchConfigurationModeResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetProvisioningAuditRecord: + return (void*)soap_instantiate__sai__GetProvisioningAuditRecord(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetProvisioningAuditRecordResponse: + return (void*)soap_instantiate__sai__GetProvisioningAuditRecordResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetProvisioningPID: + return (void*)soap_instantiate__sai__GetProvisioningPID(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetProvisioningPIDResponse: + return (void*)soap_instantiate__sai__GetProvisioningPIDResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__ExtendProvisioningPeriod: + return (void*)soap_instantiate__sai__ExtendProvisioningPeriod(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__ExtendProvisioningPeriodResponse: + return (void*)soap_instantiate__sai__ExtendProvisioningPeriodResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetRealmAuthOptions: + return (void*)soap_instantiate__sai__GetRealmAuthOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetRealmAuthOptionsResponse: + return (void*)soap_instantiate__sai__GetRealmAuthOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetRealmAuthOptions: + return (void*)soap_instantiate__sai__SetRealmAuthOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetRealmAuthOptionsResponse: + return (void*)soap_instantiate__sai__SetRealmAuthOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetEnvironmentDetection: + return (void*)soap_instantiate__sai__SetEnvironmentDetection(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetEnvironmentDetectionResponse: + return (void*)soap_instantiate__sai__SetEnvironmentDetectionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetEnvironmentDetection: + return (void*)soap_instantiate__sai__GetEnvironmentDetection(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetEnvironmentDetectionResponse: + return (void*)soap_instantiate__sai__GetEnvironmentDetectionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnumeratePowerPackages: + return (void*)soap_instantiate__sai__EnumeratePowerPackages(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnumeratePowerPackagesResponse: + return (void*)soap_instantiate__sai__EnumeratePowerPackagesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetActivePowerPackage: + return (void*)soap_instantiate__sai__GetActivePowerPackage(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetActivePowerPackageResponse: + return (void*)soap_instantiate__sai__GetActivePowerPackageResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetPowerPackage: + return (void*)soap_instantiate__sai__GetPowerPackage(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetPowerPackageResponse: + return (void*)soap_instantiate__sai__GetPowerPackageResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetActivePowerPackage: + return (void*)soap_instantiate__sai__SetActivePowerPackage(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetActivePowerPackageResponse: + return (void*)soap_instantiate__sai__SetActivePowerPackageResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetGlobalPowerPolicy: + return (void*)soap_instantiate__sai__SetGlobalPowerPolicy(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetGlobalPowerPolicyResponse: + return (void*)soap_instantiate__sai__SetGlobalPowerPolicyResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetGlobalPowerPolicy: + return (void*)soap_instantiate__sai__GetGlobalPowerPolicy(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetGlobalPowerPolicyResponse: + return (void*)soap_instantiate__sai__GetGlobalPowerPolicyResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreAddKey: + return (void*)soap_instantiate__sai__CertStoreAddKey(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreAddKeyResponse: + return (void*)soap_instantiate__sai__CertStoreAddKeyResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreEnumerateKeys: + return (void*)soap_instantiate__sai__CertStoreEnumerateKeys(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreEnumerateKeysResponse: + return (void*)soap_instantiate__sai__CertStoreEnumerateKeysResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreGetKey: + return (void*)soap_instantiate__sai__CertStoreGetKey(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreGetKeyResponse: + return (void*)soap_instantiate__sai__CertStoreGetKeyResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreRemoveKey: + return (void*)soap_instantiate__sai__CertStoreRemoveKey(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreRemoveKeyResponse: + return (void*)soap_instantiate__sai__CertStoreRemoveKeyResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreAddCertificate: + return (void*)soap_instantiate__sai__CertStoreAddCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreAddCertificateResponse: + return (void*)soap_instantiate__sai__CertStoreAddCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreEnumerateCertificates: + return (void*)soap_instantiate__sai__CertStoreEnumerateCertificates(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse: + return (void*)soap_instantiate__sai__CertStoreEnumerateCertificatesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreGetCertificate: + return (void*)soap_instantiate__sai__CertStoreGetCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreGetCertificateResponse: + return (void*)soap_instantiate__sai__CertStoreGetCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreRemoveCertificate: + return (void*)soap_instantiate__sai__CertStoreRemoveCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreRemoveCertificateResponse: + return (void*)soap_instantiate__sai__CertStoreRemoveCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreGetPKCS10Request: + return (void*)soap_instantiate__sai__CertStoreGetPKCS10Request(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse: + return (void*)soap_instantiate__sai__CertStoreGetPKCS10RequestResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreUpdateCertificate: + return (void*)soap_instantiate__sai__CertStoreUpdateCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__CertStoreUpdateCertificateResponse: + return (void*)soap_instantiate__sai__CertStoreUpdateCertificateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTLSCredentials: + return (void*)soap_instantiate__sai__SetTLSCredentials(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetTLSCredentialsResponse: + return (void*)soap_instantiate__sai__SetTLSCredentialsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTLSCredentials: + return (void*)soap_instantiate__sai__GetTLSCredentials(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetTLSCredentialsResponse: + return (void*)soap_instantiate__sai__GetTLSCredentialsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnableVpnRouting: + return (void*)soap_instantiate__sai__EnableVpnRouting(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__EnableVpnRoutingResponse: + return (void*)soap_instantiate__sai__EnableVpnRoutingResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetConfigurationServerFQDN: + return (void*)soap_instantiate__sai__SetConfigurationServerFQDN(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetConfigurationServerFQDNResponse: + return (void*)soap_instantiate__sai__SetConfigurationServerFQDNResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetConfigurationServerFQDN: + return (void*)soap_instantiate__sai__GetConfigurationServerFQDN(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetConfigurationServerFQDNResponse: + return (void*)soap_instantiate__sai__GetConfigurationServerFQDNResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetAclEnabledState: + return (void*)soap_instantiate__sai__SetAclEnabledState(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SetAclEnabledStateResponse: + return (void*)soap_instantiate__sai__SetAclEnabledStateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetAclEnabledState: + return (void*)soap_instantiate__sai__GetAclEnabledState(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__GetAclEnabledStateResponse: + return (void*)soap_instantiate__sai__GetAclEnabledStateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__UserCredentialsType: + return (void*)soap_instantiate_xcfg__UserCredentialsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__CertificateNameType: + return (void*)soap_instantiate_xcfg__CertificateNameType(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__ManualPACType: + return (void*)soap_instantiate_xcfg__ManualPACType(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__ServerIdentityType: + return (void*)soap_instantiate_xcfg__ServerIdentityType(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__XProfileTLSType: + return (void*)soap_instantiate_xcfg__XProfileTLSType(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type: + return (void*)soap_instantiate_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type: + return (void*)soap_instantiate_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType: + return (void*)soap_instantiate_xcfg__XProfileEAP_USCOREGTCType(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type: + return (void*)soap_instantiate_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType: + return (void*)soap_instantiate_xcfg__XProfileEAPFAST_USCOREGTCType(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType: + return (void*)soap_instantiate_xcfg__XProfileEAPFAST_USCORETLSType(soap, -1, type, arrayType, n); + case SOAP_TYPE_xcfg__XProfileType: + return (void*)soap_instantiate_xcfg__XProfileType(soap, -1, type, arrayType, n); + case SOAP_TYPE_net__StaticIPv4ParametersType: + return (void*)soap_instantiate_net__StaticIPv4ParametersType(soap, -1, type, arrayType, n); + case SOAP_TYPE_net__IPv4ParametersType: + return (void*)soap_instantiate_net__IPv4ParametersType(soap, -1, type, arrayType, n); + case SOAP_TYPE_net__InterfaceDescriptorSetType: + return (void*)soap_instantiate_net__InterfaceDescriptorSetType(soap, -1, type, arrayType, n); + case SOAP_TYPE_net__InterfaceDescriptorGetType: + return (void*)soap_instantiate_net__InterfaceDescriptorGetType(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetHostName: + return (void*)soap_instantiate__net__SetHostName(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetHostNameResponse: + return (void*)soap_instantiate__net__SetHostNameResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetHostName: + return (void*)soap_instantiate__net__GetHostName(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetHostNameResponse: + return (void*)soap_instantiate__net__GetHostNameResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetDomainName: + return (void*)soap_instantiate__net__SetDomainName(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetDomainNameResponse: + return (void*)soap_instantiate__net__SetDomainNameResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetDomainName: + return (void*)soap_instantiate__net__GetDomainName(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetDomainNameResponse: + return (void*)soap_instantiate__net__GetDomainNameResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetTcpIpParameters: + return (void*)soap_instantiate__net__SetTcpIpParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetTcpIpParametersResponse: + return (void*)soap_instantiate__net__SetTcpIpParametersResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetTcpIpParameters: + return (void*)soap_instantiate__net__GetTcpIpParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetTcpIpParametersResponse: + return (void*)soap_instantiate__net__GetTcpIpParametersResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetVlanParameters: + return (void*)soap_instantiate__net__SetVlanParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetVlanParametersResponse: + return (void*)soap_instantiate__net__SetVlanParametersResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetVlanParameters: + return (void*)soap_instantiate__net__GetVlanParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetVlanParametersResponse: + return (void*)soap_instantiate__net__GetVlanParametersResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetPingResponse: + return (void*)soap_instantiate__net__SetPingResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetPingResponseResponse: + return (void*)soap_instantiate__net__SetPingResponseResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetPingResponse: + return (void*)soap_instantiate__net__GetPingResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetPingResponseResponse: + return (void*)soap_instantiate__net__GetPingResponseResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__EnumerateInterfaces: + return (void*)soap_instantiate__net__EnumerateInterfaces(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__EnumerateInterfacesResponse: + return (void*)soap_instantiate__net__EnumerateInterfacesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetInterfaceSettings: + return (void*)soap_instantiate__net__GetInterfaceSettings(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__GetInterfaceSettingsResponse: + return (void*)soap_instantiate__net__GetInterfaceSettingsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetInterfaceSettings: + return (void*)soap_instantiate__net__SetInterfaceSettings(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__SetInterfaceSettingsResponse: + return (void*)soap_instantiate__net__SetInterfaceSettingsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Get8021XWiredProfile: + return (void*)soap_instantiate__net__Get8021XWiredProfile(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Get8021XWiredProfileResponse: + return (void*)soap_instantiate__net__Get8021XWiredProfileResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Set8021XWiredProfile: + return (void*)soap_instantiate__net__Set8021XWiredProfile(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Set8021XWiredProfileResponse: + return (void*)soap_instantiate__net__Set8021XWiredProfileResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Set8021XActiveS0: + return (void*)soap_instantiate__net__Set8021XActiveS0(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Set8021XActiveS0Response: + return (void*)soap_instantiate__net__Set8021XActiveS0Response(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Get8021XActiveS0: + return (void*)soap_instantiate__net__Get8021XActiveS0(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Get8021XActiveS0Response: + return (void*)soap_instantiate__net__Get8021XActiveS0Response(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Set8021XPxeTimeout: + return (void*)soap_instantiate__net__Set8021XPxeTimeout(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Set8021XPxeTimeoutResponse: + return (void*)soap_instantiate__net__Set8021XPxeTimeoutResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Get8021XPxeTimeout: + return (void*)soap_instantiate__net__Get8021XPxeTimeout(soap, -1, type, arrayType, n); + case SOAP_TYPE__net__Get8021XPxeTimeoutResponse: + return (void*)soap_instantiate__net__Get8021XPxeTimeoutResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__StorageEaclEntryType: + return (void*)soap_instantiate_stra__StorageEaclEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__StorageEaclEntryHandleListType: + return (void*)soap_instantiate_stra__StorageEaclEntryHandleListType(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__StorageAllocEntryType: + return (void*)soap_instantiate_stra__StorageAllocEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__StorageAllocSnrpEntryType: + return (void*)soap_instantiate_stra__StorageAllocSnrpEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__StorageAllocEntryHandleListType: + return (void*)soap_instantiate_stra__StorageAllocEntryHandleListType(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__GUID: + return (void*)soap_instantiate_stra__GUID(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__GlobalStorageAttributesType: + return (void*)soap_instantiate_stra__GlobalStorageAttributesType(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__StorageApplicationHandleListType: + return (void*)soap_instantiate_stra__StorageApplicationHandleListType(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__StorageSnrpApplicationAttributeType: + return (void*)soap_instantiate_stra__StorageSnrpApplicationAttributeType(soap, -1, type, arrayType, n); + case SOAP_TYPE_stra__StorageApplicationAttributesType: + return (void*)soap_instantiate_stra__StorageApplicationAttributesType(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__GetGlobalStorageAttributes: + return (void*)soap_instantiate__stra__GetGlobalStorageAttributes(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__GetGlobalStorageAttributesResponse: + return (void*)soap_instantiate__stra__GetGlobalStorageAttributesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__SetGlobalStorageAttributes: + return (void*)soap_instantiate__stra__SetGlobalStorageAttributes(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__SetGlobalStorageAttributesResponse: + return (void*)soap_instantiate__stra__SetGlobalStorageAttributesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AdminGetRegisteredApplications: + return (void*)soap_instantiate__stra__AdminGetRegisteredApplications(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse: + return (void*)soap_instantiate__stra__AdminGetRegisteredApplicationsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AdminGetApplicationAttributes: + return (void*)soap_instantiate__stra__AdminGetApplicationAttributes(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AdminGetApplicationAttributesResponse: + return (void*)soap_instantiate__stra__AdminGetApplicationAttributesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AdminRemoveApplication: + return (void*)soap_instantiate__stra__AdminRemoveApplication(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AdminRemoveApplicationResponse: + return (void*)soap_instantiate__stra__AdminRemoveApplicationResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AddStorageEaclEntry: + return (void*)soap_instantiate__stra__AddStorageEaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AddStorageEaclEntryResponse: + return (void*)soap_instantiate__stra__AddStorageEaclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__EnumerateStorageEaclEntries: + return (void*)soap_instantiate__stra__EnumerateStorageEaclEntries(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse: + return (void*)soap_instantiate__stra__EnumerateStorageEaclEntriesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__GetStorageEaclEntry: + return (void*)soap_instantiate__stra__GetStorageEaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__GetStorageEaclEntryResponse: + return (void*)soap_instantiate__stra__GetStorageEaclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__RemoveStorageEaclEntry: + return (void*)soap_instantiate__stra__RemoveStorageEaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__RemoveStorageEaclEntryResponse: + return (void*)soap_instantiate__stra__RemoveStorageEaclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AddStorageFpaclEntry: + return (void*)soap_instantiate__stra__AddStorageFpaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__AddStorageFpaclEntryResponse: + return (void*)soap_instantiate__stra__AddStorageFpaclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__EnumerateStorageAllocEntries: + return (void*)soap_instantiate__stra__EnumerateStorageAllocEntries(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse: + return (void*)soap_instantiate__stra__EnumerateStorageAllocEntriesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__GetStorageAllocEntry: + return (void*)soap_instantiate__stra__GetStorageAllocEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__GetStorageAllocEntryResponse: + return (void*)soap_instantiate__stra__GetStorageAllocEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__UpdateStorageFpaclEntry: + return (void*)soap_instantiate__stra__UpdateStorageFpaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse: + return (void*)soap_instantiate__stra__UpdateStorageFpaclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__RemoveStorageFpaclEntry: + return (void*)soap_instantiate__stra__RemoveStorageFpaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse: + return (void*)soap_instantiate__stra__RemoveStorageFpaclEntryResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType: + return (void*)soap_instantiate_emi__AlertSubscriptionPolicyIDArrayType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__ByteData: + return (void*)soap_instantiate_emi__ByteData(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__EventLogRecordType: + return (void*)soap_instantiate_emi__EventLogRecordType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__EventFilterType: + return (void*)soap_instantiate_emi__EventFilterType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__AlertSubscriptionType: + return (void*)soap_instantiate_emi__AlertSubscriptionType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__AlertSubscriptionHandleArrayType: + return (void*)soap_instantiate_emi__AlertSubscriptionHandleArrayType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__EventFilterHandleArrayType: + return (void*)soap_instantiate_emi__EventFilterHandleArrayType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__EventLogRecordArrayType: + return (void*)soap_instantiate_emi__EventLogRecordArrayType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__SensorHandleArrayType: + return (void*)soap_instantiate_emi__SensorHandleArrayType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__SensorAttributesType: + return (void*)soap_instantiate_emi__SensorAttributesType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__ByteStr: + return (void*)soap_instantiate_emi__ByteStr(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__AlertCredentialsType: + return (void*)soap_instantiate_emi__AlertCredentialsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__AlertSubscriptionSNMPType: + return (void*)soap_instantiate_emi__AlertSubscriptionSNMPType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__AlertSubscriptionSoapType: + return (void*)soap_instantiate_emi__AlertSubscriptionSoapType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__AlertSubscriptionGeneralType: + return (void*)soap_instantiate_emi__AlertSubscriptionGeneralType(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__SubscribeForAlert: + return (void*)soap_instantiate__emi__SubscribeForAlert(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__SubscribeForAlertResponse: + return (void*)soap_instantiate__emi__SubscribeForAlertResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateAlertSubscriptions: + return (void*)soap_instantiate__emi__EnumerateAlertSubscriptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse: + return (void*)soap_instantiate__emi__EnumerateAlertSubscriptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetAlertSubscription: + return (void*)soap_instantiate__emi__GetAlertSubscription(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetAlertSubscriptionResponse: + return (void*)soap_instantiate__emi__GetAlertSubscriptionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateAlertPolicies: + return (void*)soap_instantiate__emi__EnumerateAlertPolicies(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateAlertPoliciesResponse: + return (void*)soap_instantiate__emi__EnumerateAlertPoliciesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__SetAlertCommunityString: + return (void*)soap_instantiate__emi__SetAlertCommunityString(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__SetAlertCommunityStringResponse: + return (void*)soap_instantiate__emi__SetAlertCommunityStringResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetAlertCommunityString: + return (void*)soap_instantiate__emi__GetAlertCommunityString(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetAlertCommunityStringResponse: + return (void*)soap_instantiate__emi__GetAlertCommunityStringResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__AddEventFilter: + return (void*)soap_instantiate__emi__AddEventFilter(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__AddEventFilterResponse: + return (void*)soap_instantiate__emi__AddEventFilterResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateEventFilters: + return (void*)soap_instantiate__emi__EnumerateEventFilters(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateEventFiltersResponse: + return (void*)soap_instantiate__emi__EnumerateEventFiltersResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetEventFilter: + return (void*)soap_instantiate__emi__GetEventFilter(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetEventFilterResponse: + return (void*)soap_instantiate__emi__GetEventFilterResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__UpdateEventFilter: + return (void*)soap_instantiate__emi__UpdateEventFilter(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__UpdateEventFilterResponse: + return (void*)soap_instantiate__emi__UpdateEventFilterResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__RemoveEventFilter: + return (void*)soap_instantiate__emi__RemoveEventFilter(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__RemoveEventFilterResponse: + return (void*)soap_instantiate__emi__RemoveEventFilterResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__ReadEventLogRecords: + return (void*)soap_instantiate__emi__ReadEventLogRecords(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__ReadEventLogRecordsResponse: + return (void*)soap_instantiate__emi__ReadEventLogRecordsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetEventLogStatus: + return (void*)soap_instantiate__emi__GetEventLogStatus(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetEventLogStatusResponse: + return (void*)soap_instantiate__emi__GetEventLogStatusResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__ClearEventLog: + return (void*)soap_instantiate__emi__ClearEventLog(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__ClearEventLogResponse: + return (void*)soap_instantiate__emi__ClearEventLogResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__FreezeEventLog: + return (void*)soap_instantiate__emi__FreezeEventLog(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__FreezeEventLogResponse: + return (void*)soap_instantiate__emi__FreezeEventLogResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__SetEventLogTimestampClock: + return (void*)soap_instantiate__emi__SetEventLogTimestampClock(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__SetEventLogTimestampClockResponse: + return (void*)soap_instantiate__emi__SetEventLogTimestampClockResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetEventLogTimestampClock: + return (void*)soap_instantiate__emi__GetEventLogTimestampClock(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetEventLogTimestampClockResponse: + return (void*)soap_instantiate__emi__GetEventLogTimestampClockResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateSensors: + return (void*)soap_instantiate__emi__EnumerateSensors(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateSensorsResponse: + return (void*)soap_instantiate__emi__EnumerateSensorsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetSensorAttributes: + return (void*)soap_instantiate__emi__GetSensorAttributes(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetSensorAttributesResponse: + return (void*)soap_instantiate__emi__GetSensorAttributesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__CancelAlertSubscription: + return (void*)soap_instantiate__emi__CancelAlertSubscription(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__CancelAlertSubscriptionResponse: + return (void*)soap_instantiate__emi__CancelAlertSubscriptionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__SubscribeForGeneralAlert: + return (void*)soap_instantiate__emi__SubscribeForGeneralAlert(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__SubscribeForGeneralAlertResponse: + return (void*)soap_instantiate__emi__SubscribeForGeneralAlertResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions: + return (void*)soap_instantiate__emi__EnumerateGeneralAlertSubscriptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse: + return (void*)soap_instantiate__emi__EnumerateGeneralAlertSubscriptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetGeneralAlertSubscription: + return (void*)soap_instantiate__emi__GetGeneralAlertSubscription(soap, -1, type, arrayType, n); + case SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse: + return (void*)soap_instantiate__emi__GetGeneralAlertSubscriptionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType: + return (void*)soap_instantiate_cb__CircuitBreakerAntiSpoofingFilterType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerPolicyType: + return (void*)soap_instantiate_cb__CircuitBreakerPolicyType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerPolicyInfoType: + return (void*)soap_instantiate_cb__CircuitBreakerPolicyInfoType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType: + return (void*)soap_instantiate_cb__CircuitBreakerIPv4AddressAndMaskType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType: + return (void*)soap_instantiate_cb__CircuitBreakerIPv6AddressAndMaskType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType: + return (void*)soap_instantiate_cb__CircuitBreakerIPLayeredPortSimpleType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType: + return (void*)soap_instantiate_cb__CircuitBreakerIPLayeredPortRangeType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType: + return (void*)soap_instantiate_cb__CircuitBreakerIPLayeredPortType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType: + return (void*)soap_instantiate_cb__CircuitBreakerIPLayeredTCPFlagsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerIPv4Type: + return (void*)soap_instantiate_cb__CircuitBreakerIPv4Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerIPv6Type: + return (void*)soap_instantiate_cb__CircuitBreakerIPv6Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerIPPacketType: + return (void*)soap_instantiate_cb__CircuitBreakerIPPacketType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerPacketUDPType: + return (void*)soap_instantiate_cb__CircuitBreakerPacketUDPType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerPacketIPType: + return (void*)soap_instantiate_cb__CircuitBreakerPacketIPType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerPacketETHType: + return (void*)soap_instantiate_cb__CircuitBreakerPacketETHType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerPacketType: + return (void*)soap_instantiate_cb__CircuitBreakerPacketType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerFilterType: + return (void*)soap_instantiate_cb__CircuitBreakerFilterType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerFilterInfoType: + return (void*)soap_instantiate_cb__CircuitBreakerFilterInfoType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerCapabilitiesType: + return (void*)soap_instantiate_cb__CircuitBreakerCapabilitiesType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType: + return (void*)soap_instantiate_cb__CircuitBreakerFilterStatisticsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType: + return (void*)soap_instantiate_cb__CircuitBreakerHardwarePolicyType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__TimedCounterType: + return (void*)soap_instantiate_cb__TimedCounterType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__BlockedPortInfoType: + return (void*)soap_instantiate_cb__BlockedPortInfoType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__HcbOptionsType: + return (void*)soap_instantiate_cb__HcbOptionsType(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyCreate: + return (void*)soap_instantiate__cb__CbPolicyCreate(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyCreateResponse: + return (void*)soap_instantiate__cb__CbPolicyCreateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyGet: + return (void*)soap_instantiate__cb__CbPolicyGet(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyGetResponse: + return (void*)soap_instantiate__cb__CbPolicyGetResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyDelete: + return (void*)soap_instantiate__cb__CbPolicyDelete(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyDeleteResponse: + return (void*)soap_instantiate__cb__CbPolicyDeleteResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyEnumerate: + return (void*)soap_instantiate__cb__CbPolicyEnumerate(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyEnumerateResponse: + return (void*)soap_instantiate__cb__CbPolicyEnumerateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyEnable: + return (void*)soap_instantiate__cb__CbPolicyEnable(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyEnableResponse: + return (void*)soap_instantiate__cb__CbPolicyEnableResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyDisable: + return (void*)soap_instantiate__cb__CbPolicyDisable(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyDisableResponse: + return (void*)soap_instantiate__cb__CbPolicyDisableResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyGetEnabled: + return (void*)soap_instantiate__cb__CbPolicyGetEnabled(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyGetEnabledResponse: + return (void*)soap_instantiate__cb__CbPolicyGetEnabledResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyGetActiveStatistics: + return (void*)soap_instantiate__cb__CbPolicyGetActiveStatistics(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse: + return (void*)soap_instantiate__cb__CbPolicyGetActiveStatisticsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbFilterCreate: + return (void*)soap_instantiate__cb__CbFilterCreate(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbFilterCreateResponse: + return (void*)soap_instantiate__cb__CbFilterCreateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbFilterGet: + return (void*)soap_instantiate__cb__CbFilterGet(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbFilterGetResponse: + return (void*)soap_instantiate__cb__CbFilterGetResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbFilterDelete: + return (void*)soap_instantiate__cb__CbFilterDelete(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbFilterDeleteResponse: + return (void*)soap_instantiate__cb__CbFilterDeleteResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbFilterEnumerate: + return (void*)soap_instantiate__cb__CbFilterEnumerate(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbFilterEnumerateResponse: + return (void*)soap_instantiate__cb__CbFilterEnumerateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbQueryCapabilities: + return (void*)soap_instantiate__cb__CbQueryCapabilities(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__CbQueryCapabilitiesResponse: + return (void*)soap_instantiate__cb__CbQueryCapabilitiesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__SetHcbOptions: + return (void*)soap_instantiate__cb__SetHcbOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__SetHcbOptionsResponse: + return (void*)soap_instantiate__cb__SetHcbOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__GetHcbOptions: + return (void*)soap_instantiate__cb__GetHcbOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__GetHcbOptionsResponse: + return (void*)soap_instantiate__cb__GetHcbOptionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__ClearHcbState: + return (void*)soap_instantiate__cb__ClearHcbState(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__ClearHcbStateResponse: + return (void*)soap_instantiate__cb__ClearHcbStateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__GetHcbState: + return (void*)soap_instantiate__cb__GetHcbState(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__GetHcbStateResponse: + return (void*)soap_instantiate__cb__GetHcbStateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__AssetTypeArrayType: + return (void*)soap_instantiate_hwa__AssetTypeArrayType(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__AssetDataArrayType: + return (void*)soap_instantiate_hwa__AssetDataArrayType(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__AssetDataType: + return (void*)soap_instantiate_hwa__AssetDataType(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__PT_USCOREBIOS: + return (void*)soap_instantiate_hwa__PT_USCOREBIOS(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM: + return (void*)soap_instantiate_hwa__PT_USCORECOMPUTER_USCORESYSTEM(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__GUID: + return (void*)soap_instantiate_hwa__GUID(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__PT_USCOREBASEBOARD: + return (void*)soap_instantiate_hwa__PT_USCOREBASEBOARD(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR: + return (void*)soap_instantiate_hwa__PT_USCOREPROCESSOR(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE: + return (void*)soap_instantiate_hwa__PT_USCOREMEMORY_USCOREMODULE(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__PT_USCOREFRU: + return (void*)soap_instantiate_hwa__PT_USCOREFRU(soap, -1, type, arrayType, n); + case SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE: + return (void*)soap_instantiate_hwa__PT_USCOREMEDIA_USCOREDEVICE(soap, -1, type, arrayType, n); + case SOAP_TYPE__hwa__EnumerateAssetTypes: + return (void*)soap_instantiate__hwa__EnumerateAssetTypes(soap, -1, type, arrayType, n); + case SOAP_TYPE__hwa__EnumerateAssetTypesResponse: + return (void*)soap_instantiate__hwa__EnumerateAssetTypesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__hwa__GetAssetData: + return (void*)soap_instantiate__hwa__GetAssetData(soap, -1, type, arrayType, n); + case SOAP_TYPE__hwa__GetAssetDataResponse: + return (void*)soap_instantiate__hwa__GetAssetDataResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_apr__GUID: + return (void*)soap_instantiate_apr__GUID(soap, -1, type, arrayType, n); + case SOAP_TYPE_apr__ConsoleWatchdogEntryType: + return (void*)soap_instantiate_apr__ConsoleWatchdogEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_apr__ConsoleWatchdogActionType: + return (void*)soap_instantiate_apr__ConsoleWatchdogActionType(soap, -1, type, arrayType, n); + case SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType: + return (void*)soap_instantiate_apr__CircuitBreakerHardwarePolicyType(soap, -1, type, arrayType, n); + case SOAP_TYPE_apr__AgentPresenceCapabilitiesType: + return (void*)soap_instantiate_apr__AgentPresenceCapabilitiesType(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogCreate: + return (void*)soap_instantiate__apr__ConsoleWatchdogCreate(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogCreateResponse: + return (void*)soap_instantiate__apr__ConsoleWatchdogCreateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogDelete: + return (void*)soap_instantiate__apr__ConsoleWatchdogDelete(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse: + return (void*)soap_instantiate__apr__ConsoleWatchdogDeleteResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogEnumerate: + return (void*)soap_instantiate__apr__ConsoleWatchdogEnumerate(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse: + return (void*)soap_instantiate__apr__ConsoleWatchdogEnumerateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogSetActions: + return (void*)soap_instantiate__apr__ConsoleWatchdogSetActions(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse: + return (void*)soap_instantiate__apr__ConsoleWatchdogSetActionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogGetActions: + return (void*)soap_instantiate__apr__ConsoleWatchdogGetActions(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse: + return (void*)soap_instantiate__apr__ConsoleWatchdogGetActionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy: + return (void*)soap_instantiate__apr__ConsoleWatchdogSetCbPolicy(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse: + return (void*)soap_instantiate__apr__ConsoleWatchdogSetCbPolicyResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy: + return (void*)soap_instantiate__apr__ConsoleWatchdogGetCbPolicy(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse: + return (void*)soap_instantiate__apr__ConsoleWatchdogGetCbPolicyResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities: + return (void*)soap_instantiate__apr__ConsoleWatchdogQueryCapabilities(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse: + return (void*)soap_instantiate__apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_apl__GUID: + return (void*)soap_instantiate_apl__GUID(soap, -1, type, arrayType, n); + case SOAP_TYPE__apl__AgentWatchdogRegister: + return (void*)soap_instantiate__apl__AgentWatchdogRegister(soap, -1, type, arrayType, n); + case SOAP_TYPE__apl__AgentWatchdogRegisterResponse: + return (void*)soap_instantiate__apl__AgentWatchdogRegisterResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__apl__AgentWatchdogHeartbeat: + return (void*)soap_instantiate__apl__AgentWatchdogHeartbeat(soap, -1, type, arrayType, n); + case SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse: + return (void*)soap_instantiate__apl__AgentWatchdogHeartbeatResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__apl__AgentWatchdogShutdown: + return (void*)soap_instantiate__apl__AgentWatchdogShutdown(soap, -1, type, arrayType, n); + case SOAP_TYPE__apl__AgentWatchdogShutdownResponse: + return (void*)soap_instantiate__apl__AgentWatchdogShutdownResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_idr__IderSessionLogEntryType: + return (void*)soap_instantiate_idr__IderSessionLogEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_idr__FirmwareVersionType: + return (void*)soap_instantiate_idr__FirmwareVersionType(soap, -1, type, arrayType, n); + case SOAP_TYPE__idr__SetRedirectionListenerState: + return (void*)soap_instantiate__idr__SetRedirectionListenerState(soap, -1, type, arrayType, n); + case SOAP_TYPE__idr__SetRedirectionListenerStateResponse: + return (void*)soap_instantiate__idr__SetRedirectionListenerStateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__idr__GetRedirectionListenerState: + return (void*)soap_instantiate__idr__GetRedirectionListenerState(soap, -1, type, arrayType, n); + case SOAP_TYPE__idr__GetRedirectionListenerStateResponse: + return (void*)soap_instantiate__idr__GetRedirectionListenerStateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__idr__GetIderSessionLog: + return (void*)soap_instantiate__idr__GetIderSessionLog(soap, -1, type, arrayType, n); + case SOAP_TYPE__idr__GetIderSessionLogResponse: + return (void*)soap_instantiate__idr__GetIderSessionLogResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__tim__GetLowAccuracyTimeSynch: + return (void*)soap_instantiate__tim__GetLowAccuracyTimeSynch(soap, -1, type, arrayType, n); + case SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse: + return (void*)soap_instantiate__tim__GetLowAccuracyTimeSynchResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__tim__SetHighAccuracyTimeSynch: + return (void*)soap_instantiate__tim__SetHighAccuracyTimeSynch(soap, -1, type, arrayType, n); + case SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse: + return (void*)soap_instantiate__tim__SetHighAccuracyTimeSynchResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__str__ExecuteStorageOperation: + return (void*)soap_instantiate__str__ExecuteStorageOperation(soap, -1, type, arrayType, n); + case SOAP_TYPE__str__ExecuteStorageOperationResponse: + return (void*)soap_instantiate__str__ExecuteStorageOperationResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_inf__IderSessionLogEntryType: + return (void*)soap_instantiate_inf__IderSessionLogEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_inf__FirmwareVersionType: + return (void*)soap_instantiate_inf__FirmwareVersionType(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetCoreVersion: + return (void*)soap_instantiate__inf__GetCoreVersion(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetCoreVersionResponse: + return (void*)soap_instantiate__inf__GetCoreVersionResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetCodeVersions: + return (void*)soap_instantiate__inf__GetCodeVersions(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetCodeVersionsResponse: + return (void*)soap_instantiate__inf__GetCodeVersionsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetProvisioningMode: + return (void*)soap_instantiate__inf__GetProvisioningMode(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetProvisioningModeResponse: + return (void*)soap_instantiate__inf__GetProvisioningModeResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetProvisioningState: + return (void*)soap_instantiate__inf__GetProvisioningState(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetProvisioningStateResponse: + return (void*)soap_instantiate__inf__GetProvisioningStateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetVlanParameters: + return (void*)soap_instantiate__inf__GetVlanParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetVlanParametersResponse: + return (void*)soap_instantiate__inf__GetVlanParametersResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetHostName: + return (void*)soap_instantiate__inf__GetHostName(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetHostNameResponse: + return (void*)soap_instantiate__inf__GetHostNameResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetConfigServerInfo: + return (void*)soap_instantiate__inf__GetConfigServerInfo(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetConfigServerInfoResponse: + return (void*)soap_instantiate__inf__GetConfigServerInfoResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetAdminAclEntryStatus: + return (void*)soap_instantiate__inf__GetAdminAclEntryStatus(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetAdminAclEntryStatusResponse: + return (void*)soap_instantiate__inf__GetAdminAclEntryStatusResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetAdminNetAclEntryStatus: + return (void*)soap_instantiate__inf__GetAdminNetAclEntryStatus(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse: + return (void*)soap_instantiate__inf__GetAdminNetAclEntryStatusResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetPasswordModel: + return (void*)soap_instantiate__inf__GetPasswordModel(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetPasswordModelResponse: + return (void*)soap_instantiate__inf__GetPasswordModelResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetEnabledInterfaces: + return (void*)soap_instantiate__inf__GetEnabledInterfaces(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetEnabledInterfacesResponse: + return (void*)soap_instantiate__inf__GetEnabledInterfacesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetNetworkState: + return (void*)soap_instantiate__inf__GetNetworkState(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetNetworkStateResponse: + return (void*)soap_instantiate__inf__GetNetworkStateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetSecurityParameters: + return (void*)soap_instantiate__inf__GetSecurityParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetSecurityParametersResponse: + return (void*)soap_instantiate__inf__GetSecurityParametersResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetIderSessionLog: + return (void*)soap_instantiate__inf__GetIderSessionLog(soap, -1, type, arrayType, n); + case SOAP_TYPE__inf__GetIderSessionLogResponse: + return (void*)soap_instantiate__inf__GetIderSessionLogResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__rci__GetRemoteControlCapabilities: + return (void*)soap_instantiate__rci__GetRemoteControlCapabilities(soap, -1, type, arrayType, n); + case SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse: + return (void*)soap_instantiate__rci__GetRemoteControlCapabilitiesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__rci__RemoteControl: + return (void*)soap_instantiate__rci__RemoteControl(soap, -1, type, arrayType, n); + case SOAP_TYPE__rci__RemoteControlResponse: + return (void*)soap_instantiate__rci__RemoteControlResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__rci__GetSystemPowerState: + return (void*)soap_instantiate__rci__GetSystemPowerState(soap, -1, type, arrayType, n); + case SOAP_TYPE__rci__GetSystemPowerStateResponse: + return (void*)soap_instantiate__rci__GetSystemPowerStateResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__WEP64Type: + return (void*)soap_instantiate_wcxs__WEP64Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__WEP128Type: + return (void*)soap_instantiate_wcxs__WEP128Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__DataEncryptionWEPXType: + return (void*)soap_instantiate_wcxs__DataEncryptionWEPXType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__DataEncryptionWEPType: + return (void*)soap_instantiate_wcxs__DataEncryptionWEPType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__DataEncryptionTKIPType: + return (void*)soap_instantiate_wcxs__DataEncryptionTKIPType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__DataEncryptionCCMPType: + return (void*)soap_instantiate_wcxs__DataEncryptionCCMPType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType: + return (void*)soap_instantiate_wcxs__ProfileSecuritySettingWPAType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType: + return (void*)soap_instantiate_wcxs__ProfileSecuritySettingRSNType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__ProfileSecuritySettingsType: + return (void*)soap_instantiate_wcxs__ProfileSecuritySettingsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__ProfileType: + return (void*)soap_instantiate_wcxs__ProfileType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__WirelessCapabilitiesType: + return (void*)soap_instantiate_wcxs__WirelessCapabilitiesType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__WirelessSettingsType: + return (void*)soap_instantiate_wcxs__WirelessSettingsType(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__AddWirelessProfileRequest: + return (void*)soap_instantiate__wcxs__AddWirelessProfileRequest(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__AddWirelessProfileResponse: + return (void*)soap_instantiate__wcxs__AddWirelessProfileResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__GetWirelessProfileRequest: + return (void*)soap_instantiate__wcxs__GetWirelessProfileRequest(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__GetWirelessProfileResponse: + return (void*)soap_instantiate__wcxs__GetWirelessProfileResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__RemoveWirelessProfileRequest: + return (void*)soap_instantiate__wcxs__RemoveWirelessProfileRequest(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__RemoveWirelessProfileResponse: + return (void*)soap_instantiate__wcxs__RemoveWirelessProfileResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__UpdateWirelessProfileRequest: + return (void*)soap_instantiate__wcxs__UpdateWirelessProfileRequest(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__UpdateWirelessProfileResponse: + return (void*)soap_instantiate__wcxs__UpdateWirelessProfileResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest: + return (void*)soap_instantiate__wcxs__EnumerateWirelessProfilesRequest(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse: + return (void*)soap_instantiate__wcxs__EnumerateWirelessProfilesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest: + return (void*)soap_instantiate__wcxs__GetWirelessCapabilitiesRequest(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse: + return (void*)soap_instantiate__wcxs__GetWirelessCapabilitiesResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__GetWirelessSettingsRequest: + return (void*)soap_instantiate__wcxs__GetWirelessSettingsRequest(soap, -1, type, arrayType, n); + case SOAP_TYPE__wcxs__GetWirelessSettingsResponse: + return (void*)soap_instantiate__wcxs__GetWirelessSettingsResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE_cmn__URLType: + return (void*)soap_instantiate_cmn__URLType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerDefaultFilterType: + return (void*)soap_instantiate_cb__CircuitBreakerDefaultFilterType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__CircuitBreakerPacketTCPType: + return (void*)soap_instantiate_cb__CircuitBreakerPacketTCPType(soap, -1, type, arrayType, n); + case SOAP_TYPE___apl__AgentWatchdogShutdown: + return (void*)soap_instantiate___apl__AgentWatchdogShutdown(soap, -1, type, arrayType, n); + case SOAP_TYPE___apl__AgentWatchdogHeartbeat: + return (void*)soap_instantiate___apl__AgentWatchdogHeartbeat(soap, -1, type, arrayType, n); + case SOAP_TYPE___apl__AgentWatchdogRegister: + return (void*)soap_instantiate___apl__AgentWatchdogRegister(soap, -1, type, arrayType, n); + case SOAP_TYPE___apr__ConsoleWatchdogCreate: + return (void*)soap_instantiate___apr__ConsoleWatchdogCreate(soap, -1, type, arrayType, n); + case SOAP_TYPE___apr__ConsoleWatchdogDelete: + return (void*)soap_instantiate___apr__ConsoleWatchdogDelete(soap, -1, type, arrayType, n); + case SOAP_TYPE___apr__ConsoleWatchdogEnumerate: + return (void*)soap_instantiate___apr__ConsoleWatchdogEnumerate(soap, -1, type, arrayType, n); + case SOAP_TYPE___apr__ConsoleWatchdogSetActions: + return (void*)soap_instantiate___apr__ConsoleWatchdogSetActions(soap, -1, type, arrayType, n); + case SOAP_TYPE___apr__ConsoleWatchdogGetActions: + return (void*)soap_instantiate___apr__ConsoleWatchdogGetActions(soap, -1, type, arrayType, n); + case SOAP_TYPE___apr__ConsoleWatchdogSetCbPolicy: + return (void*)soap_instantiate___apr__ConsoleWatchdogSetCbPolicy(soap, -1, type, arrayType, n); + case SOAP_TYPE___apr__ConsoleWatchdogGetCbPolicy: + return (void*)soap_instantiate___apr__ConsoleWatchdogGetCbPolicy(soap, -1, type, arrayType, n); + case SOAP_TYPE___apr__ConsoleWatchdogQueryCapabilities: + return (void*)soap_instantiate___apr__ConsoleWatchdogQueryCapabilities(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbPolicyCreate: + return (void*)soap_instantiate___cb__CbPolicyCreate(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbPolicyGet: + return (void*)soap_instantiate___cb__CbPolicyGet(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbPolicyDelete: + return (void*)soap_instantiate___cb__CbPolicyDelete(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbPolicyEnumerate: + return (void*)soap_instantiate___cb__CbPolicyEnumerate(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbPolicyEnable: + return (void*)soap_instantiate___cb__CbPolicyEnable(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbPolicyDisable: + return (void*)soap_instantiate___cb__CbPolicyDisable(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbPolicyGetEnabled: + return (void*)soap_instantiate___cb__CbPolicyGetEnabled(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbPolicyGetActiveStatistics: + return (void*)soap_instantiate___cb__CbPolicyGetActiveStatistics(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbFilterCreate: + return (void*)soap_instantiate___cb__CbFilterCreate(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbFilterGet: + return (void*)soap_instantiate___cb__CbFilterGet(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbFilterDelete: + return (void*)soap_instantiate___cb__CbFilterDelete(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbFilterEnumerate: + return (void*)soap_instantiate___cb__CbFilterEnumerate(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__CbQueryCapabilities: + return (void*)soap_instantiate___cb__CbQueryCapabilities(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__SetHcbOptions: + return (void*)soap_instantiate___cb__SetHcbOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__GetHcbOptions: + return (void*)soap_instantiate___cb__GetHcbOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__ClearHcbState: + return (void*)soap_instantiate___cb__ClearHcbState(soap, -1, type, arrayType, n); + case SOAP_TYPE___cb__GetHcbState: + return (void*)soap_instantiate___cb__GetHcbState(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__EnumerateEventFilters: + return (void*)soap_instantiate___emi__EnumerateEventFilters(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__GetAlertSubscription: + return (void*)soap_instantiate___emi__GetAlertSubscription(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__SetAlertCommunityString: + return (void*)soap_instantiate___emi__SetAlertCommunityString(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__GetAlertCommunityString: + return (void*)soap_instantiate___emi__GetAlertCommunityString(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__AddEventFilter: + return (void*)soap_instantiate___emi__AddEventFilter(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__SubscribeForAlert: + return (void*)soap_instantiate___emi__SubscribeForAlert(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__EnumerateAlertSubscriptions: + return (void*)soap_instantiate___emi__EnumerateAlertSubscriptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__EnumerateAlertPolicies: + return (void*)soap_instantiate___emi__EnumerateAlertPolicies(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__CancelAlertSubscription: + return (void*)soap_instantiate___emi__CancelAlertSubscription(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__GetEventFilter: + return (void*)soap_instantiate___emi__GetEventFilter(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__UpdateEventFilter: + return (void*)soap_instantiate___emi__UpdateEventFilter(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__RemoveEventFilter: + return (void*)soap_instantiate___emi__RemoveEventFilter(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__GetEventLogStatus: + return (void*)soap_instantiate___emi__GetEventLogStatus(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__ReadEventLogRecords: + return (void*)soap_instantiate___emi__ReadEventLogRecords(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__ClearEventLog: + return (void*)soap_instantiate___emi__ClearEventLog(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__FreezeEventLog: + return (void*)soap_instantiate___emi__FreezeEventLog(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__SetEventLogTimestampClock: + return (void*)soap_instantiate___emi__SetEventLogTimestampClock(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__GetEventLogTimestampClock: + return (void*)soap_instantiate___emi__GetEventLogTimestampClock(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__EnumerateSensors: + return (void*)soap_instantiate___emi__EnumerateSensors(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__GetSensorAttributes: + return (void*)soap_instantiate___emi__GetSensorAttributes(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__SubscribeForGeneralAlert: + return (void*)soap_instantiate___emi__SubscribeForGeneralAlert(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__EnumerateGeneralAlertSubscriptions: + return (void*)soap_instantiate___emi__EnumerateGeneralAlertSubscriptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___emi__GetGeneralAlertSubscription: + return (void*)soap_instantiate___emi__GetGeneralAlertSubscription(soap, -1, type, arrayType, n); + case SOAP_TYPE___hwa__EnumerateAssetTypes: + return (void*)soap_instantiate___hwa__EnumerateAssetTypes(soap, -1, type, arrayType, n); + case SOAP_TYPE___hwa__GetAssetData: + return (void*)soap_instantiate___hwa__GetAssetData(soap, -1, type, arrayType, n); + case SOAP_TYPE___idr__SetRedirectionListenerState: + return (void*)soap_instantiate___idr__SetRedirectionListenerState(soap, -1, type, arrayType, n); + case SOAP_TYPE___idr__GetRedirectionListenerState: + return (void*)soap_instantiate___idr__GetRedirectionListenerState(soap, -1, type, arrayType, n); + case SOAP_TYPE___idr__GetIderSessionLog: + return (void*)soap_instantiate___idr__GetIderSessionLog(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetCoreVersion: + return (void*)soap_instantiate___inf__GetCoreVersion(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetCodeVersions: + return (void*)soap_instantiate___inf__GetCodeVersions(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetProvisioningMode: + return (void*)soap_instantiate___inf__GetProvisioningMode(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetProvisioningState: + return (void*)soap_instantiate___inf__GetProvisioningState(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetVlanParameters: + return (void*)soap_instantiate___inf__GetVlanParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetHostName: + return (void*)soap_instantiate___inf__GetHostName(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetConfigServerInfo: + return (void*)soap_instantiate___inf__GetConfigServerInfo(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetAdminAclEntryStatus: + return (void*)soap_instantiate___inf__GetAdminAclEntryStatus(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetAdminNetAclEntryStatus: + return (void*)soap_instantiate___inf__GetAdminNetAclEntryStatus(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetPasswordModel: + return (void*)soap_instantiate___inf__GetPasswordModel(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetEnabledInterfaces: + return (void*)soap_instantiate___inf__GetEnabledInterfaces(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetNetworkState: + return (void*)soap_instantiate___inf__GetNetworkState(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetSecurityParameters: + return (void*)soap_instantiate___inf__GetSecurityParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE___inf__GetIderSessionLog: + return (void*)soap_instantiate___inf__GetIderSessionLog(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__SetHostName: + return (void*)soap_instantiate___net__SetHostName(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__GetHostName: + return (void*)soap_instantiate___net__GetHostName(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__SetDomainName: + return (void*)soap_instantiate___net__SetDomainName(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__GetDomainName: + return (void*)soap_instantiate___net__GetDomainName(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__SetTcpIpParameters: + return (void*)soap_instantiate___net__SetTcpIpParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__GetTcpIpParameters: + return (void*)soap_instantiate___net__GetTcpIpParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__SetVlanParameters: + return (void*)soap_instantiate___net__SetVlanParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__GetVlanParameters: + return (void*)soap_instantiate___net__GetVlanParameters(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__SetPingResponse: + return (void*)soap_instantiate___net__SetPingResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__GetPingResponse: + return (void*)soap_instantiate___net__GetPingResponse(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__EnumerateInterfaces: + return (void*)soap_instantiate___net__EnumerateInterfaces(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__GetInterfaceSettings: + return (void*)soap_instantiate___net__GetInterfaceSettings(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__SetInterfaceSettings: + return (void*)soap_instantiate___net__SetInterfaceSettings(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__Set8021XWiredProfile: + return (void*)soap_instantiate___net__Set8021XWiredProfile(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__Get8021XWiredProfile: + return (void*)soap_instantiate___net__Get8021XWiredProfile(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__Set8021XActiveS0: + return (void*)soap_instantiate___net__Set8021XActiveS0(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__Get8021XActiveS0: + return (void*)soap_instantiate___net__Get8021XActiveS0(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__Set8021XPxeTimeout: + return (void*)soap_instantiate___net__Set8021XPxeTimeout(soap, -1, type, arrayType, n); + case SOAP_TYPE___net__Get8021XPxeTimeout: + return (void*)soap_instantiate___net__Get8021XPxeTimeout(soap, -1, type, arrayType, n); + case SOAP_TYPE___rci__GetRemoteControlCapabilities: + return (void*)soap_instantiate___rci__GetRemoteControlCapabilities(soap, -1, type, arrayType, n); + case SOAP_TYPE___rci__RemoteControl: + return (void*)soap_instantiate___rci__RemoteControl(soap, -1, type, arrayType, n); + case SOAP_TYPE___rci__GetSystemPowerState: + return (void*)soap_instantiate___rci__GetSystemPowerState(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__ResetFlashWearOutProtection: + return (void*)soap_instantiate___sai__ResetFlashWearOutProtection(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetAdminAclEntry: + return (void*)soap_instantiate___sai__GetAdminAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetAdminAclEntry: + return (void*)soap_instantiate___sai__SetAdminAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__AddUserAclEntry: + return (void*)soap_instantiate___sai__AddUserAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__EnumerateUserAclEntries: + return (void*)soap_instantiate___sai__EnumerateUserAclEntries(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetUserAclEntry: + return (void*)soap_instantiate___sai__GetUserAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__UpdateUserAclEntry: + return (void*)soap_instantiate___sai__UpdateUserAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__RemoveUserAclEntry: + return (void*)soap_instantiate___sai__RemoveUserAclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetTlsEnabled: + return (void*)soap_instantiate___sai__SetTlsEnabled(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetRngKey: + return (void*)soap_instantiate___sai__SetRngKey(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetTLSKeyAndCertificate: + return (void*)soap_instantiate___sai__SetTLSKeyAndCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetTLSCertificate: + return (void*)soap_instantiate___sai__SetTLSCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetTLSCertificate: + return (void*)soap_instantiate___sai__GetTLSCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__UpdateCoreFromUrl: + return (void*)soap_instantiate___sai__UpdateCoreFromUrl(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetProvisioningMode: + return (void*)soap_instantiate___sai__GetProvisioningMode(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetProvisioningMode: + return (void*)soap_instantiate___sai__SetProvisioningMode(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__Unprovision: + return (void*)soap_instantiate___sai__Unprovision(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CommitChanges: + return (void*)soap_instantiate___sai__CommitChanges(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetCoreVersion: + return (void*)soap_instantiate___sai__GetCoreVersion(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__AddUserAclEntryEx: + return (void*)soap_instantiate___sai__AddUserAclEntryEx(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetUserAclEntryEx: + return (void*)soap_instantiate___sai__GetUserAclEntryEx(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__UpdateUserAclEntryEx: + return (void*)soap_instantiate___sai__UpdateUserAclEntryEx(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetAdminAclEntryEx: + return (void*)soap_instantiate___sai__SetAdminAclEntryEx(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetDigestRealm: + return (void*)soap_instantiate___sai__GetDigestRealm(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetKerberosOptions: + return (void*)soap_instantiate___sai__SetKerberosOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetKerberosOptions: + return (void*)soap_instantiate___sai__GetKerberosOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetEnabledInterfaces: + return (void*)soap_instantiate___sai__SetEnabledInterfaces(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetEnabledInterfaces: + return (void*)soap_instantiate___sai__GetEnabledInterfaces(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetTlsOptions: + return (void*)soap_instantiate___sai__SetTlsOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetTlsOptions: + return (void*)soap_instantiate___sai__GetTlsOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__AddTrustedRootCertificate: + return (void*)soap_instantiate___sai__AddTrustedRootCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetTrustedRootCertificate: + return (void*)soap_instantiate___sai__GetTrustedRootCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__DeleteTrustedRootCertificate: + return (void*)soap_instantiate___sai__DeleteTrustedRootCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__EnumerateTrustedRootCertificates: + return (void*)soap_instantiate___sai__EnumerateTrustedRootCertificates(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetTrustedFqdnCN: + return (void*)soap_instantiate___sai__SetTrustedFqdnCN(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetTrustedFqdnCN: + return (void*)soap_instantiate___sai__GetTrustedFqdnCN(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetCRL: + return (void*)soap_instantiate___sai__SetCRL(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetCRL: + return (void*)soap_instantiate___sai__GetCRL(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetServerCertificateReq: + return (void*)soap_instantiate___sai__GetServerCertificateReq(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetPkiCapabilities: + return (void*)soap_instantiate___sai__GetPkiCapabilities(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetPowerSavingOptions: + return (void*)soap_instantiate___sai__SetPowerSavingOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetPowerSavingOptions: + return (void*)soap_instantiate___sai__GetPowerSavingOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetTLSPSK: + return (void*)soap_instantiate___sai__SetTLSPSK(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__PartialUnprovision: + return (void*)soap_instantiate___sai__PartialUnprovision(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetMEBxPassword: + return (void*)soap_instantiate___sai__SetMEBxPassword(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetProvisioningServerOTP: + return (void*)soap_instantiate___sai__SetProvisioningServerOTP(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetProvisioningServerOTP: + return (void*)soap_instantiate___sai__GetProvisioningServerOTP(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__EnumerateCertificateHashEntries: + return (void*)soap_instantiate___sai__EnumerateCertificateHashEntries(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetCertificateHashEntry: + return (void*)soap_instantiate___sai__GetCertificateHashEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__AddCertificateHashEntry: + return (void*)soap_instantiate___sai__AddCertificateHashEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__DeleteCertificateHashEntry: + return (void*)soap_instantiate___sai__DeleteCertificateHashEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__EnableCertificateHashEntry: + return (void*)soap_instantiate___sai__EnableCertificateHashEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetZeroTouchConfigurationMode: + return (void*)soap_instantiate___sai__GetZeroTouchConfigurationMode(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetZeroTouchConfigurationMode: + return (void*)soap_instantiate___sai__SetZeroTouchConfigurationMode(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetProvisioningAuditRecord: + return (void*)soap_instantiate___sai__GetProvisioningAuditRecord(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetProvisioningPID: + return (void*)soap_instantiate___sai__GetProvisioningPID(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__ExtendProvisioningPeriod: + return (void*)soap_instantiate___sai__ExtendProvisioningPeriod(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetRealmAuthOptions: + return (void*)soap_instantiate___sai__GetRealmAuthOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetRealmAuthOptions: + return (void*)soap_instantiate___sai__SetRealmAuthOptions(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetEnvironmentDetection: + return (void*)soap_instantiate___sai__SetEnvironmentDetection(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetEnvironmentDetection: + return (void*)soap_instantiate___sai__GetEnvironmentDetection(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__EnumeratePowerPackages: + return (void*)soap_instantiate___sai__EnumeratePowerPackages(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetPowerPackage: + return (void*)soap_instantiate___sai__GetPowerPackage(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetActivePowerPackage: + return (void*)soap_instantiate___sai__GetActivePowerPackage(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetActivePowerPackage: + return (void*)soap_instantiate___sai__SetActivePowerPackage(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetGlobalPowerPolicy: + return (void*)soap_instantiate___sai__SetGlobalPowerPolicy(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetGlobalPowerPolicy: + return (void*)soap_instantiate___sai__GetGlobalPowerPolicy(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreAddKey: + return (void*)soap_instantiate___sai__CertStoreAddKey(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreEnumerateKeys: + return (void*)soap_instantiate___sai__CertStoreEnumerateKeys(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreGetKey: + return (void*)soap_instantiate___sai__CertStoreGetKey(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreRemoveKey: + return (void*)soap_instantiate___sai__CertStoreRemoveKey(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreAddCertificate: + return (void*)soap_instantiate___sai__CertStoreAddCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreGetCertificate: + return (void*)soap_instantiate___sai__CertStoreGetCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreEnumerateCertificates: + return (void*)soap_instantiate___sai__CertStoreEnumerateCertificates(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreRemoveCertificate: + return (void*)soap_instantiate___sai__CertStoreRemoveCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreGetPKCS10Request: + return (void*)soap_instantiate___sai__CertStoreGetPKCS10Request(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__CertStoreUpdateCertificate: + return (void*)soap_instantiate___sai__CertStoreUpdateCertificate(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetTLSCredentials: + return (void*)soap_instantiate___sai__SetTLSCredentials(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetTLSCredentials: + return (void*)soap_instantiate___sai__GetTLSCredentials(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__EnableVpnRouting: + return (void*)soap_instantiate___sai__EnableVpnRouting(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetConfigurationServerFQDN: + return (void*)soap_instantiate___sai__GetConfigurationServerFQDN(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetConfigurationServerFQDN: + return (void*)soap_instantiate___sai__SetConfigurationServerFQDN(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__SetAclEnabledState: + return (void*)soap_instantiate___sai__SetAclEnabledState(soap, -1, type, arrayType, n); + case SOAP_TYPE___sai__GetAclEnabledState: + return (void*)soap_instantiate___sai__GetAclEnabledState(soap, -1, type, arrayType, n); + case SOAP_TYPE___str__ExecuteStorageOperation: + return (void*)soap_instantiate___str__ExecuteStorageOperation(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__GetGlobalStorageAttributes: + return (void*)soap_instantiate___stra__GetGlobalStorageAttributes(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__SetGlobalStorageAttributes: + return (void*)soap_instantiate___stra__SetGlobalStorageAttributes(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__AdminGetRegisteredApplications: + return (void*)soap_instantiate___stra__AdminGetRegisteredApplications(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__AdminGetApplicationAttributes: + return (void*)soap_instantiate___stra__AdminGetApplicationAttributes(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__AdminRemoveApplication: + return (void*)soap_instantiate___stra__AdminRemoveApplication(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__AddStorageEaclEntry: + return (void*)soap_instantiate___stra__AddStorageEaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__EnumerateStorageEaclEntries: + return (void*)soap_instantiate___stra__EnumerateStorageEaclEntries(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__GetStorageEaclEntry: + return (void*)soap_instantiate___stra__GetStorageEaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__RemoveStorageEaclEntry: + return (void*)soap_instantiate___stra__RemoveStorageEaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__AddStorageFpaclEntry: + return (void*)soap_instantiate___stra__AddStorageFpaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__EnumerateStorageAllocEntries: + return (void*)soap_instantiate___stra__EnumerateStorageAllocEntries(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__GetStorageAllocEntry: + return (void*)soap_instantiate___stra__GetStorageAllocEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__UpdateStorageFpaclEntry: + return (void*)soap_instantiate___stra__UpdateStorageFpaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___stra__RemoveStorageFpaclEntry: + return (void*)soap_instantiate___stra__RemoveStorageFpaclEntry(soap, -1, type, arrayType, n); + case SOAP_TYPE___tim__GetLowAccuracyTimeSynch: + return (void*)soap_instantiate___tim__GetLowAccuracyTimeSynch(soap, -1, type, arrayType, n); + case SOAP_TYPE___tim__SetHighAccuracyTimeSynch: + return (void*)soap_instantiate___tim__SetHighAccuracyTimeSynch(soap, -1, type, arrayType, n); + case SOAP_TYPE___wcxs__AddWirelessProfile: + return (void*)soap_instantiate___wcxs__AddWirelessProfile(soap, -1, type, arrayType, n); + case SOAP_TYPE___wcxs__GetWirelessProfile: + return (void*)soap_instantiate___wcxs__GetWirelessProfile(soap, -1, type, arrayType, n); + case SOAP_TYPE___wcxs__RemoveWirelessProfile: + return (void*)soap_instantiate___wcxs__RemoveWirelessProfile(soap, -1, type, arrayType, n); + case SOAP_TYPE___wcxs__UpdateWirelessProfile: + return (void*)soap_instantiate___wcxs__UpdateWirelessProfile(soap, -1, type, arrayType, n); + case SOAP_TYPE___wcxs__EnumerateWirelessProfiles: + return (void*)soap_instantiate___wcxs__EnumerateWirelessProfiles(soap, -1, type, arrayType, n); + case SOAP_TYPE___wcxs__GetWirelessCapabilities: + return (void*)soap_instantiate___wcxs__GetWirelessCapabilities(soap, -1, type, arrayType, n); + case SOAP_TYPE___wcxs__GetWirelessSettings: + return (void*)soap_instantiate___wcxs__GetWirelessSettings(soap, -1, type, arrayType, n); + case SOAP_TYPE_xsd__anyURI: + return (void*)soap_instantiate_xsd__anyURI(soap, -1, type, arrayType, n); + case SOAP_TYPE_cmn__HostNameType: + return (void*)soap_instantiate_cmn__HostNameType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cmn__IPv4AddressStringType: + return (void*)soap_instantiate_cmn__IPv4AddressStringType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cmn__IPv6AddressStringType: + return (void*)soap_instantiate_cmn__IPv6AddressStringType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cmn__GuidBuf: + return (void*)soap_instantiate_cmn__GuidBuf(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__AclStringType: + return (void*)soap_instantiate_sai__AclStringType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__AclPasswordStringType: + return (void*)soap_instantiate_sai__AclPasswordStringType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__MEBxPasswordType: + return (void*)soap_instantiate_sai__MEBxPasswordType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__ProvisioningOTPType: + return (void*)soap_instantiate_sai__ProvisioningOTPType(soap, -1, type, arrayType, n); + case SOAP_TYPE_sai__FriendlyNameType: + return (void*)soap_instantiate_sai__FriendlyNameType(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__SpnString: + return (void*)soap_instantiate__sai__SpnString(soap, -1, type, arrayType, n); + case SOAP_TYPE__sai__KerberosRealmName: + return (void*)soap_instantiate__sai__KerberosRealmName(soap, -1, type, arrayType, n); + case SOAP_TYPE_net__MACAddressType: + return (void*)soap_instantiate_net__MACAddressType(soap, -1, type, arrayType, n); + case SOAP_TYPE_emi__CommunityStringType: + return (void*)soap_instantiate_emi__CommunityStringType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__IPv4AddressStringType: + return (void*)soap_instantiate_cb__IPv4AddressStringType(soap, -1, type, arrayType, n); + case SOAP_TYPE_cb__IPv6AddressStringType: + return (void*)soap_instantiate_cb__IPv6AddressStringType(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__FilterName: + return (void*)soap_instantiate__cb__FilterName(soap, -1, type, arrayType, n); + case SOAP_TYPE__cb__PolicyName: + return (void*)soap_instantiate__cb__PolicyName(soap, -1, type, arrayType, n); + case SOAP_TYPE__apr__AgentDescription: + return (void*)soap_instantiate__apr__AgentDescription(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__ProfileNameType: + return (void*)soap_instantiate_wcxs__ProfileNameType(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__RawKey64Type: + return (void*)soap_instantiate_wcxs__RawKey64Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__RawKey128Type: + return (void*)soap_instantiate_wcxs__RawKey128Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__RawKey256Type: + return (void*)soap_instantiate_wcxs__RawKey256Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__PassPhrase5Type: + return (void*)soap_instantiate_wcxs__PassPhrase5Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__PassPhraseWEP128Type: + return (void*)soap_instantiate_wcxs__PassPhraseWEP128Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_wcxs__PassPhrase63Type: + return (void*)soap_instantiate_wcxs__PassPhrase63Type(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfwcxs__ProfileNameType: + return (void*)soap_instantiate_std__vectorTemplateOfwcxs__ProfileNameType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfwcxs__FeatureType: + return (void*)soap_instantiate_std__vectorTemplateOfwcxs__FeatureType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfinf__EnabledInterfacesType: + return (void*)soap_instantiate_std__vectorTemplateOfinf__EnabledInterfacesType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerToinf__FirmwareVersionType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerToinf__FirmwareVersionType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfunsignedShort: + return (void*)soap_instantiate_std__vectorTemplateOfunsignedShort(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerTohwa__AssetDataType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerTohwa__AssetDataType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfhwa__AssetTypeType: + return (void*)soap_instantiate_std__vectorTemplateOfhwa__AssetTypeType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfemi__AlertAuthOptionsType: + return (void*)soap_instantiate_std__vectorTemplateOfemi__AlertAuthOptionsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfemi__SensorHandleType: + return (void*)soap_instantiate_std__vectorTemplateOfemi__SensorHandleType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerToemi__EventLogRecordType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerToemi__EventLogRecordType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfemi__EventFilterHandleType: + return (void*)soap_instantiate_std__vectorTemplateOfemi__EventFilterHandleType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionHandleType: + return (void*)soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType: + return (void*)soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfstra__StorageApplicationHandleType: + return (void*)soap_instantiate_std__vectorTemplateOfstra__StorageApplicationHandleType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfunsignedByte: + return (void*)soap_instantiate_std__vectorTemplateOfunsignedByte(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfstra__StorageAllocEntryHandleType: + return (void*)soap_instantiate_std__vectorTemplateOfstra__StorageAllocEntryHandleType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfstra__StorageEaclEntryHandleType: + return (void*)soap_instantiate_std__vectorTemplateOfstra__StorageEaclEntryHandleType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfnet__InterfaceHandleType: + return (void*)soap_instantiate_std__vectorTemplateOfnet__InterfaceHandleType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfcmn__GuidBuf: + return (void*)soap_instantiate_std__vectorTemplateOfcmn__GuidBuf(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerTosai__CrlType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerTosai__CrlType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfsai__CertificateHandleType: + return (void*)soap_instantiate_std__vectorTemplateOfsai__CertificateHandleType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerTosai__TlsOptionsType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfsai__EnabledInterfacesType: + return (void*)soap_instantiate_std__vectorTemplateOfsai__EnabledInterfacesType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfstd__string: + return (void*)soap_instantiate_std__vectorTemplateOfstd__string(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfunsignedInt: + return (void*)soap_instantiate_std__vectorTemplateOfunsignedInt(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfxsd__base64Binary: + return (void*)soap_instantiate_std__vectorTemplateOfxsd__base64Binary(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfPointerTosai__KerberosSpnType: + return (void*)soap_instantiate_std__vectorTemplateOfPointerTosai__KerberosSpnType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfsai__UserAclRealmType: + return (void*)soap_instantiate_std__vectorTemplateOfsai__UserAclRealmType(soap, -1, type, arrayType, n); + case SOAP_TYPE_std__vectorTemplateOfsai__UserAclEntryHandleType: + return (void*)soap_instantiate_std__vectorTemplateOfsai__UserAclEntryHandleType(soap, -1, type, arrayType, n); + } + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_fdelete(struct soap_clist *p) +{ switch (p->type) + { + case SOAP_TYPE_std__string: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_xsd__base64Binary: + if (p->size < 0) + delete (xsd__base64Binary*)p->ptr; + else + delete[] (xsd__base64Binary*)p->ptr; + break; + case SOAP_TYPE_cmn__NodeAddressType: + if (p->size < 0) + delete (cmn__NodeAddressType*)p->ptr; + else + delete[] (cmn__NodeAddressType*)p->ptr; + break; + case SOAP_TYPE_cstr__RSAKeyPairType: + if (p->size < 0) + delete (cstr__RSAKeyPairType*)p->ptr; + else + delete[] (cstr__RSAKeyPairType*)p->ptr; + break; + case SOAP_TYPE_cstr__KeyPairType: + if (p->size < 0) + delete (cstr__KeyPairType*)p->ptr; + else + delete[] (cstr__KeyPairType*)p->ptr; + break; + case SOAP_TYPE_sai__UserAclEntryType: + if (p->size < 0) + delete (sai__UserAclEntryType*)p->ptr; + else + delete[] (sai__UserAclEntryType*)p->ptr; + break; + case SOAP_TYPE_sai__AdminAclEntryType: + if (p->size < 0) + delete (sai__AdminAclEntryType*)p->ptr; + else + delete[] (sai__AdminAclEntryType*)p->ptr; + break; + case SOAP_TYPE_sai__UserAclEntryHandleListType: + if (p->size < 0) + delete (sai__UserAclEntryHandleListType*)p->ptr; + else + delete[] (sai__UserAclEntryHandleListType*)p->ptr; + break; + case SOAP_TYPE_sai__UserAclRealmListType: + if (p->size < 0) + delete (sai__UserAclRealmListType*)p->ptr; + else + delete[] (sai__UserAclRealmListType*)p->ptr; + break; + case SOAP_TYPE_sai__RsaKeyType: + if (p->size < 0) + delete (sai__RsaKeyType*)p->ptr; + else + delete[] (sai__RsaKeyType*)p->ptr; + break; + case SOAP_TYPE_sai__RngKeyType: + if (p->size < 0) + delete (sai__RngKeyType*)p->ptr; + else + delete[] (sai__RngKeyType*)p->ptr; + break; + case SOAP_TYPE_sai__CertificateChainType: + if (p->size < 0) + delete (sai__CertificateChainType*)p->ptr; + else + delete[] (sai__CertificateChainType*)p->ptr; + break; + case SOAP_TYPE_sai__UpdateCoreUrlKeyType: + if (p->size < 0) + delete (sai__UpdateCoreUrlKeyType*)p->ptr; + else + delete[] (sai__UpdateCoreUrlKeyType*)p->ptr; + break; + case SOAP_TYPE_sai__AmtVersion: + if (p->size < 0) + delete (sai__AmtVersion*)p->ptr; + else + delete[] (sai__AmtVersion*)p->ptr; + break; + case SOAP_TYPE_sai__UserEntryDigestType: + if (p->size < 0) + delete (sai__UserEntryDigestType*)p->ptr; + else + delete[] (sai__UserEntryDigestType*)p->ptr; + break; + case SOAP_TYPE_sai__UserEntryKerberosType: + if (p->size < 0) + delete (sai__UserEntryKerberosType*)p->ptr; + else + delete[] (sai__UserEntryKerberosType*)p->ptr; + break; + case SOAP_TYPE_sai__UserAclEntryExType: + if (p->size < 0) + delete (sai__UserAclEntryExType*)p->ptr; + else + delete[] (sai__UserAclEntryExType*)p->ptr; + break; + case SOAP_TYPE_sai__AdminAclEntryExType: + if (p->size < 0) + delete (sai__AdminAclEntryExType*)p->ptr; + else + delete[] (sai__AdminAclEntryExType*)p->ptr; + break; + case SOAP_TYPE_sai__KerberosSpnType: + if (p->size < 0) + delete (sai__KerberosSpnType*)p->ptr; + else + delete[] (sai__KerberosSpnType*)p->ptr; + break; + case SOAP_TYPE_sai__KerberosOptionsType: + if (p->size < 0) + delete (sai__KerberosOptionsType*)p->ptr; + else + delete[] (sai__KerberosOptionsType*)p->ptr; + break; + case SOAP_TYPE_sai__TlsOptionsType: + if (p->size < 0) + delete (sai__TlsOptionsType*)p->ptr; + else + delete[] (sai__TlsOptionsType*)p->ptr; + break; + case SOAP_TYPE_sai__CertificateType: + if (p->size < 0) + delete (sai__CertificateType*)p->ptr; + else + delete[] (sai__CertificateType*)p->ptr; + break; + case SOAP_TYPE_sai__CrlType: + if (p->size < 0) + delete (sai__CrlType*)p->ptr; + else + delete[] (sai__CrlType*)p->ptr; + break; + case SOAP_TYPE_sai__PkiCapsType: + if (p->size < 0) + delete (sai__PkiCapsType*)p->ptr; + else + delete[] (sai__PkiCapsType*)p->ptr; + break; + case SOAP_TYPE_sai__CertHashEntryType: + if (p->size < 0) + delete (sai__CertHashEntryType*)p->ptr; + else + delete[] (sai__CertHashEntryType*)p->ptr; + break; + case SOAP_TYPE_sai__ProvisioningAuditRecordType: + if (p->size < 0) + delete (sai__ProvisioningAuditRecordType*)p->ptr; + else + delete[] (sai__ProvisioningAuditRecordType*)p->ptr; + break; + case SOAP_TYPE_sai__EnvironmentDetectionDomainType: + if (p->size < 0) + delete (sai__EnvironmentDetectionDomainType*)p->ptr; + else + delete[] (sai__EnvironmentDetectionDomainType*)p->ptr; + break; + case SOAP_TYPE_sai__EnvironmentDetectionType: + if (p->size < 0) + delete (sai__EnvironmentDetectionType*)p->ptr; + else + delete[] (sai__EnvironmentDetectionType*)p->ptr; + break; + case SOAP_TYPE_sai__GlobalPowerPolicyType: + if (p->size < 0) + delete (sai__GlobalPowerPolicyType*)p->ptr; + else + delete[] (sai__GlobalPowerPolicyType*)p->ptr; + break; + case SOAP_TYPE__sai__AddUserAclEntry: + if (p->size < 0) + delete (_sai__AddUserAclEntry*)p->ptr; + else + delete[] (_sai__AddUserAclEntry*)p->ptr; + break; + case SOAP_TYPE__sai__AddUserAclEntryResponse: + if (p->size < 0) + delete (_sai__AddUserAclEntryResponse*)p->ptr; + else + delete[] (_sai__AddUserAclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetAdminAclEntry: + if (p->size < 0) + delete (_sai__SetAdminAclEntry*)p->ptr; + else + delete[] (_sai__SetAdminAclEntry*)p->ptr; + break; + case SOAP_TYPE__sai__SetAdminAclEntryResponse: + if (p->size < 0) + delete (_sai__SetAdminAclEntryResponse*)p->ptr; + else + delete[] (_sai__SetAdminAclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__EnumerateUserAclEntries: + if (p->size < 0) + delete (_sai__EnumerateUserAclEntries*)p->ptr; + else + delete[] (_sai__EnumerateUserAclEntries*)p->ptr; + break; + case SOAP_TYPE__sai__EnumerateUserAclEntriesResponse: + if (p->size < 0) + delete (_sai__EnumerateUserAclEntriesResponse*)p->ptr; + else + delete[] (_sai__EnumerateUserAclEntriesResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetUserAclEntry: + if (p->size < 0) + delete (_sai__GetUserAclEntry*)p->ptr; + else + delete[] (_sai__GetUserAclEntry*)p->ptr; + break; + case SOAP_TYPE__sai__GetUserAclEntryResponse: + if (p->size < 0) + delete (_sai__GetUserAclEntryResponse*)p->ptr; + else + delete[] (_sai__GetUserAclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetAdminAclEntry: + if (p->size < 0) + delete (_sai__GetAdminAclEntry*)p->ptr; + else + delete[] (_sai__GetAdminAclEntry*)p->ptr; + break; + case SOAP_TYPE__sai__GetAdminAclEntryResponse: + if (p->size < 0) + delete (_sai__GetAdminAclEntryResponse*)p->ptr; + else + delete[] (_sai__GetAdminAclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__UpdateUserAclEntry: + if (p->size < 0) + delete (_sai__UpdateUserAclEntry*)p->ptr; + else + delete[] (_sai__UpdateUserAclEntry*)p->ptr; + break; + case SOAP_TYPE__sai__UpdateUserAclEntryResponse: + if (p->size < 0) + delete (_sai__UpdateUserAclEntryResponse*)p->ptr; + else + delete[] (_sai__UpdateUserAclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__RemoveUserAclEntry: + if (p->size < 0) + delete (_sai__RemoveUserAclEntry*)p->ptr; + else + delete[] (_sai__RemoveUserAclEntry*)p->ptr; + break; + case SOAP_TYPE__sai__RemoveUserAclEntryResponse: + if (p->size < 0) + delete (_sai__RemoveUserAclEntryResponse*)p->ptr; + else + delete[] (_sai__RemoveUserAclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetTlsEnabled: + if (p->size < 0) + delete (_sai__SetTlsEnabled*)p->ptr; + else + delete[] (_sai__SetTlsEnabled*)p->ptr; + break; + case SOAP_TYPE__sai__SetTlsEnabledResponse: + if (p->size < 0) + delete (_sai__SetTlsEnabledResponse*)p->ptr; + else + delete[] (_sai__SetTlsEnabledResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetTLSKeyAndCertificate: + if (p->size < 0) + delete (_sai__SetTLSKeyAndCertificate*)p->ptr; + else + delete[] (_sai__SetTLSKeyAndCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse: + if (p->size < 0) + delete (_sai__SetTLSKeyAndCertificateResponse*)p->ptr; + else + delete[] (_sai__SetTLSKeyAndCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetRngKey: + if (p->size < 0) + delete (_sai__SetRngKey*)p->ptr; + else + delete[] (_sai__SetRngKey*)p->ptr; + break; + case SOAP_TYPE__sai__SetRngKeyResponse: + if (p->size < 0) + delete (_sai__SetRngKeyResponse*)p->ptr; + else + delete[] (_sai__SetRngKeyResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetTLSCertificate: + if (p->size < 0) + delete (_sai__SetTLSCertificate*)p->ptr; + else + delete[] (_sai__SetTLSCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__SetTLSCertificateResponse: + if (p->size < 0) + delete (_sai__SetTLSCertificateResponse*)p->ptr; + else + delete[] (_sai__SetTLSCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetTLSCertificate: + if (p->size < 0) + delete (_sai__GetTLSCertificate*)p->ptr; + else + delete[] (_sai__GetTLSCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__GetTLSCertificateResponse: + if (p->size < 0) + delete (_sai__GetTLSCertificateResponse*)p->ptr; + else + delete[] (_sai__GetTLSCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__UpdateCoreFromUrl: + if (p->size < 0) + delete (_sai__UpdateCoreFromUrl*)p->ptr; + else + delete[] (_sai__UpdateCoreFromUrl*)p->ptr; + break; + case SOAP_TYPE__sai__UpdateCoreFromUrlResponse: + if (p->size < 0) + delete (_sai__UpdateCoreFromUrlResponse*)p->ptr; + else + delete[] (_sai__UpdateCoreFromUrlResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetProvisioningMode: + if (p->size < 0) + delete (_sai__GetProvisioningMode*)p->ptr; + else + delete[] (_sai__GetProvisioningMode*)p->ptr; + break; + case SOAP_TYPE__sai__GetProvisioningModeResponse: + if (p->size < 0) + delete (_sai__GetProvisioningModeResponse*)p->ptr; + else + delete[] (_sai__GetProvisioningModeResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetProvisioningMode: + if (p->size < 0) + delete (_sai__SetProvisioningMode*)p->ptr; + else + delete[] (_sai__SetProvisioningMode*)p->ptr; + break; + case SOAP_TYPE__sai__SetProvisioningModeResponse: + if (p->size < 0) + delete (_sai__SetProvisioningModeResponse*)p->ptr; + else + delete[] (_sai__SetProvisioningModeResponse*)p->ptr; + break; + case SOAP_TYPE__sai__Unprovision: + if (p->size < 0) + delete (_sai__Unprovision*)p->ptr; + else + delete[] (_sai__Unprovision*)p->ptr; + break; + case SOAP_TYPE__sai__UnprovisionResponse: + if (p->size < 0) + delete (_sai__UnprovisionResponse*)p->ptr; + else + delete[] (_sai__UnprovisionResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CommitChanges: + if (p->size < 0) + delete (_sai__CommitChanges*)p->ptr; + else + delete[] (_sai__CommitChanges*)p->ptr; + break; + case SOAP_TYPE__sai__CommitChangesResponse: + if (p->size < 0) + delete (_sai__CommitChangesResponse*)p->ptr; + else + delete[] (_sai__CommitChangesResponse*)p->ptr; + break; + case SOAP_TYPE__sai__ResetFlashWearOutProtection: + if (p->size < 0) + delete (_sai__ResetFlashWearOutProtection*)p->ptr; + else + delete[] (_sai__ResetFlashWearOutProtection*)p->ptr; + break; + case SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse: + if (p->size < 0) + delete (_sai__ResetFlashWearOutProtectionResponse*)p->ptr; + else + delete[] (_sai__ResetFlashWearOutProtectionResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetCoreVersion: + if (p->size < 0) + delete (_sai__GetCoreVersion*)p->ptr; + else + delete[] (_sai__GetCoreVersion*)p->ptr; + break; + case SOAP_TYPE__sai__GetCoreVersionResponse: + if (p->size < 0) + delete (_sai__GetCoreVersionResponse*)p->ptr; + else + delete[] (_sai__GetCoreVersionResponse*)p->ptr; + break; + case SOAP_TYPE__sai__AddUserAclEntryEx: + if (p->size < 0) + delete (_sai__AddUserAclEntryEx*)p->ptr; + else + delete[] (_sai__AddUserAclEntryEx*)p->ptr; + break; + case SOAP_TYPE__sai__AddUserAclEntryExResponse: + if (p->size < 0) + delete (_sai__AddUserAclEntryExResponse*)p->ptr; + else + delete[] (_sai__AddUserAclEntryExResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetUserAclEntryEx: + if (p->size < 0) + delete (_sai__GetUserAclEntryEx*)p->ptr; + else + delete[] (_sai__GetUserAclEntryEx*)p->ptr; + break; + case SOAP_TYPE__sai__GetUserAclEntryExResponse: + if (p->size < 0) + delete (_sai__GetUserAclEntryExResponse*)p->ptr; + else + delete[] (_sai__GetUserAclEntryExResponse*)p->ptr; + break; + case SOAP_TYPE__sai__UpdateUserAclEntryEx: + if (p->size < 0) + delete (_sai__UpdateUserAclEntryEx*)p->ptr; + else + delete[] (_sai__UpdateUserAclEntryEx*)p->ptr; + break; + case SOAP_TYPE__sai__UpdateUserAclEntryExResponse: + if (p->size < 0) + delete (_sai__UpdateUserAclEntryExResponse*)p->ptr; + else + delete[] (_sai__UpdateUserAclEntryExResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetAdminAclEntryEx: + if (p->size < 0) + delete (_sai__SetAdminAclEntryEx*)p->ptr; + else + delete[] (_sai__SetAdminAclEntryEx*)p->ptr; + break; + case SOAP_TYPE__sai__SetAdminAclEntryExResponse: + if (p->size < 0) + delete (_sai__SetAdminAclEntryExResponse*)p->ptr; + else + delete[] (_sai__SetAdminAclEntryExResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetDigestRealm: + if (p->size < 0) + delete (_sai__GetDigestRealm*)p->ptr; + else + delete[] (_sai__GetDigestRealm*)p->ptr; + break; + case SOAP_TYPE__sai__GetDigestRealmResponse: + if (p->size < 0) + delete (_sai__GetDigestRealmResponse*)p->ptr; + else + delete[] (_sai__GetDigestRealmResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetKerberosOptions: + if (p->size < 0) + delete (_sai__SetKerberosOptions*)p->ptr; + else + delete[] (_sai__SetKerberosOptions*)p->ptr; + break; + case SOAP_TYPE__sai__SetKerberosOptionsResponse: + if (p->size < 0) + delete (_sai__SetKerberosOptionsResponse*)p->ptr; + else + delete[] (_sai__SetKerberosOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetKerberosOptions: + if (p->size < 0) + delete (_sai__GetKerberosOptions*)p->ptr; + else + delete[] (_sai__GetKerberosOptions*)p->ptr; + break; + case SOAP_TYPE__sai__GetKerberosOptionsResponse: + if (p->size < 0) + delete (_sai__GetKerberosOptionsResponse*)p->ptr; + else + delete[] (_sai__GetKerberosOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetEnabledInterfaces: + if (p->size < 0) + delete (_sai__SetEnabledInterfaces*)p->ptr; + else + delete[] (_sai__SetEnabledInterfaces*)p->ptr; + break; + case SOAP_TYPE__sai__SetEnabledInterfacesResponse: + if (p->size < 0) + delete (_sai__SetEnabledInterfacesResponse*)p->ptr; + else + delete[] (_sai__SetEnabledInterfacesResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetEnabledInterfaces: + if (p->size < 0) + delete (_sai__GetEnabledInterfaces*)p->ptr; + else + delete[] (_sai__GetEnabledInterfaces*)p->ptr; + break; + case SOAP_TYPE__sai__GetEnabledInterfacesResponse: + if (p->size < 0) + delete (_sai__GetEnabledInterfacesResponse*)p->ptr; + else + delete[] (_sai__GetEnabledInterfacesResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetTlsOptions: + if (p->size < 0) + delete (_sai__SetTlsOptions*)p->ptr; + else + delete[] (_sai__SetTlsOptions*)p->ptr; + break; + case SOAP_TYPE__sai__SetTlsOptionsResponse: + if (p->size < 0) + delete (_sai__SetTlsOptionsResponse*)p->ptr; + else + delete[] (_sai__SetTlsOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetTlsOptions: + if (p->size < 0) + delete (_sai__GetTlsOptions*)p->ptr; + else + delete[] (_sai__GetTlsOptions*)p->ptr; + break; + case SOAP_TYPE__sai__GetTlsOptionsResponse: + if (p->size < 0) + delete (_sai__GetTlsOptionsResponse*)p->ptr; + else + delete[] (_sai__GetTlsOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__AddTrustedRootCertificate: + if (p->size < 0) + delete (_sai__AddTrustedRootCertificate*)p->ptr; + else + delete[] (_sai__AddTrustedRootCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__AddTrustedRootCertificateResponse: + if (p->size < 0) + delete (_sai__AddTrustedRootCertificateResponse*)p->ptr; + else + delete[] (_sai__AddTrustedRootCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetTrustedRootCertificate: + if (p->size < 0) + delete (_sai__GetTrustedRootCertificate*)p->ptr; + else + delete[] (_sai__GetTrustedRootCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__GetTrustedRootCertificateResponse: + if (p->size < 0) + delete (_sai__GetTrustedRootCertificateResponse*)p->ptr; + else + delete[] (_sai__GetTrustedRootCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__DeleteTrustedRootCertificate: + if (p->size < 0) + delete (_sai__DeleteTrustedRootCertificate*)p->ptr; + else + delete[] (_sai__DeleteTrustedRootCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse: + if (p->size < 0) + delete (_sai__DeleteTrustedRootCertificateResponse*)p->ptr; + else + delete[] (_sai__DeleteTrustedRootCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__EnumerateTrustedRootCertificates: + if (p->size < 0) + delete (_sai__EnumerateTrustedRootCertificates*)p->ptr; + else + delete[] (_sai__EnumerateTrustedRootCertificates*)p->ptr; + break; + case SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse: + if (p->size < 0) + delete (_sai__EnumerateTrustedRootCertificatesResponse*)p->ptr; + else + delete[] (_sai__EnumerateTrustedRootCertificatesResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetTrustedFqdnCN: + if (p->size < 0) + delete (_sai__SetTrustedFqdnCN*)p->ptr; + else + delete[] (_sai__SetTrustedFqdnCN*)p->ptr; + break; + case SOAP_TYPE__sai__SetTrustedFqdnCNResponse: + if (p->size < 0) + delete (_sai__SetTrustedFqdnCNResponse*)p->ptr; + else + delete[] (_sai__SetTrustedFqdnCNResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetTrustedFqdnCN: + if (p->size < 0) + delete (_sai__GetTrustedFqdnCN*)p->ptr; + else + delete[] (_sai__GetTrustedFqdnCN*)p->ptr; + break; + case SOAP_TYPE__sai__GetTrustedFqdnCNResponse: + if (p->size < 0) + delete (_sai__GetTrustedFqdnCNResponse*)p->ptr; + else + delete[] (_sai__GetTrustedFqdnCNResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetCRL: + if (p->size < 0) + delete (_sai__SetCRL*)p->ptr; + else + delete[] (_sai__SetCRL*)p->ptr; + break; + case SOAP_TYPE__sai__SetCRLResponse: + if (p->size < 0) + delete (_sai__SetCRLResponse*)p->ptr; + else + delete[] (_sai__SetCRLResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetCRL: + if (p->size < 0) + delete (_sai__GetCRL*)p->ptr; + else + delete[] (_sai__GetCRL*)p->ptr; + break; + case SOAP_TYPE__sai__GetCRLResponse: + if (p->size < 0) + delete (_sai__GetCRLResponse*)p->ptr; + else + delete[] (_sai__GetCRLResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetServerCertificateReq: + if (p->size < 0) + delete (_sai__GetServerCertificateReq*)p->ptr; + else + delete[] (_sai__GetServerCertificateReq*)p->ptr; + break; + case SOAP_TYPE__sai__GetServerCertificateReqResponse: + if (p->size < 0) + delete (_sai__GetServerCertificateReqResponse*)p->ptr; + else + delete[] (_sai__GetServerCertificateReqResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetPkiCapabilities: + if (p->size < 0) + delete (_sai__GetPkiCapabilities*)p->ptr; + else + delete[] (_sai__GetPkiCapabilities*)p->ptr; + break; + case SOAP_TYPE__sai__GetPkiCapabilitiesResponse: + if (p->size < 0) + delete (_sai__GetPkiCapabilitiesResponse*)p->ptr; + else + delete[] (_sai__GetPkiCapabilitiesResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetPowerSavingOptions: + if (p->size < 0) + delete (_sai__SetPowerSavingOptions*)p->ptr; + else + delete[] (_sai__SetPowerSavingOptions*)p->ptr; + break; + case SOAP_TYPE__sai__SetPowerSavingOptionsResponse: + if (p->size < 0) + delete (_sai__SetPowerSavingOptionsResponse*)p->ptr; + else + delete[] (_sai__SetPowerSavingOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetPowerSavingOptions: + if (p->size < 0) + delete (_sai__GetPowerSavingOptions*)p->ptr; + else + delete[] (_sai__GetPowerSavingOptions*)p->ptr; + break; + case SOAP_TYPE__sai__GetPowerSavingOptionsResponse: + if (p->size < 0) + delete (_sai__GetPowerSavingOptionsResponse*)p->ptr; + else + delete[] (_sai__GetPowerSavingOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetTLSPSK: + if (p->size < 0) + delete (_sai__SetTLSPSK*)p->ptr; + else + delete[] (_sai__SetTLSPSK*)p->ptr; + break; + case SOAP_TYPE__sai__SetTLSPSKResponse: + if (p->size < 0) + delete (_sai__SetTLSPSKResponse*)p->ptr; + else + delete[] (_sai__SetTLSPSKResponse*)p->ptr; + break; + case SOAP_TYPE__sai__PartialUnprovision: + if (p->size < 0) + delete (_sai__PartialUnprovision*)p->ptr; + else + delete[] (_sai__PartialUnprovision*)p->ptr; + break; + case SOAP_TYPE__sai__PartialUnprovisionResponse: + if (p->size < 0) + delete (_sai__PartialUnprovisionResponse*)p->ptr; + else + delete[] (_sai__PartialUnprovisionResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetMEBxPassword: + if (p->size < 0) + delete (_sai__SetMEBxPassword*)p->ptr; + else + delete[] (_sai__SetMEBxPassword*)p->ptr; + break; + case SOAP_TYPE__sai__SetMEBxPasswordResponse: + if (p->size < 0) + delete (_sai__SetMEBxPasswordResponse*)p->ptr; + else + delete[] (_sai__SetMEBxPasswordResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetProvisioningServerOTP: + if (p->size < 0) + delete (_sai__SetProvisioningServerOTP*)p->ptr; + else + delete[] (_sai__SetProvisioningServerOTP*)p->ptr; + break; + case SOAP_TYPE__sai__SetProvisioningServerOTPResponse: + if (p->size < 0) + delete (_sai__SetProvisioningServerOTPResponse*)p->ptr; + else + delete[] (_sai__SetProvisioningServerOTPResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetProvisioningServerOTP: + if (p->size < 0) + delete (_sai__GetProvisioningServerOTP*)p->ptr; + else + delete[] (_sai__GetProvisioningServerOTP*)p->ptr; + break; + case SOAP_TYPE__sai__GetProvisioningServerOTPResponse: + if (p->size < 0) + delete (_sai__GetProvisioningServerOTPResponse*)p->ptr; + else + delete[] (_sai__GetProvisioningServerOTPResponse*)p->ptr; + break; + case SOAP_TYPE__sai__EnumerateCertificateHashEntries: + if (p->size < 0) + delete (_sai__EnumerateCertificateHashEntries*)p->ptr; + else + delete[] (_sai__EnumerateCertificateHashEntries*)p->ptr; + break; + case SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse: + if (p->size < 0) + delete (_sai__EnumerateCertificateHashEntriesResponse*)p->ptr; + else + delete[] (_sai__EnumerateCertificateHashEntriesResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetCertificateHashEntry: + if (p->size < 0) + delete (_sai__GetCertificateHashEntry*)p->ptr; + else + delete[] (_sai__GetCertificateHashEntry*)p->ptr; + break; + case SOAP_TYPE__sai__GetCertificateHashEntryResponse: + if (p->size < 0) + delete (_sai__GetCertificateHashEntryResponse*)p->ptr; + else + delete[] (_sai__GetCertificateHashEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__AddCertificateHashEntry: + if (p->size < 0) + delete (_sai__AddCertificateHashEntry*)p->ptr; + else + delete[] (_sai__AddCertificateHashEntry*)p->ptr; + break; + case SOAP_TYPE__sai__AddCertificateHashEntryResponse: + if (p->size < 0) + delete (_sai__AddCertificateHashEntryResponse*)p->ptr; + else + delete[] (_sai__AddCertificateHashEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__DeleteCertificateHashEntry: + if (p->size < 0) + delete (_sai__DeleteCertificateHashEntry*)p->ptr; + else + delete[] (_sai__DeleteCertificateHashEntry*)p->ptr; + break; + case SOAP_TYPE__sai__DeleteCertificateHashEntryResponse: + if (p->size < 0) + delete (_sai__DeleteCertificateHashEntryResponse*)p->ptr; + else + delete[] (_sai__DeleteCertificateHashEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__EnableCertificateHashEntry: + if (p->size < 0) + delete (_sai__EnableCertificateHashEntry*)p->ptr; + else + delete[] (_sai__EnableCertificateHashEntry*)p->ptr; + break; + case SOAP_TYPE__sai__EnableCertificateHashEntryResponse: + if (p->size < 0) + delete (_sai__EnableCertificateHashEntryResponse*)p->ptr; + else + delete[] (_sai__EnableCertificateHashEntryResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetZeroTouchConfigurationMode: + if (p->size < 0) + delete (_sai__GetZeroTouchConfigurationMode*)p->ptr; + else + delete[] (_sai__GetZeroTouchConfigurationMode*)p->ptr; + break; + case SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse: + if (p->size < 0) + delete (_sai__GetZeroTouchConfigurationModeResponse*)p->ptr; + else + delete[] (_sai__GetZeroTouchConfigurationModeResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetZeroTouchConfigurationMode: + if (p->size < 0) + delete (_sai__SetZeroTouchConfigurationMode*)p->ptr; + else + delete[] (_sai__SetZeroTouchConfigurationMode*)p->ptr; + break; + case SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse: + if (p->size < 0) + delete (_sai__SetZeroTouchConfigurationModeResponse*)p->ptr; + else + delete[] (_sai__SetZeroTouchConfigurationModeResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetProvisioningAuditRecord: + if (p->size < 0) + delete (_sai__GetProvisioningAuditRecord*)p->ptr; + else + delete[] (_sai__GetProvisioningAuditRecord*)p->ptr; + break; + case SOAP_TYPE__sai__GetProvisioningAuditRecordResponse: + if (p->size < 0) + delete (_sai__GetProvisioningAuditRecordResponse*)p->ptr; + else + delete[] (_sai__GetProvisioningAuditRecordResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetProvisioningPID: + if (p->size < 0) + delete (_sai__GetProvisioningPID*)p->ptr; + else + delete[] (_sai__GetProvisioningPID*)p->ptr; + break; + case SOAP_TYPE__sai__GetProvisioningPIDResponse: + if (p->size < 0) + delete (_sai__GetProvisioningPIDResponse*)p->ptr; + else + delete[] (_sai__GetProvisioningPIDResponse*)p->ptr; + break; + case SOAP_TYPE__sai__ExtendProvisioningPeriod: + if (p->size < 0) + delete (_sai__ExtendProvisioningPeriod*)p->ptr; + else + delete[] (_sai__ExtendProvisioningPeriod*)p->ptr; + break; + case SOAP_TYPE__sai__ExtendProvisioningPeriodResponse: + if (p->size < 0) + delete (_sai__ExtendProvisioningPeriodResponse*)p->ptr; + else + delete[] (_sai__ExtendProvisioningPeriodResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetRealmAuthOptions: + if (p->size < 0) + delete (_sai__GetRealmAuthOptions*)p->ptr; + else + delete[] (_sai__GetRealmAuthOptions*)p->ptr; + break; + case SOAP_TYPE__sai__GetRealmAuthOptionsResponse: + if (p->size < 0) + delete (_sai__GetRealmAuthOptionsResponse*)p->ptr; + else + delete[] (_sai__GetRealmAuthOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetRealmAuthOptions: + if (p->size < 0) + delete (_sai__SetRealmAuthOptions*)p->ptr; + else + delete[] (_sai__SetRealmAuthOptions*)p->ptr; + break; + case SOAP_TYPE__sai__SetRealmAuthOptionsResponse: + if (p->size < 0) + delete (_sai__SetRealmAuthOptionsResponse*)p->ptr; + else + delete[] (_sai__SetRealmAuthOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetEnvironmentDetection: + if (p->size < 0) + delete (_sai__SetEnvironmentDetection*)p->ptr; + else + delete[] (_sai__SetEnvironmentDetection*)p->ptr; + break; + case SOAP_TYPE__sai__SetEnvironmentDetectionResponse: + if (p->size < 0) + delete (_sai__SetEnvironmentDetectionResponse*)p->ptr; + else + delete[] (_sai__SetEnvironmentDetectionResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetEnvironmentDetection: + if (p->size < 0) + delete (_sai__GetEnvironmentDetection*)p->ptr; + else + delete[] (_sai__GetEnvironmentDetection*)p->ptr; + break; + case SOAP_TYPE__sai__GetEnvironmentDetectionResponse: + if (p->size < 0) + delete (_sai__GetEnvironmentDetectionResponse*)p->ptr; + else + delete[] (_sai__GetEnvironmentDetectionResponse*)p->ptr; + break; + case SOAP_TYPE__sai__EnumeratePowerPackages: + if (p->size < 0) + delete (_sai__EnumeratePowerPackages*)p->ptr; + else + delete[] (_sai__EnumeratePowerPackages*)p->ptr; + break; + case SOAP_TYPE__sai__EnumeratePowerPackagesResponse: + if (p->size < 0) + delete (_sai__EnumeratePowerPackagesResponse*)p->ptr; + else + delete[] (_sai__EnumeratePowerPackagesResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetActivePowerPackage: + if (p->size < 0) + delete (_sai__GetActivePowerPackage*)p->ptr; + else + delete[] (_sai__GetActivePowerPackage*)p->ptr; + break; + case SOAP_TYPE__sai__GetActivePowerPackageResponse: + if (p->size < 0) + delete (_sai__GetActivePowerPackageResponse*)p->ptr; + else + delete[] (_sai__GetActivePowerPackageResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetPowerPackage: + if (p->size < 0) + delete (_sai__GetPowerPackage*)p->ptr; + else + delete[] (_sai__GetPowerPackage*)p->ptr; + break; + case SOAP_TYPE__sai__GetPowerPackageResponse: + if (p->size < 0) + delete (_sai__GetPowerPackageResponse*)p->ptr; + else + delete[] (_sai__GetPowerPackageResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetActivePowerPackage: + if (p->size < 0) + delete (_sai__SetActivePowerPackage*)p->ptr; + else + delete[] (_sai__SetActivePowerPackage*)p->ptr; + break; + case SOAP_TYPE__sai__SetActivePowerPackageResponse: + if (p->size < 0) + delete (_sai__SetActivePowerPackageResponse*)p->ptr; + else + delete[] (_sai__SetActivePowerPackageResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetGlobalPowerPolicy: + if (p->size < 0) + delete (_sai__SetGlobalPowerPolicy*)p->ptr; + else + delete[] (_sai__SetGlobalPowerPolicy*)p->ptr; + break; + case SOAP_TYPE__sai__SetGlobalPowerPolicyResponse: + if (p->size < 0) + delete (_sai__SetGlobalPowerPolicyResponse*)p->ptr; + else + delete[] (_sai__SetGlobalPowerPolicyResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetGlobalPowerPolicy: + if (p->size < 0) + delete (_sai__GetGlobalPowerPolicy*)p->ptr; + else + delete[] (_sai__GetGlobalPowerPolicy*)p->ptr; + break; + case SOAP_TYPE__sai__GetGlobalPowerPolicyResponse: + if (p->size < 0) + delete (_sai__GetGlobalPowerPolicyResponse*)p->ptr; + else + delete[] (_sai__GetGlobalPowerPolicyResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreAddKey: + if (p->size < 0) + delete (_sai__CertStoreAddKey*)p->ptr; + else + delete[] (_sai__CertStoreAddKey*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreAddKeyResponse: + if (p->size < 0) + delete (_sai__CertStoreAddKeyResponse*)p->ptr; + else + delete[] (_sai__CertStoreAddKeyResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreEnumerateKeys: + if (p->size < 0) + delete (_sai__CertStoreEnumerateKeys*)p->ptr; + else + delete[] (_sai__CertStoreEnumerateKeys*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreEnumerateKeysResponse: + if (p->size < 0) + delete (_sai__CertStoreEnumerateKeysResponse*)p->ptr; + else + delete[] (_sai__CertStoreEnumerateKeysResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreGetKey: + if (p->size < 0) + delete (_sai__CertStoreGetKey*)p->ptr; + else + delete[] (_sai__CertStoreGetKey*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreGetKeyResponse: + if (p->size < 0) + delete (_sai__CertStoreGetKeyResponse*)p->ptr; + else + delete[] (_sai__CertStoreGetKeyResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreRemoveKey: + if (p->size < 0) + delete (_sai__CertStoreRemoveKey*)p->ptr; + else + delete[] (_sai__CertStoreRemoveKey*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreRemoveKeyResponse: + if (p->size < 0) + delete (_sai__CertStoreRemoveKeyResponse*)p->ptr; + else + delete[] (_sai__CertStoreRemoveKeyResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreAddCertificate: + if (p->size < 0) + delete (_sai__CertStoreAddCertificate*)p->ptr; + else + delete[] (_sai__CertStoreAddCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreAddCertificateResponse: + if (p->size < 0) + delete (_sai__CertStoreAddCertificateResponse*)p->ptr; + else + delete[] (_sai__CertStoreAddCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreEnumerateCertificates: + if (p->size < 0) + delete (_sai__CertStoreEnumerateCertificates*)p->ptr; + else + delete[] (_sai__CertStoreEnumerateCertificates*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse: + if (p->size < 0) + delete (_sai__CertStoreEnumerateCertificatesResponse*)p->ptr; + else + delete[] (_sai__CertStoreEnumerateCertificatesResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreGetCertificate: + if (p->size < 0) + delete (_sai__CertStoreGetCertificate*)p->ptr; + else + delete[] (_sai__CertStoreGetCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreGetCertificateResponse: + if (p->size < 0) + delete (_sai__CertStoreGetCertificateResponse*)p->ptr; + else + delete[] (_sai__CertStoreGetCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreRemoveCertificate: + if (p->size < 0) + delete (_sai__CertStoreRemoveCertificate*)p->ptr; + else + delete[] (_sai__CertStoreRemoveCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreRemoveCertificateResponse: + if (p->size < 0) + delete (_sai__CertStoreRemoveCertificateResponse*)p->ptr; + else + delete[] (_sai__CertStoreRemoveCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreGetPKCS10Request: + if (p->size < 0) + delete (_sai__CertStoreGetPKCS10Request*)p->ptr; + else + delete[] (_sai__CertStoreGetPKCS10Request*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse: + if (p->size < 0) + delete (_sai__CertStoreGetPKCS10RequestResponse*)p->ptr; + else + delete[] (_sai__CertStoreGetPKCS10RequestResponse*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreUpdateCertificate: + if (p->size < 0) + delete (_sai__CertStoreUpdateCertificate*)p->ptr; + else + delete[] (_sai__CertStoreUpdateCertificate*)p->ptr; + break; + case SOAP_TYPE__sai__CertStoreUpdateCertificateResponse: + if (p->size < 0) + delete (_sai__CertStoreUpdateCertificateResponse*)p->ptr; + else + delete[] (_sai__CertStoreUpdateCertificateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetTLSCredentials: + if (p->size < 0) + delete (_sai__SetTLSCredentials*)p->ptr; + else + delete[] (_sai__SetTLSCredentials*)p->ptr; + break; + case SOAP_TYPE__sai__SetTLSCredentialsResponse: + if (p->size < 0) + delete (_sai__SetTLSCredentialsResponse*)p->ptr; + else + delete[] (_sai__SetTLSCredentialsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetTLSCredentials: + if (p->size < 0) + delete (_sai__GetTLSCredentials*)p->ptr; + else + delete[] (_sai__GetTLSCredentials*)p->ptr; + break; + case SOAP_TYPE__sai__GetTLSCredentialsResponse: + if (p->size < 0) + delete (_sai__GetTLSCredentialsResponse*)p->ptr; + else + delete[] (_sai__GetTLSCredentialsResponse*)p->ptr; + break; + case SOAP_TYPE__sai__EnableVpnRouting: + if (p->size < 0) + delete (_sai__EnableVpnRouting*)p->ptr; + else + delete[] (_sai__EnableVpnRouting*)p->ptr; + break; + case SOAP_TYPE__sai__EnableVpnRoutingResponse: + if (p->size < 0) + delete (_sai__EnableVpnRoutingResponse*)p->ptr; + else + delete[] (_sai__EnableVpnRoutingResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetConfigurationServerFQDN: + if (p->size < 0) + delete (_sai__SetConfigurationServerFQDN*)p->ptr; + else + delete[] (_sai__SetConfigurationServerFQDN*)p->ptr; + break; + case SOAP_TYPE__sai__SetConfigurationServerFQDNResponse: + if (p->size < 0) + delete (_sai__SetConfigurationServerFQDNResponse*)p->ptr; + else + delete[] (_sai__SetConfigurationServerFQDNResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetConfigurationServerFQDN: + if (p->size < 0) + delete (_sai__GetConfigurationServerFQDN*)p->ptr; + else + delete[] (_sai__GetConfigurationServerFQDN*)p->ptr; + break; + case SOAP_TYPE__sai__GetConfigurationServerFQDNResponse: + if (p->size < 0) + delete (_sai__GetConfigurationServerFQDNResponse*)p->ptr; + else + delete[] (_sai__GetConfigurationServerFQDNResponse*)p->ptr; + break; + case SOAP_TYPE__sai__SetAclEnabledState: + if (p->size < 0) + delete (_sai__SetAclEnabledState*)p->ptr; + else + delete[] (_sai__SetAclEnabledState*)p->ptr; + break; + case SOAP_TYPE__sai__SetAclEnabledStateResponse: + if (p->size < 0) + delete (_sai__SetAclEnabledStateResponse*)p->ptr; + else + delete[] (_sai__SetAclEnabledStateResponse*)p->ptr; + break; + case SOAP_TYPE__sai__GetAclEnabledState: + if (p->size < 0) + delete (_sai__GetAclEnabledState*)p->ptr; + else + delete[] (_sai__GetAclEnabledState*)p->ptr; + break; + case SOAP_TYPE__sai__GetAclEnabledStateResponse: + if (p->size < 0) + delete (_sai__GetAclEnabledStateResponse*)p->ptr; + else + delete[] (_sai__GetAclEnabledStateResponse*)p->ptr; + break; + case SOAP_TYPE_xcfg__UserCredentialsType: + if (p->size < 0) + delete (xcfg__UserCredentialsType*)p->ptr; + else + delete[] (xcfg__UserCredentialsType*)p->ptr; + break; + case SOAP_TYPE_xcfg__CertificateNameType: + if (p->size < 0) + delete (xcfg__CertificateNameType*)p->ptr; + else + delete[] (xcfg__CertificateNameType*)p->ptr; + break; + case SOAP_TYPE_xcfg__ManualPACType: + if (p->size < 0) + delete (xcfg__ManualPACType*)p->ptr; + else + delete[] (xcfg__ManualPACType*)p->ptr; + break; + case SOAP_TYPE_xcfg__ServerIdentityType: + if (p->size < 0) + delete (xcfg__ServerIdentityType*)p->ptr; + else + delete[] (xcfg__ServerIdentityType*)p->ptr; + break; + case SOAP_TYPE_xcfg__XProfileTLSType: + if (p->size < 0) + delete (xcfg__XProfileTLSType*)p->ptr; + else + delete[] (xcfg__XProfileTLSType*)p->ptr; + break; + case SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type: + if (p->size < 0) + delete (xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)p->ptr; + else + delete[] (xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)p->ptr; + break; + case SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type: + if (p->size < 0) + delete (xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)p->ptr; + else + delete[] (xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)p->ptr; + break; + case SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType: + if (p->size < 0) + delete (xcfg__XProfileEAP_USCOREGTCType*)p->ptr; + else + delete[] (xcfg__XProfileEAP_USCOREGTCType*)p->ptr; + break; + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type: + if (p->size < 0) + delete (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)p->ptr; + else + delete[] (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)p->ptr; + break; + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType: + if (p->size < 0) + delete (xcfg__XProfileEAPFAST_USCOREGTCType*)p->ptr; + else + delete[] (xcfg__XProfileEAPFAST_USCOREGTCType*)p->ptr; + break; + case SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType: + if (p->size < 0) + delete (xcfg__XProfileEAPFAST_USCORETLSType*)p->ptr; + else + delete[] (xcfg__XProfileEAPFAST_USCORETLSType*)p->ptr; + break; + case SOAP_TYPE_xcfg__XProfileType: + if (p->size < 0) + delete (xcfg__XProfileType*)p->ptr; + else + delete[] (xcfg__XProfileType*)p->ptr; + break; + case SOAP_TYPE_net__StaticIPv4ParametersType: + if (p->size < 0) + delete (net__StaticIPv4ParametersType*)p->ptr; + else + delete[] (net__StaticIPv4ParametersType*)p->ptr; + break; + case SOAP_TYPE_net__IPv4ParametersType: + if (p->size < 0) + delete (net__IPv4ParametersType*)p->ptr; + else + delete[] (net__IPv4ParametersType*)p->ptr; + break; + case SOAP_TYPE_net__InterfaceDescriptorSetType: + if (p->size < 0) + delete (net__InterfaceDescriptorSetType*)p->ptr; + else + delete[] (net__InterfaceDescriptorSetType*)p->ptr; + break; + case SOAP_TYPE_net__InterfaceDescriptorGetType: + if (p->size < 0) + delete (net__InterfaceDescriptorGetType*)p->ptr; + else + delete[] (net__InterfaceDescriptorGetType*)p->ptr; + break; + case SOAP_TYPE__net__SetHostName: + if (p->size < 0) + delete (_net__SetHostName*)p->ptr; + else + delete[] (_net__SetHostName*)p->ptr; + break; + case SOAP_TYPE__net__SetHostNameResponse: + if (p->size < 0) + delete (_net__SetHostNameResponse*)p->ptr; + else + delete[] (_net__SetHostNameResponse*)p->ptr; + break; + case SOAP_TYPE__net__GetHostName: + if (p->size < 0) + delete (_net__GetHostName*)p->ptr; + else + delete[] (_net__GetHostName*)p->ptr; + break; + case SOAP_TYPE__net__GetHostNameResponse: + if (p->size < 0) + delete (_net__GetHostNameResponse*)p->ptr; + else + delete[] (_net__GetHostNameResponse*)p->ptr; + break; + case SOAP_TYPE__net__SetDomainName: + if (p->size < 0) + delete (_net__SetDomainName*)p->ptr; + else + delete[] (_net__SetDomainName*)p->ptr; + break; + case SOAP_TYPE__net__SetDomainNameResponse: + if (p->size < 0) + delete (_net__SetDomainNameResponse*)p->ptr; + else + delete[] (_net__SetDomainNameResponse*)p->ptr; + break; + case SOAP_TYPE__net__GetDomainName: + if (p->size < 0) + delete (_net__GetDomainName*)p->ptr; + else + delete[] (_net__GetDomainName*)p->ptr; + break; + case SOAP_TYPE__net__GetDomainNameResponse: + if (p->size < 0) + delete (_net__GetDomainNameResponse*)p->ptr; + else + delete[] (_net__GetDomainNameResponse*)p->ptr; + break; + case SOAP_TYPE__net__SetTcpIpParameters: + if (p->size < 0) + delete (_net__SetTcpIpParameters*)p->ptr; + else + delete[] (_net__SetTcpIpParameters*)p->ptr; + break; + case SOAP_TYPE__net__SetTcpIpParametersResponse: + if (p->size < 0) + delete (_net__SetTcpIpParametersResponse*)p->ptr; + else + delete[] (_net__SetTcpIpParametersResponse*)p->ptr; + break; + case SOAP_TYPE__net__GetTcpIpParameters: + if (p->size < 0) + delete (_net__GetTcpIpParameters*)p->ptr; + else + delete[] (_net__GetTcpIpParameters*)p->ptr; + break; + case SOAP_TYPE__net__GetTcpIpParametersResponse: + if (p->size < 0) + delete (_net__GetTcpIpParametersResponse*)p->ptr; + else + delete[] (_net__GetTcpIpParametersResponse*)p->ptr; + break; + case SOAP_TYPE__net__SetVlanParameters: + if (p->size < 0) + delete (_net__SetVlanParameters*)p->ptr; + else + delete[] (_net__SetVlanParameters*)p->ptr; + break; + case SOAP_TYPE__net__SetVlanParametersResponse: + if (p->size < 0) + delete (_net__SetVlanParametersResponse*)p->ptr; + else + delete[] (_net__SetVlanParametersResponse*)p->ptr; + break; + case SOAP_TYPE__net__GetVlanParameters: + if (p->size < 0) + delete (_net__GetVlanParameters*)p->ptr; + else + delete[] (_net__GetVlanParameters*)p->ptr; + break; + case SOAP_TYPE__net__GetVlanParametersResponse: + if (p->size < 0) + delete (_net__GetVlanParametersResponse*)p->ptr; + else + delete[] (_net__GetVlanParametersResponse*)p->ptr; + break; + case SOAP_TYPE__net__SetPingResponse: + if (p->size < 0) + delete (_net__SetPingResponse*)p->ptr; + else + delete[] (_net__SetPingResponse*)p->ptr; + break; + case SOAP_TYPE__net__SetPingResponseResponse: + if (p->size < 0) + delete (_net__SetPingResponseResponse*)p->ptr; + else + delete[] (_net__SetPingResponseResponse*)p->ptr; + break; + case SOAP_TYPE__net__GetPingResponse: + if (p->size < 0) + delete (_net__GetPingResponse*)p->ptr; + else + delete[] (_net__GetPingResponse*)p->ptr; + break; + case SOAP_TYPE__net__GetPingResponseResponse: + if (p->size < 0) + delete (_net__GetPingResponseResponse*)p->ptr; + else + delete[] (_net__GetPingResponseResponse*)p->ptr; + break; + case SOAP_TYPE__net__EnumerateInterfaces: + if (p->size < 0) + delete (_net__EnumerateInterfaces*)p->ptr; + else + delete[] (_net__EnumerateInterfaces*)p->ptr; + break; + case SOAP_TYPE__net__EnumerateInterfacesResponse: + if (p->size < 0) + delete (_net__EnumerateInterfacesResponse*)p->ptr; + else + delete[] (_net__EnumerateInterfacesResponse*)p->ptr; + break; + case SOAP_TYPE__net__GetInterfaceSettings: + if (p->size < 0) + delete (_net__GetInterfaceSettings*)p->ptr; + else + delete[] (_net__GetInterfaceSettings*)p->ptr; + break; + case SOAP_TYPE__net__GetInterfaceSettingsResponse: + if (p->size < 0) + delete (_net__GetInterfaceSettingsResponse*)p->ptr; + else + delete[] (_net__GetInterfaceSettingsResponse*)p->ptr; + break; + case SOAP_TYPE__net__SetInterfaceSettings: + if (p->size < 0) + delete (_net__SetInterfaceSettings*)p->ptr; + else + delete[] (_net__SetInterfaceSettings*)p->ptr; + break; + case SOAP_TYPE__net__SetInterfaceSettingsResponse: + if (p->size < 0) + delete (_net__SetInterfaceSettingsResponse*)p->ptr; + else + delete[] (_net__SetInterfaceSettingsResponse*)p->ptr; + break; + case SOAP_TYPE__net__Get8021XWiredProfile: + if (p->size < 0) + delete (_net__Get8021XWiredProfile*)p->ptr; + else + delete[] (_net__Get8021XWiredProfile*)p->ptr; + break; + case SOAP_TYPE__net__Get8021XWiredProfileResponse: + if (p->size < 0) + delete (_net__Get8021XWiredProfileResponse*)p->ptr; + else + delete[] (_net__Get8021XWiredProfileResponse*)p->ptr; + break; + case SOAP_TYPE__net__Set8021XWiredProfile: + if (p->size < 0) + delete (_net__Set8021XWiredProfile*)p->ptr; + else + delete[] (_net__Set8021XWiredProfile*)p->ptr; + break; + case SOAP_TYPE__net__Set8021XWiredProfileResponse: + if (p->size < 0) + delete (_net__Set8021XWiredProfileResponse*)p->ptr; + else + delete[] (_net__Set8021XWiredProfileResponse*)p->ptr; + break; + case SOAP_TYPE__net__Set8021XActiveS0: + if (p->size < 0) + delete (_net__Set8021XActiveS0*)p->ptr; + else + delete[] (_net__Set8021XActiveS0*)p->ptr; + break; + case SOAP_TYPE__net__Set8021XActiveS0Response: + if (p->size < 0) + delete (_net__Set8021XActiveS0Response*)p->ptr; + else + delete[] (_net__Set8021XActiveS0Response*)p->ptr; + break; + case SOAP_TYPE__net__Get8021XActiveS0: + if (p->size < 0) + delete (_net__Get8021XActiveS0*)p->ptr; + else + delete[] (_net__Get8021XActiveS0*)p->ptr; + break; + case SOAP_TYPE__net__Get8021XActiveS0Response: + if (p->size < 0) + delete (_net__Get8021XActiveS0Response*)p->ptr; + else + delete[] (_net__Get8021XActiveS0Response*)p->ptr; + break; + case SOAP_TYPE__net__Set8021XPxeTimeout: + if (p->size < 0) + delete (_net__Set8021XPxeTimeout*)p->ptr; + else + delete[] (_net__Set8021XPxeTimeout*)p->ptr; + break; + case SOAP_TYPE__net__Set8021XPxeTimeoutResponse: + if (p->size < 0) + delete (_net__Set8021XPxeTimeoutResponse*)p->ptr; + else + delete[] (_net__Set8021XPxeTimeoutResponse*)p->ptr; + break; + case SOAP_TYPE__net__Get8021XPxeTimeout: + if (p->size < 0) + delete (_net__Get8021XPxeTimeout*)p->ptr; + else + delete[] (_net__Get8021XPxeTimeout*)p->ptr; + break; + case SOAP_TYPE__net__Get8021XPxeTimeoutResponse: + if (p->size < 0) + delete (_net__Get8021XPxeTimeoutResponse*)p->ptr; + else + delete[] (_net__Get8021XPxeTimeoutResponse*)p->ptr; + break; + case SOAP_TYPE_stra__StorageEaclEntryType: + if (p->size < 0) + delete (stra__StorageEaclEntryType*)p->ptr; + else + delete[] (stra__StorageEaclEntryType*)p->ptr; + break; + case SOAP_TYPE_stra__StorageEaclEntryHandleListType: + if (p->size < 0) + delete (stra__StorageEaclEntryHandleListType*)p->ptr; + else + delete[] (stra__StorageEaclEntryHandleListType*)p->ptr; + break; + case SOAP_TYPE_stra__StorageAllocEntryType: + if (p->size < 0) + delete (stra__StorageAllocEntryType*)p->ptr; + else + delete[] (stra__StorageAllocEntryType*)p->ptr; + break; + case SOAP_TYPE_stra__StorageAllocSnrpEntryType: + if (p->size < 0) + delete (stra__StorageAllocSnrpEntryType*)p->ptr; + else + delete[] (stra__StorageAllocSnrpEntryType*)p->ptr; + break; + case SOAP_TYPE_stra__StorageAllocEntryHandleListType: + if (p->size < 0) + delete (stra__StorageAllocEntryHandleListType*)p->ptr; + else + delete[] (stra__StorageAllocEntryHandleListType*)p->ptr; + break; + case SOAP_TYPE_stra__GUID: + if (p->size < 0) + delete (stra__GUID*)p->ptr; + else + delete[] (stra__GUID*)p->ptr; + break; + case SOAP_TYPE_stra__GlobalStorageAttributesType: + if (p->size < 0) + delete (stra__GlobalStorageAttributesType*)p->ptr; + else + delete[] (stra__GlobalStorageAttributesType*)p->ptr; + break; + case SOAP_TYPE_stra__StorageApplicationHandleListType: + if (p->size < 0) + delete (stra__StorageApplicationHandleListType*)p->ptr; + else + delete[] (stra__StorageApplicationHandleListType*)p->ptr; + break; + case SOAP_TYPE_stra__StorageSnrpApplicationAttributeType: + if (p->size < 0) + delete (stra__StorageSnrpApplicationAttributeType*)p->ptr; + else + delete[] (stra__StorageSnrpApplicationAttributeType*)p->ptr; + break; + case SOAP_TYPE_stra__StorageApplicationAttributesType: + if (p->size < 0) + delete (stra__StorageApplicationAttributesType*)p->ptr; + else + delete[] (stra__StorageApplicationAttributesType*)p->ptr; + break; + case SOAP_TYPE__stra__GetGlobalStorageAttributes: + if (p->size < 0) + delete (_stra__GetGlobalStorageAttributes*)p->ptr; + else + delete[] (_stra__GetGlobalStorageAttributes*)p->ptr; + break; + case SOAP_TYPE__stra__GetGlobalStorageAttributesResponse: + if (p->size < 0) + delete (_stra__GetGlobalStorageAttributesResponse*)p->ptr; + else + delete[] (_stra__GetGlobalStorageAttributesResponse*)p->ptr; + break; + case SOAP_TYPE__stra__SetGlobalStorageAttributes: + if (p->size < 0) + delete (_stra__SetGlobalStorageAttributes*)p->ptr; + else + delete[] (_stra__SetGlobalStorageAttributes*)p->ptr; + break; + case SOAP_TYPE__stra__SetGlobalStorageAttributesResponse: + if (p->size < 0) + delete (_stra__SetGlobalStorageAttributesResponse*)p->ptr; + else + delete[] (_stra__SetGlobalStorageAttributesResponse*)p->ptr; + break; + case SOAP_TYPE__stra__AdminGetRegisteredApplications: + if (p->size < 0) + delete (_stra__AdminGetRegisteredApplications*)p->ptr; + else + delete[] (_stra__AdminGetRegisteredApplications*)p->ptr; + break; + case SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse: + if (p->size < 0) + delete (_stra__AdminGetRegisteredApplicationsResponse*)p->ptr; + else + delete[] (_stra__AdminGetRegisteredApplicationsResponse*)p->ptr; + break; + case SOAP_TYPE__stra__AdminGetApplicationAttributes: + if (p->size < 0) + delete (_stra__AdminGetApplicationAttributes*)p->ptr; + else + delete[] (_stra__AdminGetApplicationAttributes*)p->ptr; + break; + case SOAP_TYPE__stra__AdminGetApplicationAttributesResponse: + if (p->size < 0) + delete (_stra__AdminGetApplicationAttributesResponse*)p->ptr; + else + delete[] (_stra__AdminGetApplicationAttributesResponse*)p->ptr; + break; + case SOAP_TYPE__stra__AdminRemoveApplication: + if (p->size < 0) + delete (_stra__AdminRemoveApplication*)p->ptr; + else + delete[] (_stra__AdminRemoveApplication*)p->ptr; + break; + case SOAP_TYPE__stra__AdminRemoveApplicationResponse: + if (p->size < 0) + delete (_stra__AdminRemoveApplicationResponse*)p->ptr; + else + delete[] (_stra__AdminRemoveApplicationResponse*)p->ptr; + break; + case SOAP_TYPE__stra__AddStorageEaclEntry: + if (p->size < 0) + delete (_stra__AddStorageEaclEntry*)p->ptr; + else + delete[] (_stra__AddStorageEaclEntry*)p->ptr; + break; + case SOAP_TYPE__stra__AddStorageEaclEntryResponse: + if (p->size < 0) + delete (_stra__AddStorageEaclEntryResponse*)p->ptr; + else + delete[] (_stra__AddStorageEaclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__stra__EnumerateStorageEaclEntries: + if (p->size < 0) + delete (_stra__EnumerateStorageEaclEntries*)p->ptr; + else + delete[] (_stra__EnumerateStorageEaclEntries*)p->ptr; + break; + case SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse: + if (p->size < 0) + delete (_stra__EnumerateStorageEaclEntriesResponse*)p->ptr; + else + delete[] (_stra__EnumerateStorageEaclEntriesResponse*)p->ptr; + break; + case SOAP_TYPE__stra__GetStorageEaclEntry: + if (p->size < 0) + delete (_stra__GetStorageEaclEntry*)p->ptr; + else + delete[] (_stra__GetStorageEaclEntry*)p->ptr; + break; + case SOAP_TYPE__stra__GetStorageEaclEntryResponse: + if (p->size < 0) + delete (_stra__GetStorageEaclEntryResponse*)p->ptr; + else + delete[] (_stra__GetStorageEaclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__stra__RemoveStorageEaclEntry: + if (p->size < 0) + delete (_stra__RemoveStorageEaclEntry*)p->ptr; + else + delete[] (_stra__RemoveStorageEaclEntry*)p->ptr; + break; + case SOAP_TYPE__stra__RemoveStorageEaclEntryResponse: + if (p->size < 0) + delete (_stra__RemoveStorageEaclEntryResponse*)p->ptr; + else + delete[] (_stra__RemoveStorageEaclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__stra__AddStorageFpaclEntry: + if (p->size < 0) + delete (_stra__AddStorageFpaclEntry*)p->ptr; + else + delete[] (_stra__AddStorageFpaclEntry*)p->ptr; + break; + case SOAP_TYPE__stra__AddStorageFpaclEntryResponse: + if (p->size < 0) + delete (_stra__AddStorageFpaclEntryResponse*)p->ptr; + else + delete[] (_stra__AddStorageFpaclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__stra__EnumerateStorageAllocEntries: + if (p->size < 0) + delete (_stra__EnumerateStorageAllocEntries*)p->ptr; + else + delete[] (_stra__EnumerateStorageAllocEntries*)p->ptr; + break; + case SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse: + if (p->size < 0) + delete (_stra__EnumerateStorageAllocEntriesResponse*)p->ptr; + else + delete[] (_stra__EnumerateStorageAllocEntriesResponse*)p->ptr; + break; + case SOAP_TYPE__stra__GetStorageAllocEntry: + if (p->size < 0) + delete (_stra__GetStorageAllocEntry*)p->ptr; + else + delete[] (_stra__GetStorageAllocEntry*)p->ptr; + break; + case SOAP_TYPE__stra__GetStorageAllocEntryResponse: + if (p->size < 0) + delete (_stra__GetStorageAllocEntryResponse*)p->ptr; + else + delete[] (_stra__GetStorageAllocEntryResponse*)p->ptr; + break; + case SOAP_TYPE__stra__UpdateStorageFpaclEntry: + if (p->size < 0) + delete (_stra__UpdateStorageFpaclEntry*)p->ptr; + else + delete[] (_stra__UpdateStorageFpaclEntry*)p->ptr; + break; + case SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse: + if (p->size < 0) + delete (_stra__UpdateStorageFpaclEntryResponse*)p->ptr; + else + delete[] (_stra__UpdateStorageFpaclEntryResponse*)p->ptr; + break; + case SOAP_TYPE__stra__RemoveStorageFpaclEntry: + if (p->size < 0) + delete (_stra__RemoveStorageFpaclEntry*)p->ptr; + else + delete[] (_stra__RemoveStorageFpaclEntry*)p->ptr; + break; + case SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse: + if (p->size < 0) + delete (_stra__RemoveStorageFpaclEntryResponse*)p->ptr; + else + delete[] (_stra__RemoveStorageFpaclEntryResponse*)p->ptr; + break; + case SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType: + if (p->size < 0) + delete (emi__AlertSubscriptionPolicyIDArrayType*)p->ptr; + else + delete[] (emi__AlertSubscriptionPolicyIDArrayType*)p->ptr; + break; + case SOAP_TYPE_emi__ByteData: + if (p->size < 0) + delete (emi__ByteData*)p->ptr; + else + delete[] (emi__ByteData*)p->ptr; + break; + case SOAP_TYPE_emi__EventLogRecordType: + if (p->size < 0) + delete (emi__EventLogRecordType*)p->ptr; + else + delete[] (emi__EventLogRecordType*)p->ptr; + break; + case SOAP_TYPE_emi__EventFilterType: + if (p->size < 0) + delete (emi__EventFilterType*)p->ptr; + else + delete[] (emi__EventFilterType*)p->ptr; + break; + case SOAP_TYPE_emi__AlertSubscriptionType: + if (p->size < 0) + delete (emi__AlertSubscriptionType*)p->ptr; + else + delete[] (emi__AlertSubscriptionType*)p->ptr; + break; + case SOAP_TYPE_emi__AlertSubscriptionHandleArrayType: + if (p->size < 0) + delete (emi__AlertSubscriptionHandleArrayType*)p->ptr; + else + delete[] (emi__AlertSubscriptionHandleArrayType*)p->ptr; + break; + case SOAP_TYPE_emi__EventFilterHandleArrayType: + if (p->size < 0) + delete (emi__EventFilterHandleArrayType*)p->ptr; + else + delete[] (emi__EventFilterHandleArrayType*)p->ptr; + break; + case SOAP_TYPE_emi__EventLogRecordArrayType: + if (p->size < 0) + delete (emi__EventLogRecordArrayType*)p->ptr; + else + delete[] (emi__EventLogRecordArrayType*)p->ptr; + break; + case SOAP_TYPE_emi__SensorHandleArrayType: + if (p->size < 0) + delete (emi__SensorHandleArrayType*)p->ptr; + else + delete[] (emi__SensorHandleArrayType*)p->ptr; + break; + case SOAP_TYPE_emi__SensorAttributesType: + if (p->size < 0) + delete (emi__SensorAttributesType*)p->ptr; + else + delete[] (emi__SensorAttributesType*)p->ptr; + break; + case SOAP_TYPE_emi__ByteStr: + if (p->size < 0) + delete (emi__ByteStr*)p->ptr; + else + delete[] (emi__ByteStr*)p->ptr; + break; + case SOAP_TYPE_emi__AlertCredentialsType: + if (p->size < 0) + delete (emi__AlertCredentialsType*)p->ptr; + else + delete[] (emi__AlertCredentialsType*)p->ptr; + break; + case SOAP_TYPE_emi__AlertSubscriptionSNMPType: + if (p->size < 0) + delete (emi__AlertSubscriptionSNMPType*)p->ptr; + else + delete[] (emi__AlertSubscriptionSNMPType*)p->ptr; + break; + case SOAP_TYPE_emi__AlertSubscriptionSoapType: + if (p->size < 0) + delete (emi__AlertSubscriptionSoapType*)p->ptr; + else + delete[] (emi__AlertSubscriptionSoapType*)p->ptr; + break; + case SOAP_TYPE_emi__AlertSubscriptionGeneralType: + if (p->size < 0) + delete (emi__AlertSubscriptionGeneralType*)p->ptr; + else + delete[] (emi__AlertSubscriptionGeneralType*)p->ptr; + break; + case SOAP_TYPE__emi__SubscribeForAlert: + if (p->size < 0) + delete (_emi__SubscribeForAlert*)p->ptr; + else + delete[] (_emi__SubscribeForAlert*)p->ptr; + break; + case SOAP_TYPE__emi__SubscribeForAlertResponse: + if (p->size < 0) + delete (_emi__SubscribeForAlertResponse*)p->ptr; + else + delete[] (_emi__SubscribeForAlertResponse*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateAlertSubscriptions: + if (p->size < 0) + delete (_emi__EnumerateAlertSubscriptions*)p->ptr; + else + delete[] (_emi__EnumerateAlertSubscriptions*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse: + if (p->size < 0) + delete (_emi__EnumerateAlertSubscriptionsResponse*)p->ptr; + else + delete[] (_emi__EnumerateAlertSubscriptionsResponse*)p->ptr; + break; + case SOAP_TYPE__emi__GetAlertSubscription: + if (p->size < 0) + delete (_emi__GetAlertSubscription*)p->ptr; + else + delete[] (_emi__GetAlertSubscription*)p->ptr; + break; + case SOAP_TYPE__emi__GetAlertSubscriptionResponse: + if (p->size < 0) + delete (_emi__GetAlertSubscriptionResponse*)p->ptr; + else + delete[] (_emi__GetAlertSubscriptionResponse*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateAlertPolicies: + if (p->size < 0) + delete (_emi__EnumerateAlertPolicies*)p->ptr; + else + delete[] (_emi__EnumerateAlertPolicies*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateAlertPoliciesResponse: + if (p->size < 0) + delete (_emi__EnumerateAlertPoliciesResponse*)p->ptr; + else + delete[] (_emi__EnumerateAlertPoliciesResponse*)p->ptr; + break; + case SOAP_TYPE__emi__SetAlertCommunityString: + if (p->size < 0) + delete (_emi__SetAlertCommunityString*)p->ptr; + else + delete[] (_emi__SetAlertCommunityString*)p->ptr; + break; + case SOAP_TYPE__emi__SetAlertCommunityStringResponse: + if (p->size < 0) + delete (_emi__SetAlertCommunityStringResponse*)p->ptr; + else + delete[] (_emi__SetAlertCommunityStringResponse*)p->ptr; + break; + case SOAP_TYPE__emi__GetAlertCommunityString: + if (p->size < 0) + delete (_emi__GetAlertCommunityString*)p->ptr; + else + delete[] (_emi__GetAlertCommunityString*)p->ptr; + break; + case SOAP_TYPE__emi__GetAlertCommunityStringResponse: + if (p->size < 0) + delete (_emi__GetAlertCommunityStringResponse*)p->ptr; + else + delete[] (_emi__GetAlertCommunityStringResponse*)p->ptr; + break; + case SOAP_TYPE__emi__AddEventFilter: + if (p->size < 0) + delete (_emi__AddEventFilter*)p->ptr; + else + delete[] (_emi__AddEventFilter*)p->ptr; + break; + case SOAP_TYPE__emi__AddEventFilterResponse: + if (p->size < 0) + delete (_emi__AddEventFilterResponse*)p->ptr; + else + delete[] (_emi__AddEventFilterResponse*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateEventFilters: + if (p->size < 0) + delete (_emi__EnumerateEventFilters*)p->ptr; + else + delete[] (_emi__EnumerateEventFilters*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateEventFiltersResponse: + if (p->size < 0) + delete (_emi__EnumerateEventFiltersResponse*)p->ptr; + else + delete[] (_emi__EnumerateEventFiltersResponse*)p->ptr; + break; + case SOAP_TYPE__emi__GetEventFilter: + if (p->size < 0) + delete (_emi__GetEventFilter*)p->ptr; + else + delete[] (_emi__GetEventFilter*)p->ptr; + break; + case SOAP_TYPE__emi__GetEventFilterResponse: + if (p->size < 0) + delete (_emi__GetEventFilterResponse*)p->ptr; + else + delete[] (_emi__GetEventFilterResponse*)p->ptr; + break; + case SOAP_TYPE__emi__UpdateEventFilter: + if (p->size < 0) + delete (_emi__UpdateEventFilter*)p->ptr; + else + delete[] (_emi__UpdateEventFilter*)p->ptr; + break; + case SOAP_TYPE__emi__UpdateEventFilterResponse: + if (p->size < 0) + delete (_emi__UpdateEventFilterResponse*)p->ptr; + else + delete[] (_emi__UpdateEventFilterResponse*)p->ptr; + break; + case SOAP_TYPE__emi__RemoveEventFilter: + if (p->size < 0) + delete (_emi__RemoveEventFilter*)p->ptr; + else + delete[] (_emi__RemoveEventFilter*)p->ptr; + break; + case SOAP_TYPE__emi__RemoveEventFilterResponse: + if (p->size < 0) + delete (_emi__RemoveEventFilterResponse*)p->ptr; + else + delete[] (_emi__RemoveEventFilterResponse*)p->ptr; + break; + case SOAP_TYPE__emi__ReadEventLogRecords: + if (p->size < 0) + delete (_emi__ReadEventLogRecords*)p->ptr; + else + delete[] (_emi__ReadEventLogRecords*)p->ptr; + break; + case SOAP_TYPE__emi__ReadEventLogRecordsResponse: + if (p->size < 0) + delete (_emi__ReadEventLogRecordsResponse*)p->ptr; + else + delete[] (_emi__ReadEventLogRecordsResponse*)p->ptr; + break; + case SOAP_TYPE__emi__GetEventLogStatus: + if (p->size < 0) + delete (_emi__GetEventLogStatus*)p->ptr; + else + delete[] (_emi__GetEventLogStatus*)p->ptr; + break; + case SOAP_TYPE__emi__GetEventLogStatusResponse: + if (p->size < 0) + delete (_emi__GetEventLogStatusResponse*)p->ptr; + else + delete[] (_emi__GetEventLogStatusResponse*)p->ptr; + break; + case SOAP_TYPE__emi__ClearEventLog: + if (p->size < 0) + delete (_emi__ClearEventLog*)p->ptr; + else + delete[] (_emi__ClearEventLog*)p->ptr; + break; + case SOAP_TYPE__emi__ClearEventLogResponse: + if (p->size < 0) + delete (_emi__ClearEventLogResponse*)p->ptr; + else + delete[] (_emi__ClearEventLogResponse*)p->ptr; + break; + case SOAP_TYPE__emi__FreezeEventLog: + if (p->size < 0) + delete (_emi__FreezeEventLog*)p->ptr; + else + delete[] (_emi__FreezeEventLog*)p->ptr; + break; + case SOAP_TYPE__emi__FreezeEventLogResponse: + if (p->size < 0) + delete (_emi__FreezeEventLogResponse*)p->ptr; + else + delete[] (_emi__FreezeEventLogResponse*)p->ptr; + break; + case SOAP_TYPE__emi__SetEventLogTimestampClock: + if (p->size < 0) + delete (_emi__SetEventLogTimestampClock*)p->ptr; + else + delete[] (_emi__SetEventLogTimestampClock*)p->ptr; + break; + case SOAP_TYPE__emi__SetEventLogTimestampClockResponse: + if (p->size < 0) + delete (_emi__SetEventLogTimestampClockResponse*)p->ptr; + else + delete[] (_emi__SetEventLogTimestampClockResponse*)p->ptr; + break; + case SOAP_TYPE__emi__GetEventLogTimestampClock: + if (p->size < 0) + delete (_emi__GetEventLogTimestampClock*)p->ptr; + else + delete[] (_emi__GetEventLogTimestampClock*)p->ptr; + break; + case SOAP_TYPE__emi__GetEventLogTimestampClockResponse: + if (p->size < 0) + delete (_emi__GetEventLogTimestampClockResponse*)p->ptr; + else + delete[] (_emi__GetEventLogTimestampClockResponse*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateSensors: + if (p->size < 0) + delete (_emi__EnumerateSensors*)p->ptr; + else + delete[] (_emi__EnumerateSensors*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateSensorsResponse: + if (p->size < 0) + delete (_emi__EnumerateSensorsResponse*)p->ptr; + else + delete[] (_emi__EnumerateSensorsResponse*)p->ptr; + break; + case SOAP_TYPE__emi__GetSensorAttributes: + if (p->size < 0) + delete (_emi__GetSensorAttributes*)p->ptr; + else + delete[] (_emi__GetSensorAttributes*)p->ptr; + break; + case SOAP_TYPE__emi__GetSensorAttributesResponse: + if (p->size < 0) + delete (_emi__GetSensorAttributesResponse*)p->ptr; + else + delete[] (_emi__GetSensorAttributesResponse*)p->ptr; + break; + case SOAP_TYPE__emi__CancelAlertSubscription: + if (p->size < 0) + delete (_emi__CancelAlertSubscription*)p->ptr; + else + delete[] (_emi__CancelAlertSubscription*)p->ptr; + break; + case SOAP_TYPE__emi__CancelAlertSubscriptionResponse: + if (p->size < 0) + delete (_emi__CancelAlertSubscriptionResponse*)p->ptr; + else + delete[] (_emi__CancelAlertSubscriptionResponse*)p->ptr; + break; + case SOAP_TYPE__emi__SubscribeForGeneralAlert: + if (p->size < 0) + delete (_emi__SubscribeForGeneralAlert*)p->ptr; + else + delete[] (_emi__SubscribeForGeneralAlert*)p->ptr; + break; + case SOAP_TYPE__emi__SubscribeForGeneralAlertResponse: + if (p->size < 0) + delete (_emi__SubscribeForGeneralAlertResponse*)p->ptr; + else + delete[] (_emi__SubscribeForGeneralAlertResponse*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions: + if (p->size < 0) + delete (_emi__EnumerateGeneralAlertSubscriptions*)p->ptr; + else + delete[] (_emi__EnumerateGeneralAlertSubscriptions*)p->ptr; + break; + case SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse: + if (p->size < 0) + delete (_emi__EnumerateGeneralAlertSubscriptionsResponse*)p->ptr; + else + delete[] (_emi__EnumerateGeneralAlertSubscriptionsResponse*)p->ptr; + break; + case SOAP_TYPE__emi__GetGeneralAlertSubscription: + if (p->size < 0) + delete (_emi__GetGeneralAlertSubscription*)p->ptr; + else + delete[] (_emi__GetGeneralAlertSubscription*)p->ptr; + break; + case SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse: + if (p->size < 0) + delete (_emi__GetGeneralAlertSubscriptionResponse*)p->ptr; + else + delete[] (_emi__GetGeneralAlertSubscriptionResponse*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType: + if (p->size < 0) + delete (cb__CircuitBreakerAntiSpoofingFilterType*)p->ptr; + else + delete[] (cb__CircuitBreakerAntiSpoofingFilterType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerPolicyType: + if (p->size < 0) + delete (cb__CircuitBreakerPolicyType*)p->ptr; + else + delete[] (cb__CircuitBreakerPolicyType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerPolicyInfoType: + if (p->size < 0) + delete (cb__CircuitBreakerPolicyInfoType*)p->ptr; + else + delete[] (cb__CircuitBreakerPolicyInfoType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType: + if (p->size < 0) + delete (cb__CircuitBreakerIPv4AddressAndMaskType*)p->ptr; + else + delete[] (cb__CircuitBreakerIPv4AddressAndMaskType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType: + if (p->size < 0) + delete (cb__CircuitBreakerIPv6AddressAndMaskType*)p->ptr; + else + delete[] (cb__CircuitBreakerIPv6AddressAndMaskType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType: + if (p->size < 0) + delete (cb__CircuitBreakerIPLayeredPortSimpleType*)p->ptr; + else + delete[] (cb__CircuitBreakerIPLayeredPortSimpleType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType: + if (p->size < 0) + delete (cb__CircuitBreakerIPLayeredPortRangeType*)p->ptr; + else + delete[] (cb__CircuitBreakerIPLayeredPortRangeType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType: + if (p->size < 0) + delete (cb__CircuitBreakerIPLayeredPortType*)p->ptr; + else + delete[] (cb__CircuitBreakerIPLayeredPortType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType: + if (p->size < 0) + delete (cb__CircuitBreakerIPLayeredTCPFlagsType*)p->ptr; + else + delete[] (cb__CircuitBreakerIPLayeredTCPFlagsType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerIPv4Type: + if (p->size < 0) + delete (cb__CircuitBreakerIPv4Type*)p->ptr; + else + delete[] (cb__CircuitBreakerIPv4Type*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerIPv6Type: + if (p->size < 0) + delete (cb__CircuitBreakerIPv6Type*)p->ptr; + else + delete[] (cb__CircuitBreakerIPv6Type*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerIPPacketType: + if (p->size < 0) + delete (cb__CircuitBreakerIPPacketType*)p->ptr; + else + delete[] (cb__CircuitBreakerIPPacketType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerPacketUDPType: + if (p->size < 0) + delete (cb__CircuitBreakerPacketUDPType*)p->ptr; + else + delete[] (cb__CircuitBreakerPacketUDPType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerPacketIPType: + if (p->size < 0) + delete (cb__CircuitBreakerPacketIPType*)p->ptr; + else + delete[] (cb__CircuitBreakerPacketIPType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerPacketETHType: + if (p->size < 0) + delete (cb__CircuitBreakerPacketETHType*)p->ptr; + else + delete[] (cb__CircuitBreakerPacketETHType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerPacketType: + if (p->size < 0) + delete (cb__CircuitBreakerPacketType*)p->ptr; + else + delete[] (cb__CircuitBreakerPacketType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerFilterType: + if (p->size < 0) + delete (cb__CircuitBreakerFilterType*)p->ptr; + else + delete[] (cb__CircuitBreakerFilterType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerFilterInfoType: + if (p->size < 0) + delete (cb__CircuitBreakerFilterInfoType*)p->ptr; + else + delete[] (cb__CircuitBreakerFilterInfoType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerCapabilitiesType: + if (p->size < 0) + delete (cb__CircuitBreakerCapabilitiesType*)p->ptr; + else + delete[] (cb__CircuitBreakerCapabilitiesType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType: + if (p->size < 0) + delete (cb__CircuitBreakerFilterStatisticsType*)p->ptr; + else + delete[] (cb__CircuitBreakerFilterStatisticsType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType: + if (p->size < 0) + delete (cb__CircuitBreakerHardwarePolicyType*)p->ptr; + else + delete[] (cb__CircuitBreakerHardwarePolicyType*)p->ptr; + break; + case SOAP_TYPE_cb__TimedCounterType: + if (p->size < 0) + delete (cb__TimedCounterType*)p->ptr; + else + delete[] (cb__TimedCounterType*)p->ptr; + break; + case SOAP_TYPE_cb__BlockedPortInfoType: + if (p->size < 0) + delete (cb__BlockedPortInfoType*)p->ptr; + else + delete[] (cb__BlockedPortInfoType*)p->ptr; + break; + case SOAP_TYPE_cb__HcbOptionsType: + if (p->size < 0) + delete (cb__HcbOptionsType*)p->ptr; + else + delete[] (cb__HcbOptionsType*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyCreate: + if (p->size < 0) + delete (_cb__CbPolicyCreate*)p->ptr; + else + delete[] (_cb__CbPolicyCreate*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyCreateResponse: + if (p->size < 0) + delete (_cb__CbPolicyCreateResponse*)p->ptr; + else + delete[] (_cb__CbPolicyCreateResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyGet: + if (p->size < 0) + delete (_cb__CbPolicyGet*)p->ptr; + else + delete[] (_cb__CbPolicyGet*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyGetResponse: + if (p->size < 0) + delete (_cb__CbPolicyGetResponse*)p->ptr; + else + delete[] (_cb__CbPolicyGetResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyDelete: + if (p->size < 0) + delete (_cb__CbPolicyDelete*)p->ptr; + else + delete[] (_cb__CbPolicyDelete*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyDeleteResponse: + if (p->size < 0) + delete (_cb__CbPolicyDeleteResponse*)p->ptr; + else + delete[] (_cb__CbPolicyDeleteResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyEnumerate: + if (p->size < 0) + delete (_cb__CbPolicyEnumerate*)p->ptr; + else + delete[] (_cb__CbPolicyEnumerate*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyEnumerateResponse: + if (p->size < 0) + delete (_cb__CbPolicyEnumerateResponse*)p->ptr; + else + delete[] (_cb__CbPolicyEnumerateResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyEnable: + if (p->size < 0) + delete (_cb__CbPolicyEnable*)p->ptr; + else + delete[] (_cb__CbPolicyEnable*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyEnableResponse: + if (p->size < 0) + delete (_cb__CbPolicyEnableResponse*)p->ptr; + else + delete[] (_cb__CbPolicyEnableResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyDisable: + if (p->size < 0) + delete (_cb__CbPolicyDisable*)p->ptr; + else + delete[] (_cb__CbPolicyDisable*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyDisableResponse: + if (p->size < 0) + delete (_cb__CbPolicyDisableResponse*)p->ptr; + else + delete[] (_cb__CbPolicyDisableResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyGetEnabled: + if (p->size < 0) + delete (_cb__CbPolicyGetEnabled*)p->ptr; + else + delete[] (_cb__CbPolicyGetEnabled*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyGetEnabledResponse: + if (p->size < 0) + delete (_cb__CbPolicyGetEnabledResponse*)p->ptr; + else + delete[] (_cb__CbPolicyGetEnabledResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyGetActiveStatistics: + if (p->size < 0) + delete (_cb__CbPolicyGetActiveStatistics*)p->ptr; + else + delete[] (_cb__CbPolicyGetActiveStatistics*)p->ptr; + break; + case SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse: + if (p->size < 0) + delete (_cb__CbPolicyGetActiveStatisticsResponse*)p->ptr; + else + delete[] (_cb__CbPolicyGetActiveStatisticsResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbFilterCreate: + if (p->size < 0) + delete (_cb__CbFilterCreate*)p->ptr; + else + delete[] (_cb__CbFilterCreate*)p->ptr; + break; + case SOAP_TYPE__cb__CbFilterCreateResponse: + if (p->size < 0) + delete (_cb__CbFilterCreateResponse*)p->ptr; + else + delete[] (_cb__CbFilterCreateResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbFilterGet: + if (p->size < 0) + delete (_cb__CbFilterGet*)p->ptr; + else + delete[] (_cb__CbFilterGet*)p->ptr; + break; + case SOAP_TYPE__cb__CbFilterGetResponse: + if (p->size < 0) + delete (_cb__CbFilterGetResponse*)p->ptr; + else + delete[] (_cb__CbFilterGetResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbFilterDelete: + if (p->size < 0) + delete (_cb__CbFilterDelete*)p->ptr; + else + delete[] (_cb__CbFilterDelete*)p->ptr; + break; + case SOAP_TYPE__cb__CbFilterDeleteResponse: + if (p->size < 0) + delete (_cb__CbFilterDeleteResponse*)p->ptr; + else + delete[] (_cb__CbFilterDeleteResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbFilterEnumerate: + if (p->size < 0) + delete (_cb__CbFilterEnumerate*)p->ptr; + else + delete[] (_cb__CbFilterEnumerate*)p->ptr; + break; + case SOAP_TYPE__cb__CbFilterEnumerateResponse: + if (p->size < 0) + delete (_cb__CbFilterEnumerateResponse*)p->ptr; + else + delete[] (_cb__CbFilterEnumerateResponse*)p->ptr; + break; + case SOAP_TYPE__cb__CbQueryCapabilities: + if (p->size < 0) + delete (_cb__CbQueryCapabilities*)p->ptr; + else + delete[] (_cb__CbQueryCapabilities*)p->ptr; + break; + case SOAP_TYPE__cb__CbQueryCapabilitiesResponse: + if (p->size < 0) + delete (_cb__CbQueryCapabilitiesResponse*)p->ptr; + else + delete[] (_cb__CbQueryCapabilitiesResponse*)p->ptr; + break; + case SOAP_TYPE__cb__SetHcbOptions: + if (p->size < 0) + delete (_cb__SetHcbOptions*)p->ptr; + else + delete[] (_cb__SetHcbOptions*)p->ptr; + break; + case SOAP_TYPE__cb__SetHcbOptionsResponse: + if (p->size < 0) + delete (_cb__SetHcbOptionsResponse*)p->ptr; + else + delete[] (_cb__SetHcbOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__cb__GetHcbOptions: + if (p->size < 0) + delete (_cb__GetHcbOptions*)p->ptr; + else + delete[] (_cb__GetHcbOptions*)p->ptr; + break; + case SOAP_TYPE__cb__GetHcbOptionsResponse: + if (p->size < 0) + delete (_cb__GetHcbOptionsResponse*)p->ptr; + else + delete[] (_cb__GetHcbOptionsResponse*)p->ptr; + break; + case SOAP_TYPE__cb__ClearHcbState: + if (p->size < 0) + delete (_cb__ClearHcbState*)p->ptr; + else + delete[] (_cb__ClearHcbState*)p->ptr; + break; + case SOAP_TYPE__cb__ClearHcbStateResponse: + if (p->size < 0) + delete (_cb__ClearHcbStateResponse*)p->ptr; + else + delete[] (_cb__ClearHcbStateResponse*)p->ptr; + break; + case SOAP_TYPE__cb__GetHcbState: + if (p->size < 0) + delete (_cb__GetHcbState*)p->ptr; + else + delete[] (_cb__GetHcbState*)p->ptr; + break; + case SOAP_TYPE__cb__GetHcbStateResponse: + if (p->size < 0) + delete (_cb__GetHcbStateResponse*)p->ptr; + else + delete[] (_cb__GetHcbStateResponse*)p->ptr; + break; + case SOAP_TYPE_hwa__AssetTypeArrayType: + if (p->size < 0) + delete (hwa__AssetTypeArrayType*)p->ptr; + else + delete[] (hwa__AssetTypeArrayType*)p->ptr; + break; + case SOAP_TYPE_hwa__AssetDataArrayType: + if (p->size < 0) + delete (hwa__AssetDataArrayType*)p->ptr; + else + delete[] (hwa__AssetDataArrayType*)p->ptr; + break; + case SOAP_TYPE_hwa__AssetDataType: + if (p->size < 0) + delete (hwa__AssetDataType*)p->ptr; + else + delete[] (hwa__AssetDataType*)p->ptr; + break; + case SOAP_TYPE_hwa__PT_USCOREBIOS: + if (p->size < 0) + delete (hwa__PT_USCOREBIOS*)p->ptr; + else + delete[] (hwa__PT_USCOREBIOS*)p->ptr; + break; + case SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM: + if (p->size < 0) + delete (hwa__PT_USCORECOMPUTER_USCORESYSTEM*)p->ptr; + else + delete[] (hwa__PT_USCORECOMPUTER_USCORESYSTEM*)p->ptr; + break; + case SOAP_TYPE_hwa__GUID: + if (p->size < 0) + delete (hwa__GUID*)p->ptr; + else + delete[] (hwa__GUID*)p->ptr; + break; + case SOAP_TYPE_hwa__PT_USCOREBASEBOARD: + if (p->size < 0) + delete (hwa__PT_USCOREBASEBOARD*)p->ptr; + else + delete[] (hwa__PT_USCOREBASEBOARD*)p->ptr; + break; + case SOAP_TYPE_hwa__PT_USCOREPROCESSOR: + if (p->size < 0) + delete (hwa__PT_USCOREPROCESSOR*)p->ptr; + else + delete[] (hwa__PT_USCOREPROCESSOR*)p->ptr; + break; + case SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE: + if (p->size < 0) + delete (hwa__PT_USCOREMEMORY_USCOREMODULE*)p->ptr; + else + delete[] (hwa__PT_USCOREMEMORY_USCOREMODULE*)p->ptr; + break; + case SOAP_TYPE_hwa__PT_USCOREFRU: + if (p->size < 0) + delete (hwa__PT_USCOREFRU*)p->ptr; + else + delete[] (hwa__PT_USCOREFRU*)p->ptr; + break; + case SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE: + if (p->size < 0) + delete (hwa__PT_USCOREMEDIA_USCOREDEVICE*)p->ptr; + else + delete[] (hwa__PT_USCOREMEDIA_USCOREDEVICE*)p->ptr; + break; + case SOAP_TYPE__hwa__EnumerateAssetTypes: + if (p->size < 0) + delete (_hwa__EnumerateAssetTypes*)p->ptr; + else + delete[] (_hwa__EnumerateAssetTypes*)p->ptr; + break; + case SOAP_TYPE__hwa__EnumerateAssetTypesResponse: + if (p->size < 0) + delete (_hwa__EnumerateAssetTypesResponse*)p->ptr; + else + delete[] (_hwa__EnumerateAssetTypesResponse*)p->ptr; + break; + case SOAP_TYPE__hwa__GetAssetData: + if (p->size < 0) + delete (_hwa__GetAssetData*)p->ptr; + else + delete[] (_hwa__GetAssetData*)p->ptr; + break; + case SOAP_TYPE__hwa__GetAssetDataResponse: + if (p->size < 0) + delete (_hwa__GetAssetDataResponse*)p->ptr; + else + delete[] (_hwa__GetAssetDataResponse*)p->ptr; + break; + case SOAP_TYPE_apr__GUID: + if (p->size < 0) + delete (apr__GUID*)p->ptr; + else + delete[] (apr__GUID*)p->ptr; + break; + case SOAP_TYPE_apr__ConsoleWatchdogEntryType: + if (p->size < 0) + delete (apr__ConsoleWatchdogEntryType*)p->ptr; + else + delete[] (apr__ConsoleWatchdogEntryType*)p->ptr; + break; + case SOAP_TYPE_apr__ConsoleWatchdogActionType: + if (p->size < 0) + delete (apr__ConsoleWatchdogActionType*)p->ptr; + else + delete[] (apr__ConsoleWatchdogActionType*)p->ptr; + break; + case SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType: + if (p->size < 0) + delete (apr__CircuitBreakerHardwarePolicyType*)p->ptr; + else + delete[] (apr__CircuitBreakerHardwarePolicyType*)p->ptr; + break; + case SOAP_TYPE_apr__AgentPresenceCapabilitiesType: + if (p->size < 0) + delete (apr__AgentPresenceCapabilitiesType*)p->ptr; + else + delete[] (apr__AgentPresenceCapabilitiesType*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogCreate: + if (p->size < 0) + delete (_apr__ConsoleWatchdogCreate*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogCreate*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogCreateResponse: + if (p->size < 0) + delete (_apr__ConsoleWatchdogCreateResponse*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogCreateResponse*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogDelete: + if (p->size < 0) + delete (_apr__ConsoleWatchdogDelete*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogDelete*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse: + if (p->size < 0) + delete (_apr__ConsoleWatchdogDeleteResponse*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogDeleteResponse*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogEnumerate: + if (p->size < 0) + delete (_apr__ConsoleWatchdogEnumerate*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogEnumerate*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse: + if (p->size < 0) + delete (_apr__ConsoleWatchdogEnumerateResponse*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogEnumerateResponse*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogSetActions: + if (p->size < 0) + delete (_apr__ConsoleWatchdogSetActions*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogSetActions*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse: + if (p->size < 0) + delete (_apr__ConsoleWatchdogSetActionsResponse*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogSetActionsResponse*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogGetActions: + if (p->size < 0) + delete (_apr__ConsoleWatchdogGetActions*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogGetActions*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse: + if (p->size < 0) + delete (_apr__ConsoleWatchdogGetActionsResponse*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogGetActionsResponse*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy: + if (p->size < 0) + delete (_apr__ConsoleWatchdogSetCbPolicy*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogSetCbPolicy*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse: + if (p->size < 0) + delete (_apr__ConsoleWatchdogSetCbPolicyResponse*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogSetCbPolicyResponse*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy: + if (p->size < 0) + delete (_apr__ConsoleWatchdogGetCbPolicy*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogGetCbPolicy*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse: + if (p->size < 0) + delete (_apr__ConsoleWatchdogGetCbPolicyResponse*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogGetCbPolicyResponse*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities: + if (p->size < 0) + delete (_apr__ConsoleWatchdogQueryCapabilities*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogQueryCapabilities*)p->ptr; + break; + case SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse: + if (p->size < 0) + delete (_apr__ConsoleWatchdogQueryCapabilitiesResponse*)p->ptr; + else + delete[] (_apr__ConsoleWatchdogQueryCapabilitiesResponse*)p->ptr; + break; + case SOAP_TYPE_apl__GUID: + if (p->size < 0) + delete (apl__GUID*)p->ptr; + else + delete[] (apl__GUID*)p->ptr; + break; + case SOAP_TYPE__apl__AgentWatchdogRegister: + if (p->size < 0) + delete (_apl__AgentWatchdogRegister*)p->ptr; + else + delete[] (_apl__AgentWatchdogRegister*)p->ptr; + break; + case SOAP_TYPE__apl__AgentWatchdogRegisterResponse: + if (p->size < 0) + delete (_apl__AgentWatchdogRegisterResponse*)p->ptr; + else + delete[] (_apl__AgentWatchdogRegisterResponse*)p->ptr; + break; + case SOAP_TYPE__apl__AgentWatchdogHeartbeat: + if (p->size < 0) + delete (_apl__AgentWatchdogHeartbeat*)p->ptr; + else + delete[] (_apl__AgentWatchdogHeartbeat*)p->ptr; + break; + case SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse: + if (p->size < 0) + delete (_apl__AgentWatchdogHeartbeatResponse*)p->ptr; + else + delete[] (_apl__AgentWatchdogHeartbeatResponse*)p->ptr; + break; + case SOAP_TYPE__apl__AgentWatchdogShutdown: + if (p->size < 0) + delete (_apl__AgentWatchdogShutdown*)p->ptr; + else + delete[] (_apl__AgentWatchdogShutdown*)p->ptr; + break; + case SOAP_TYPE__apl__AgentWatchdogShutdownResponse: + if (p->size < 0) + delete (_apl__AgentWatchdogShutdownResponse*)p->ptr; + else + delete[] (_apl__AgentWatchdogShutdownResponse*)p->ptr; + break; + case SOAP_TYPE_idr__IderSessionLogEntryType: + if (p->size < 0) + delete (idr__IderSessionLogEntryType*)p->ptr; + else + delete[] (idr__IderSessionLogEntryType*)p->ptr; + break; + case SOAP_TYPE_idr__FirmwareVersionType: + if (p->size < 0) + delete (idr__FirmwareVersionType*)p->ptr; + else + delete[] (idr__FirmwareVersionType*)p->ptr; + break; + case SOAP_TYPE__idr__SetRedirectionListenerState: + if (p->size < 0) + delete (_idr__SetRedirectionListenerState*)p->ptr; + else + delete[] (_idr__SetRedirectionListenerState*)p->ptr; + break; + case SOAP_TYPE__idr__SetRedirectionListenerStateResponse: + if (p->size < 0) + delete (_idr__SetRedirectionListenerStateResponse*)p->ptr; + else + delete[] (_idr__SetRedirectionListenerStateResponse*)p->ptr; + break; + case SOAP_TYPE__idr__GetRedirectionListenerState: + if (p->size < 0) + delete (_idr__GetRedirectionListenerState*)p->ptr; + else + delete[] (_idr__GetRedirectionListenerState*)p->ptr; + break; + case SOAP_TYPE__idr__GetRedirectionListenerStateResponse: + if (p->size < 0) + delete (_idr__GetRedirectionListenerStateResponse*)p->ptr; + else + delete[] (_idr__GetRedirectionListenerStateResponse*)p->ptr; + break; + case SOAP_TYPE__idr__GetIderSessionLog: + if (p->size < 0) + delete (_idr__GetIderSessionLog*)p->ptr; + else + delete[] (_idr__GetIderSessionLog*)p->ptr; + break; + case SOAP_TYPE__idr__GetIderSessionLogResponse: + if (p->size < 0) + delete (_idr__GetIderSessionLogResponse*)p->ptr; + else + delete[] (_idr__GetIderSessionLogResponse*)p->ptr; + break; + case SOAP_TYPE__tim__GetLowAccuracyTimeSynch: + if (p->size < 0) + delete (_tim__GetLowAccuracyTimeSynch*)p->ptr; + else + delete[] (_tim__GetLowAccuracyTimeSynch*)p->ptr; + break; + case SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse: + if (p->size < 0) + delete (_tim__GetLowAccuracyTimeSynchResponse*)p->ptr; + else + delete[] (_tim__GetLowAccuracyTimeSynchResponse*)p->ptr; + break; + case SOAP_TYPE__tim__SetHighAccuracyTimeSynch: + if (p->size < 0) + delete (_tim__SetHighAccuracyTimeSynch*)p->ptr; + else + delete[] (_tim__SetHighAccuracyTimeSynch*)p->ptr; + break; + case SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse: + if (p->size < 0) + delete (_tim__SetHighAccuracyTimeSynchResponse*)p->ptr; + else + delete[] (_tim__SetHighAccuracyTimeSynchResponse*)p->ptr; + break; + case SOAP_TYPE__str__ExecuteStorageOperation: + if (p->size < 0) + delete (_str__ExecuteStorageOperation*)p->ptr; + else + delete[] (_str__ExecuteStorageOperation*)p->ptr; + break; + case SOAP_TYPE__str__ExecuteStorageOperationResponse: + if (p->size < 0) + delete (_str__ExecuteStorageOperationResponse*)p->ptr; + else + delete[] (_str__ExecuteStorageOperationResponse*)p->ptr; + break; + case SOAP_TYPE_inf__IderSessionLogEntryType: + if (p->size < 0) + delete (inf__IderSessionLogEntryType*)p->ptr; + else + delete[] (inf__IderSessionLogEntryType*)p->ptr; + break; + case SOAP_TYPE_inf__FirmwareVersionType: + if (p->size < 0) + delete (inf__FirmwareVersionType*)p->ptr; + else + delete[] (inf__FirmwareVersionType*)p->ptr; + break; + case SOAP_TYPE__inf__GetCoreVersion: + if (p->size < 0) + delete (_inf__GetCoreVersion*)p->ptr; + else + delete[] (_inf__GetCoreVersion*)p->ptr; + break; + case SOAP_TYPE__inf__GetCoreVersionResponse: + if (p->size < 0) + delete (_inf__GetCoreVersionResponse*)p->ptr; + else + delete[] (_inf__GetCoreVersionResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetCodeVersions: + if (p->size < 0) + delete (_inf__GetCodeVersions*)p->ptr; + else + delete[] (_inf__GetCodeVersions*)p->ptr; + break; + case SOAP_TYPE__inf__GetCodeVersionsResponse: + if (p->size < 0) + delete (_inf__GetCodeVersionsResponse*)p->ptr; + else + delete[] (_inf__GetCodeVersionsResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetProvisioningMode: + if (p->size < 0) + delete (_inf__GetProvisioningMode*)p->ptr; + else + delete[] (_inf__GetProvisioningMode*)p->ptr; + break; + case SOAP_TYPE__inf__GetProvisioningModeResponse: + if (p->size < 0) + delete (_inf__GetProvisioningModeResponse*)p->ptr; + else + delete[] (_inf__GetProvisioningModeResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetProvisioningState: + if (p->size < 0) + delete (_inf__GetProvisioningState*)p->ptr; + else + delete[] (_inf__GetProvisioningState*)p->ptr; + break; + case SOAP_TYPE__inf__GetProvisioningStateResponse: + if (p->size < 0) + delete (_inf__GetProvisioningStateResponse*)p->ptr; + else + delete[] (_inf__GetProvisioningStateResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetVlanParameters: + if (p->size < 0) + delete (_inf__GetVlanParameters*)p->ptr; + else + delete[] (_inf__GetVlanParameters*)p->ptr; + break; + case SOAP_TYPE__inf__GetVlanParametersResponse: + if (p->size < 0) + delete (_inf__GetVlanParametersResponse*)p->ptr; + else + delete[] (_inf__GetVlanParametersResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetHostName: + if (p->size < 0) + delete (_inf__GetHostName*)p->ptr; + else + delete[] (_inf__GetHostName*)p->ptr; + break; + case SOAP_TYPE__inf__GetHostNameResponse: + if (p->size < 0) + delete (_inf__GetHostNameResponse*)p->ptr; + else + delete[] (_inf__GetHostNameResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetConfigServerInfo: + if (p->size < 0) + delete (_inf__GetConfigServerInfo*)p->ptr; + else + delete[] (_inf__GetConfigServerInfo*)p->ptr; + break; + case SOAP_TYPE__inf__GetConfigServerInfoResponse: + if (p->size < 0) + delete (_inf__GetConfigServerInfoResponse*)p->ptr; + else + delete[] (_inf__GetConfigServerInfoResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetAdminAclEntryStatus: + if (p->size < 0) + delete (_inf__GetAdminAclEntryStatus*)p->ptr; + else + delete[] (_inf__GetAdminAclEntryStatus*)p->ptr; + break; + case SOAP_TYPE__inf__GetAdminAclEntryStatusResponse: + if (p->size < 0) + delete (_inf__GetAdminAclEntryStatusResponse*)p->ptr; + else + delete[] (_inf__GetAdminAclEntryStatusResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetAdminNetAclEntryStatus: + if (p->size < 0) + delete (_inf__GetAdminNetAclEntryStatus*)p->ptr; + else + delete[] (_inf__GetAdminNetAclEntryStatus*)p->ptr; + break; + case SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse: + if (p->size < 0) + delete (_inf__GetAdminNetAclEntryStatusResponse*)p->ptr; + else + delete[] (_inf__GetAdminNetAclEntryStatusResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetPasswordModel: + if (p->size < 0) + delete (_inf__GetPasswordModel*)p->ptr; + else + delete[] (_inf__GetPasswordModel*)p->ptr; + break; + case SOAP_TYPE__inf__GetPasswordModelResponse: + if (p->size < 0) + delete (_inf__GetPasswordModelResponse*)p->ptr; + else + delete[] (_inf__GetPasswordModelResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetEnabledInterfaces: + if (p->size < 0) + delete (_inf__GetEnabledInterfaces*)p->ptr; + else + delete[] (_inf__GetEnabledInterfaces*)p->ptr; + break; + case SOAP_TYPE__inf__GetEnabledInterfacesResponse: + if (p->size < 0) + delete (_inf__GetEnabledInterfacesResponse*)p->ptr; + else + delete[] (_inf__GetEnabledInterfacesResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetNetworkState: + if (p->size < 0) + delete (_inf__GetNetworkState*)p->ptr; + else + delete[] (_inf__GetNetworkState*)p->ptr; + break; + case SOAP_TYPE__inf__GetNetworkStateResponse: + if (p->size < 0) + delete (_inf__GetNetworkStateResponse*)p->ptr; + else + delete[] (_inf__GetNetworkStateResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetSecurityParameters: + if (p->size < 0) + delete (_inf__GetSecurityParameters*)p->ptr; + else + delete[] (_inf__GetSecurityParameters*)p->ptr; + break; + case SOAP_TYPE__inf__GetSecurityParametersResponse: + if (p->size < 0) + delete (_inf__GetSecurityParametersResponse*)p->ptr; + else + delete[] (_inf__GetSecurityParametersResponse*)p->ptr; + break; + case SOAP_TYPE__inf__GetIderSessionLog: + if (p->size < 0) + delete (_inf__GetIderSessionLog*)p->ptr; + else + delete[] (_inf__GetIderSessionLog*)p->ptr; + break; + case SOAP_TYPE__inf__GetIderSessionLogResponse: + if (p->size < 0) + delete (_inf__GetIderSessionLogResponse*)p->ptr; + else + delete[] (_inf__GetIderSessionLogResponse*)p->ptr; + break; + case SOAP_TYPE__rci__GetRemoteControlCapabilities: + if (p->size < 0) + delete (_rci__GetRemoteControlCapabilities*)p->ptr; + else + delete[] (_rci__GetRemoteControlCapabilities*)p->ptr; + break; + case SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse: + if (p->size < 0) + delete (_rci__GetRemoteControlCapabilitiesResponse*)p->ptr; + else + delete[] (_rci__GetRemoteControlCapabilitiesResponse*)p->ptr; + break; + case SOAP_TYPE__rci__RemoteControl: + if (p->size < 0) + delete (_rci__RemoteControl*)p->ptr; + else + delete[] (_rci__RemoteControl*)p->ptr; + break; + case SOAP_TYPE__rci__RemoteControlResponse: + if (p->size < 0) + delete (_rci__RemoteControlResponse*)p->ptr; + else + delete[] (_rci__RemoteControlResponse*)p->ptr; + break; + case SOAP_TYPE__rci__GetSystemPowerState: + if (p->size < 0) + delete (_rci__GetSystemPowerState*)p->ptr; + else + delete[] (_rci__GetSystemPowerState*)p->ptr; + break; + case SOAP_TYPE__rci__GetSystemPowerStateResponse: + if (p->size < 0) + delete (_rci__GetSystemPowerStateResponse*)p->ptr; + else + delete[] (_rci__GetSystemPowerStateResponse*)p->ptr; + break; + case SOAP_TYPE_wcxs__WEP64Type: + if (p->size < 0) + delete (wcxs__WEP64Type*)p->ptr; + else + delete[] (wcxs__WEP64Type*)p->ptr; + break; + case SOAP_TYPE_wcxs__WEP128Type: + if (p->size < 0) + delete (wcxs__WEP128Type*)p->ptr; + else + delete[] (wcxs__WEP128Type*)p->ptr; + break; + case SOAP_TYPE_wcxs__DataEncryptionWEPXType: + if (p->size < 0) + delete (wcxs__DataEncryptionWEPXType*)p->ptr; + else + delete[] (wcxs__DataEncryptionWEPXType*)p->ptr; + break; + case SOAP_TYPE_wcxs__DataEncryptionWEPType: + if (p->size < 0) + delete (wcxs__DataEncryptionWEPType*)p->ptr; + else + delete[] (wcxs__DataEncryptionWEPType*)p->ptr; + break; + case SOAP_TYPE_wcxs__DataEncryptionTKIPType: + if (p->size < 0) + delete (wcxs__DataEncryptionTKIPType*)p->ptr; + else + delete[] (wcxs__DataEncryptionTKIPType*)p->ptr; + break; + case SOAP_TYPE_wcxs__DataEncryptionCCMPType: + if (p->size < 0) + delete (wcxs__DataEncryptionCCMPType*)p->ptr; + else + delete[] (wcxs__DataEncryptionCCMPType*)p->ptr; + break; + case SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType: + if (p->size < 0) + delete (wcxs__ProfileSecuritySettingWPAType*)p->ptr; + else + delete[] (wcxs__ProfileSecuritySettingWPAType*)p->ptr; + break; + case SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType: + if (p->size < 0) + delete (wcxs__ProfileSecuritySettingRSNType*)p->ptr; + else + delete[] (wcxs__ProfileSecuritySettingRSNType*)p->ptr; + break; + case SOAP_TYPE_wcxs__ProfileSecuritySettingsType: + if (p->size < 0) + delete (wcxs__ProfileSecuritySettingsType*)p->ptr; + else + delete[] (wcxs__ProfileSecuritySettingsType*)p->ptr; + break; + case SOAP_TYPE_wcxs__ProfileType: + if (p->size < 0) + delete (wcxs__ProfileType*)p->ptr; + else + delete[] (wcxs__ProfileType*)p->ptr; + break; + case SOAP_TYPE_wcxs__WirelessCapabilitiesType: + if (p->size < 0) + delete (wcxs__WirelessCapabilitiesType*)p->ptr; + else + delete[] (wcxs__WirelessCapabilitiesType*)p->ptr; + break; + case SOAP_TYPE_wcxs__WirelessSettingsType: + if (p->size < 0) + delete (wcxs__WirelessSettingsType*)p->ptr; + else + delete[] (wcxs__WirelessSettingsType*)p->ptr; + break; + case SOAP_TYPE__wcxs__AddWirelessProfileRequest: + if (p->size < 0) + delete (_wcxs__AddWirelessProfileRequest*)p->ptr; + else + delete[] (_wcxs__AddWirelessProfileRequest*)p->ptr; + break; + case SOAP_TYPE__wcxs__AddWirelessProfileResponse: + if (p->size < 0) + delete (_wcxs__AddWirelessProfileResponse*)p->ptr; + else + delete[] (_wcxs__AddWirelessProfileResponse*)p->ptr; + break; + case SOAP_TYPE__wcxs__GetWirelessProfileRequest: + if (p->size < 0) + delete (_wcxs__GetWirelessProfileRequest*)p->ptr; + else + delete[] (_wcxs__GetWirelessProfileRequest*)p->ptr; + break; + case SOAP_TYPE__wcxs__GetWirelessProfileResponse: + if (p->size < 0) + delete (_wcxs__GetWirelessProfileResponse*)p->ptr; + else + delete[] (_wcxs__GetWirelessProfileResponse*)p->ptr; + break; + case SOAP_TYPE__wcxs__RemoveWirelessProfileRequest: + if (p->size < 0) + delete (_wcxs__RemoveWirelessProfileRequest*)p->ptr; + else + delete[] (_wcxs__RemoveWirelessProfileRequest*)p->ptr; + break; + case SOAP_TYPE__wcxs__RemoveWirelessProfileResponse: + if (p->size < 0) + delete (_wcxs__RemoveWirelessProfileResponse*)p->ptr; + else + delete[] (_wcxs__RemoveWirelessProfileResponse*)p->ptr; + break; + case SOAP_TYPE__wcxs__UpdateWirelessProfileRequest: + if (p->size < 0) + delete (_wcxs__UpdateWirelessProfileRequest*)p->ptr; + else + delete[] (_wcxs__UpdateWirelessProfileRequest*)p->ptr; + break; + case SOAP_TYPE__wcxs__UpdateWirelessProfileResponse: + if (p->size < 0) + delete (_wcxs__UpdateWirelessProfileResponse*)p->ptr; + else + delete[] (_wcxs__UpdateWirelessProfileResponse*)p->ptr; + break; + case SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest: + if (p->size < 0) + delete (_wcxs__EnumerateWirelessProfilesRequest*)p->ptr; + else + delete[] (_wcxs__EnumerateWirelessProfilesRequest*)p->ptr; + break; + case SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse: + if (p->size < 0) + delete (_wcxs__EnumerateWirelessProfilesResponse*)p->ptr; + else + delete[] (_wcxs__EnumerateWirelessProfilesResponse*)p->ptr; + break; + case SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest: + if (p->size < 0) + delete (_wcxs__GetWirelessCapabilitiesRequest*)p->ptr; + else + delete[] (_wcxs__GetWirelessCapabilitiesRequest*)p->ptr; + break; + case SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse: + if (p->size < 0) + delete (_wcxs__GetWirelessCapabilitiesResponse*)p->ptr; + else + delete[] (_wcxs__GetWirelessCapabilitiesResponse*)p->ptr; + break; + case SOAP_TYPE__wcxs__GetWirelessSettingsRequest: + if (p->size < 0) + delete (_wcxs__GetWirelessSettingsRequest*)p->ptr; + else + delete[] (_wcxs__GetWirelessSettingsRequest*)p->ptr; + break; + case SOAP_TYPE__wcxs__GetWirelessSettingsResponse: + if (p->size < 0) + delete (_wcxs__GetWirelessSettingsResponse*)p->ptr; + else + delete[] (_wcxs__GetWirelessSettingsResponse*)p->ptr; + break; + case SOAP_TYPE_cmn__URLType: + if (p->size < 0) + delete (cmn__URLType*)p->ptr; + else + delete[] (cmn__URLType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerDefaultFilterType: + if (p->size < 0) + delete (cb__CircuitBreakerDefaultFilterType*)p->ptr; + else + delete[] (cb__CircuitBreakerDefaultFilterType*)p->ptr; + break; + case SOAP_TYPE_cb__CircuitBreakerPacketTCPType: + if (p->size < 0) + delete (cb__CircuitBreakerPacketTCPType*)p->ptr; + else + delete[] (cb__CircuitBreakerPacketTCPType*)p->ptr; + break; + case SOAP_TYPE___apl__AgentWatchdogShutdown: + if (p->size < 0) + delete (struct __apl__AgentWatchdogShutdown*)p->ptr; + else + delete[] (struct __apl__AgentWatchdogShutdown*)p->ptr; + break; + case SOAP_TYPE___apl__AgentWatchdogHeartbeat: + if (p->size < 0) + delete (struct __apl__AgentWatchdogHeartbeat*)p->ptr; + else + delete[] (struct __apl__AgentWatchdogHeartbeat*)p->ptr; + break; + case SOAP_TYPE___apl__AgentWatchdogRegister: + if (p->size < 0) + delete (struct __apl__AgentWatchdogRegister*)p->ptr; + else + delete[] (struct __apl__AgentWatchdogRegister*)p->ptr; + break; + case SOAP_TYPE___apr__ConsoleWatchdogCreate: + if (p->size < 0) + delete (struct __apr__ConsoleWatchdogCreate*)p->ptr; + else + delete[] (struct __apr__ConsoleWatchdogCreate*)p->ptr; + break; + case SOAP_TYPE___apr__ConsoleWatchdogDelete: + if (p->size < 0) + delete (struct __apr__ConsoleWatchdogDelete*)p->ptr; + else + delete[] (struct __apr__ConsoleWatchdogDelete*)p->ptr; + break; + case SOAP_TYPE___apr__ConsoleWatchdogEnumerate: + if (p->size < 0) + delete (struct __apr__ConsoleWatchdogEnumerate*)p->ptr; + else + delete[] (struct __apr__ConsoleWatchdogEnumerate*)p->ptr; + break; + case SOAP_TYPE___apr__ConsoleWatchdogSetActions: + if (p->size < 0) + delete (struct __apr__ConsoleWatchdogSetActions*)p->ptr; + else + delete[] (struct __apr__ConsoleWatchdogSetActions*)p->ptr; + break; + case SOAP_TYPE___apr__ConsoleWatchdogGetActions: + if (p->size < 0) + delete (struct __apr__ConsoleWatchdogGetActions*)p->ptr; + else + delete[] (struct __apr__ConsoleWatchdogGetActions*)p->ptr; + break; + case SOAP_TYPE___apr__ConsoleWatchdogSetCbPolicy: + if (p->size < 0) + delete (struct __apr__ConsoleWatchdogSetCbPolicy*)p->ptr; + else + delete[] (struct __apr__ConsoleWatchdogSetCbPolicy*)p->ptr; + break; + case SOAP_TYPE___apr__ConsoleWatchdogGetCbPolicy: + if (p->size < 0) + delete (struct __apr__ConsoleWatchdogGetCbPolicy*)p->ptr; + else + delete[] (struct __apr__ConsoleWatchdogGetCbPolicy*)p->ptr; + break; + case SOAP_TYPE___apr__ConsoleWatchdogQueryCapabilities: + if (p->size < 0) + delete (struct __apr__ConsoleWatchdogQueryCapabilities*)p->ptr; + else + delete[] (struct __apr__ConsoleWatchdogQueryCapabilities*)p->ptr; + break; + case SOAP_TYPE___cb__CbPolicyCreate: + if (p->size < 0) + delete (struct __cb__CbPolicyCreate*)p->ptr; + else + delete[] (struct __cb__CbPolicyCreate*)p->ptr; + break; + case SOAP_TYPE___cb__CbPolicyGet: + if (p->size < 0) + delete (struct __cb__CbPolicyGet*)p->ptr; + else + delete[] (struct __cb__CbPolicyGet*)p->ptr; + break; + case SOAP_TYPE___cb__CbPolicyDelete: + if (p->size < 0) + delete (struct __cb__CbPolicyDelete*)p->ptr; + else + delete[] (struct __cb__CbPolicyDelete*)p->ptr; + break; + case SOAP_TYPE___cb__CbPolicyEnumerate: + if (p->size < 0) + delete (struct __cb__CbPolicyEnumerate*)p->ptr; + else + delete[] (struct __cb__CbPolicyEnumerate*)p->ptr; + break; + case SOAP_TYPE___cb__CbPolicyEnable: + if (p->size < 0) + delete (struct __cb__CbPolicyEnable*)p->ptr; + else + delete[] (struct __cb__CbPolicyEnable*)p->ptr; + break; + case SOAP_TYPE___cb__CbPolicyDisable: + if (p->size < 0) + delete (struct __cb__CbPolicyDisable*)p->ptr; + else + delete[] (struct __cb__CbPolicyDisable*)p->ptr; + break; + case SOAP_TYPE___cb__CbPolicyGetEnabled: + if (p->size < 0) + delete (struct __cb__CbPolicyGetEnabled*)p->ptr; + else + delete[] (struct __cb__CbPolicyGetEnabled*)p->ptr; + break; + case SOAP_TYPE___cb__CbPolicyGetActiveStatistics: + if (p->size < 0) + delete (struct __cb__CbPolicyGetActiveStatistics*)p->ptr; + else + delete[] (struct __cb__CbPolicyGetActiveStatistics*)p->ptr; + break; + case SOAP_TYPE___cb__CbFilterCreate: + if (p->size < 0) + delete (struct __cb__CbFilterCreate*)p->ptr; + else + delete[] (struct __cb__CbFilterCreate*)p->ptr; + break; + case SOAP_TYPE___cb__CbFilterGet: + if (p->size < 0) + delete (struct __cb__CbFilterGet*)p->ptr; + else + delete[] (struct __cb__CbFilterGet*)p->ptr; + break; + case SOAP_TYPE___cb__CbFilterDelete: + if (p->size < 0) + delete (struct __cb__CbFilterDelete*)p->ptr; + else + delete[] (struct __cb__CbFilterDelete*)p->ptr; + break; + case SOAP_TYPE___cb__CbFilterEnumerate: + if (p->size < 0) + delete (struct __cb__CbFilterEnumerate*)p->ptr; + else + delete[] (struct __cb__CbFilterEnumerate*)p->ptr; + break; + case SOAP_TYPE___cb__CbQueryCapabilities: + if (p->size < 0) + delete (struct __cb__CbQueryCapabilities*)p->ptr; + else + delete[] (struct __cb__CbQueryCapabilities*)p->ptr; + break; + case SOAP_TYPE___cb__SetHcbOptions: + if (p->size < 0) + delete (struct __cb__SetHcbOptions*)p->ptr; + else + delete[] (struct __cb__SetHcbOptions*)p->ptr; + break; + case SOAP_TYPE___cb__GetHcbOptions: + if (p->size < 0) + delete (struct __cb__GetHcbOptions*)p->ptr; + else + delete[] (struct __cb__GetHcbOptions*)p->ptr; + break; + case SOAP_TYPE___cb__ClearHcbState: + if (p->size < 0) + delete (struct __cb__ClearHcbState*)p->ptr; + else + delete[] (struct __cb__ClearHcbState*)p->ptr; + break; + case SOAP_TYPE___cb__GetHcbState: + if (p->size < 0) + delete (struct __cb__GetHcbState*)p->ptr; + else + delete[] (struct __cb__GetHcbState*)p->ptr; + break; + case SOAP_TYPE___emi__EnumerateEventFilters: + if (p->size < 0) + delete (struct __emi__EnumerateEventFilters*)p->ptr; + else + delete[] (struct __emi__EnumerateEventFilters*)p->ptr; + break; + case SOAP_TYPE___emi__GetAlertSubscription: + if (p->size < 0) + delete (struct __emi__GetAlertSubscription*)p->ptr; + else + delete[] (struct __emi__GetAlertSubscription*)p->ptr; + break; + case SOAP_TYPE___emi__SetAlertCommunityString: + if (p->size < 0) + delete (struct __emi__SetAlertCommunityString*)p->ptr; + else + delete[] (struct __emi__SetAlertCommunityString*)p->ptr; + break; + case SOAP_TYPE___emi__GetAlertCommunityString: + if (p->size < 0) + delete (struct __emi__GetAlertCommunityString*)p->ptr; + else + delete[] (struct __emi__GetAlertCommunityString*)p->ptr; + break; + case SOAP_TYPE___emi__AddEventFilter: + if (p->size < 0) + delete (struct __emi__AddEventFilter*)p->ptr; + else + delete[] (struct __emi__AddEventFilter*)p->ptr; + break; + case SOAP_TYPE___emi__SubscribeForAlert: + if (p->size < 0) + delete (struct __emi__SubscribeForAlert*)p->ptr; + else + delete[] (struct __emi__SubscribeForAlert*)p->ptr; + break; + case SOAP_TYPE___emi__EnumerateAlertSubscriptions: + if (p->size < 0) + delete (struct __emi__EnumerateAlertSubscriptions*)p->ptr; + else + delete[] (struct __emi__EnumerateAlertSubscriptions*)p->ptr; + break; + case SOAP_TYPE___emi__EnumerateAlertPolicies: + if (p->size < 0) + delete (struct __emi__EnumerateAlertPolicies*)p->ptr; + else + delete[] (struct __emi__EnumerateAlertPolicies*)p->ptr; + break; + case SOAP_TYPE___emi__CancelAlertSubscription: + if (p->size < 0) + delete (struct __emi__CancelAlertSubscription*)p->ptr; + else + delete[] (struct __emi__CancelAlertSubscription*)p->ptr; + break; + case SOAP_TYPE___emi__GetEventFilter: + if (p->size < 0) + delete (struct __emi__GetEventFilter*)p->ptr; + else + delete[] (struct __emi__GetEventFilter*)p->ptr; + break; + case SOAP_TYPE___emi__UpdateEventFilter: + if (p->size < 0) + delete (struct __emi__UpdateEventFilter*)p->ptr; + else + delete[] (struct __emi__UpdateEventFilter*)p->ptr; + break; + case SOAP_TYPE___emi__RemoveEventFilter: + if (p->size < 0) + delete (struct __emi__RemoveEventFilter*)p->ptr; + else + delete[] (struct __emi__RemoveEventFilter*)p->ptr; + break; + case SOAP_TYPE___emi__GetEventLogStatus: + if (p->size < 0) + delete (struct __emi__GetEventLogStatus*)p->ptr; + else + delete[] (struct __emi__GetEventLogStatus*)p->ptr; + break; + case SOAP_TYPE___emi__ReadEventLogRecords: + if (p->size < 0) + delete (struct __emi__ReadEventLogRecords*)p->ptr; + else + delete[] (struct __emi__ReadEventLogRecords*)p->ptr; + break; + case SOAP_TYPE___emi__ClearEventLog: + if (p->size < 0) + delete (struct __emi__ClearEventLog*)p->ptr; + else + delete[] (struct __emi__ClearEventLog*)p->ptr; + break; + case SOAP_TYPE___emi__FreezeEventLog: + if (p->size < 0) + delete (struct __emi__FreezeEventLog*)p->ptr; + else + delete[] (struct __emi__FreezeEventLog*)p->ptr; + break; + case SOAP_TYPE___emi__SetEventLogTimestampClock: + if (p->size < 0) + delete (struct __emi__SetEventLogTimestampClock*)p->ptr; + else + delete[] (struct __emi__SetEventLogTimestampClock*)p->ptr; + break; + case SOAP_TYPE___emi__GetEventLogTimestampClock: + if (p->size < 0) + delete (struct __emi__GetEventLogTimestampClock*)p->ptr; + else + delete[] (struct __emi__GetEventLogTimestampClock*)p->ptr; + break; + case SOAP_TYPE___emi__EnumerateSensors: + if (p->size < 0) + delete (struct __emi__EnumerateSensors*)p->ptr; + else + delete[] (struct __emi__EnumerateSensors*)p->ptr; + break; + case SOAP_TYPE___emi__GetSensorAttributes: + if (p->size < 0) + delete (struct __emi__GetSensorAttributes*)p->ptr; + else + delete[] (struct __emi__GetSensorAttributes*)p->ptr; + break; + case SOAP_TYPE___emi__SubscribeForGeneralAlert: + if (p->size < 0) + delete (struct __emi__SubscribeForGeneralAlert*)p->ptr; + else + delete[] (struct __emi__SubscribeForGeneralAlert*)p->ptr; + break; + case SOAP_TYPE___emi__EnumerateGeneralAlertSubscriptions: + if (p->size < 0) + delete (struct __emi__EnumerateGeneralAlertSubscriptions*)p->ptr; + else + delete[] (struct __emi__EnumerateGeneralAlertSubscriptions*)p->ptr; + break; + case SOAP_TYPE___emi__GetGeneralAlertSubscription: + if (p->size < 0) + delete (struct __emi__GetGeneralAlertSubscription*)p->ptr; + else + delete[] (struct __emi__GetGeneralAlertSubscription*)p->ptr; + break; + case SOAP_TYPE___hwa__EnumerateAssetTypes: + if (p->size < 0) + delete (struct __hwa__EnumerateAssetTypes*)p->ptr; + else + delete[] (struct __hwa__EnumerateAssetTypes*)p->ptr; + break; + case SOAP_TYPE___hwa__GetAssetData: + if (p->size < 0) + delete (struct __hwa__GetAssetData*)p->ptr; + else + delete[] (struct __hwa__GetAssetData*)p->ptr; + break; + case SOAP_TYPE___idr__SetRedirectionListenerState: + if (p->size < 0) + delete (struct __idr__SetRedirectionListenerState*)p->ptr; + else + delete[] (struct __idr__SetRedirectionListenerState*)p->ptr; + break; + case SOAP_TYPE___idr__GetRedirectionListenerState: + if (p->size < 0) + delete (struct __idr__GetRedirectionListenerState*)p->ptr; + else + delete[] (struct __idr__GetRedirectionListenerState*)p->ptr; + break; + case SOAP_TYPE___idr__GetIderSessionLog: + if (p->size < 0) + delete (struct __idr__GetIderSessionLog*)p->ptr; + else + delete[] (struct __idr__GetIderSessionLog*)p->ptr; + break; + case SOAP_TYPE___inf__GetCoreVersion: + if (p->size < 0) + delete (struct __inf__GetCoreVersion*)p->ptr; + else + delete[] (struct __inf__GetCoreVersion*)p->ptr; + break; + case SOAP_TYPE___inf__GetCodeVersions: + if (p->size < 0) + delete (struct __inf__GetCodeVersions*)p->ptr; + else + delete[] (struct __inf__GetCodeVersions*)p->ptr; + break; + case SOAP_TYPE___inf__GetProvisioningMode: + if (p->size < 0) + delete (struct __inf__GetProvisioningMode*)p->ptr; + else + delete[] (struct __inf__GetProvisioningMode*)p->ptr; + break; + case SOAP_TYPE___inf__GetProvisioningState: + if (p->size < 0) + delete (struct __inf__GetProvisioningState*)p->ptr; + else + delete[] (struct __inf__GetProvisioningState*)p->ptr; + break; + case SOAP_TYPE___inf__GetVlanParameters: + if (p->size < 0) + delete (struct __inf__GetVlanParameters*)p->ptr; + else + delete[] (struct __inf__GetVlanParameters*)p->ptr; + break; + case SOAP_TYPE___inf__GetHostName: + if (p->size < 0) + delete (struct __inf__GetHostName*)p->ptr; + else + delete[] (struct __inf__GetHostName*)p->ptr; + break; + case SOAP_TYPE___inf__GetConfigServerInfo: + if (p->size < 0) + delete (struct __inf__GetConfigServerInfo*)p->ptr; + else + delete[] (struct __inf__GetConfigServerInfo*)p->ptr; + break; + case SOAP_TYPE___inf__GetAdminAclEntryStatus: + if (p->size < 0) + delete (struct __inf__GetAdminAclEntryStatus*)p->ptr; + else + delete[] (struct __inf__GetAdminAclEntryStatus*)p->ptr; + break; + case SOAP_TYPE___inf__GetAdminNetAclEntryStatus: + if (p->size < 0) + delete (struct __inf__GetAdminNetAclEntryStatus*)p->ptr; + else + delete[] (struct __inf__GetAdminNetAclEntryStatus*)p->ptr; + break; + case SOAP_TYPE___inf__GetPasswordModel: + if (p->size < 0) + delete (struct __inf__GetPasswordModel*)p->ptr; + else + delete[] (struct __inf__GetPasswordModel*)p->ptr; + break; + case SOAP_TYPE___inf__GetEnabledInterfaces: + if (p->size < 0) + delete (struct __inf__GetEnabledInterfaces*)p->ptr; + else + delete[] (struct __inf__GetEnabledInterfaces*)p->ptr; + break; + case SOAP_TYPE___inf__GetNetworkState: + if (p->size < 0) + delete (struct __inf__GetNetworkState*)p->ptr; + else + delete[] (struct __inf__GetNetworkState*)p->ptr; + break; + case SOAP_TYPE___inf__GetSecurityParameters: + if (p->size < 0) + delete (struct __inf__GetSecurityParameters*)p->ptr; + else + delete[] (struct __inf__GetSecurityParameters*)p->ptr; + break; + case SOAP_TYPE___inf__GetIderSessionLog: + if (p->size < 0) + delete (struct __inf__GetIderSessionLog*)p->ptr; + else + delete[] (struct __inf__GetIderSessionLog*)p->ptr; + break; + case SOAP_TYPE___net__SetHostName: + if (p->size < 0) + delete (struct __net__SetHostName*)p->ptr; + else + delete[] (struct __net__SetHostName*)p->ptr; + break; + case SOAP_TYPE___net__GetHostName: + if (p->size < 0) + delete (struct __net__GetHostName*)p->ptr; + else + delete[] (struct __net__GetHostName*)p->ptr; + break; + case SOAP_TYPE___net__SetDomainName: + if (p->size < 0) + delete (struct __net__SetDomainName*)p->ptr; + else + delete[] (struct __net__SetDomainName*)p->ptr; + break; + case SOAP_TYPE___net__GetDomainName: + if (p->size < 0) + delete (struct __net__GetDomainName*)p->ptr; + else + delete[] (struct __net__GetDomainName*)p->ptr; + break; + case SOAP_TYPE___net__SetTcpIpParameters: + if (p->size < 0) + delete (struct __net__SetTcpIpParameters*)p->ptr; + else + delete[] (struct __net__SetTcpIpParameters*)p->ptr; + break; + case SOAP_TYPE___net__GetTcpIpParameters: + if (p->size < 0) + delete (struct __net__GetTcpIpParameters*)p->ptr; + else + delete[] (struct __net__GetTcpIpParameters*)p->ptr; + break; + case SOAP_TYPE___net__SetVlanParameters: + if (p->size < 0) + delete (struct __net__SetVlanParameters*)p->ptr; + else + delete[] (struct __net__SetVlanParameters*)p->ptr; + break; + case SOAP_TYPE___net__GetVlanParameters: + if (p->size < 0) + delete (struct __net__GetVlanParameters*)p->ptr; + else + delete[] (struct __net__GetVlanParameters*)p->ptr; + break; + case SOAP_TYPE___net__SetPingResponse: + if (p->size < 0) + delete (struct __net__SetPingResponse*)p->ptr; + else + delete[] (struct __net__SetPingResponse*)p->ptr; + break; + case SOAP_TYPE___net__GetPingResponse: + if (p->size < 0) + delete (struct __net__GetPingResponse*)p->ptr; + else + delete[] (struct __net__GetPingResponse*)p->ptr; + break; + case SOAP_TYPE___net__EnumerateInterfaces: + if (p->size < 0) + delete (struct __net__EnumerateInterfaces*)p->ptr; + else + delete[] (struct __net__EnumerateInterfaces*)p->ptr; + break; + case SOAP_TYPE___net__GetInterfaceSettings: + if (p->size < 0) + delete (struct __net__GetInterfaceSettings*)p->ptr; + else + delete[] (struct __net__GetInterfaceSettings*)p->ptr; + break; + case SOAP_TYPE___net__SetInterfaceSettings: + if (p->size < 0) + delete (struct __net__SetInterfaceSettings*)p->ptr; + else + delete[] (struct __net__SetInterfaceSettings*)p->ptr; + break; + case SOAP_TYPE___net__Set8021XWiredProfile: + if (p->size < 0) + delete (struct __net__Set8021XWiredProfile*)p->ptr; + else + delete[] (struct __net__Set8021XWiredProfile*)p->ptr; + break; + case SOAP_TYPE___net__Get8021XWiredProfile: + if (p->size < 0) + delete (struct __net__Get8021XWiredProfile*)p->ptr; + else + delete[] (struct __net__Get8021XWiredProfile*)p->ptr; + break; + case SOAP_TYPE___net__Set8021XActiveS0: + if (p->size < 0) + delete (struct __net__Set8021XActiveS0*)p->ptr; + else + delete[] (struct __net__Set8021XActiveS0*)p->ptr; + break; + case SOAP_TYPE___net__Get8021XActiveS0: + if (p->size < 0) + delete (struct __net__Get8021XActiveS0*)p->ptr; + else + delete[] (struct __net__Get8021XActiveS0*)p->ptr; + break; + case SOAP_TYPE___net__Set8021XPxeTimeout: + if (p->size < 0) + delete (struct __net__Set8021XPxeTimeout*)p->ptr; + else + delete[] (struct __net__Set8021XPxeTimeout*)p->ptr; + break; + case SOAP_TYPE___net__Get8021XPxeTimeout: + if (p->size < 0) + delete (struct __net__Get8021XPxeTimeout*)p->ptr; + else + delete[] (struct __net__Get8021XPxeTimeout*)p->ptr; + break; + case SOAP_TYPE___rci__GetRemoteControlCapabilities: + if (p->size < 0) + delete (struct __rci__GetRemoteControlCapabilities*)p->ptr; + else + delete[] (struct __rci__GetRemoteControlCapabilities*)p->ptr; + break; + case SOAP_TYPE___rci__RemoteControl: + if (p->size < 0) + delete (struct __rci__RemoteControl*)p->ptr; + else + delete[] (struct __rci__RemoteControl*)p->ptr; + break; + case SOAP_TYPE___rci__GetSystemPowerState: + if (p->size < 0) + delete (struct __rci__GetSystemPowerState*)p->ptr; + else + delete[] (struct __rci__GetSystemPowerState*)p->ptr; + break; + case SOAP_TYPE___sai__ResetFlashWearOutProtection: + if (p->size < 0) + delete (struct __sai__ResetFlashWearOutProtection*)p->ptr; + else + delete[] (struct __sai__ResetFlashWearOutProtection*)p->ptr; + break; + case SOAP_TYPE___sai__GetAdminAclEntry: + if (p->size < 0) + delete (struct __sai__GetAdminAclEntry*)p->ptr; + else + delete[] (struct __sai__GetAdminAclEntry*)p->ptr; + break; + case SOAP_TYPE___sai__SetAdminAclEntry: + if (p->size < 0) + delete (struct __sai__SetAdminAclEntry*)p->ptr; + else + delete[] (struct __sai__SetAdminAclEntry*)p->ptr; + break; + case SOAP_TYPE___sai__AddUserAclEntry: + if (p->size < 0) + delete (struct __sai__AddUserAclEntry*)p->ptr; + else + delete[] (struct __sai__AddUserAclEntry*)p->ptr; + break; + case SOAP_TYPE___sai__EnumerateUserAclEntries: + if (p->size < 0) + delete (struct __sai__EnumerateUserAclEntries*)p->ptr; + else + delete[] (struct __sai__EnumerateUserAclEntries*)p->ptr; + break; + case SOAP_TYPE___sai__GetUserAclEntry: + if (p->size < 0) + delete (struct __sai__GetUserAclEntry*)p->ptr; + else + delete[] (struct __sai__GetUserAclEntry*)p->ptr; + break; + case SOAP_TYPE___sai__UpdateUserAclEntry: + if (p->size < 0) + delete (struct __sai__UpdateUserAclEntry*)p->ptr; + else + delete[] (struct __sai__UpdateUserAclEntry*)p->ptr; + break; + case SOAP_TYPE___sai__RemoveUserAclEntry: + if (p->size < 0) + delete (struct __sai__RemoveUserAclEntry*)p->ptr; + else + delete[] (struct __sai__RemoveUserAclEntry*)p->ptr; + break; + case SOAP_TYPE___sai__SetTlsEnabled: + if (p->size < 0) + delete (struct __sai__SetTlsEnabled*)p->ptr; + else + delete[] (struct __sai__SetTlsEnabled*)p->ptr; + break; + case SOAP_TYPE___sai__SetRngKey: + if (p->size < 0) + delete (struct __sai__SetRngKey*)p->ptr; + else + delete[] (struct __sai__SetRngKey*)p->ptr; + break; + case SOAP_TYPE___sai__SetTLSKeyAndCertificate: + if (p->size < 0) + delete (struct __sai__SetTLSKeyAndCertificate*)p->ptr; + else + delete[] (struct __sai__SetTLSKeyAndCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__SetTLSCertificate: + if (p->size < 0) + delete (struct __sai__SetTLSCertificate*)p->ptr; + else + delete[] (struct __sai__SetTLSCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__GetTLSCertificate: + if (p->size < 0) + delete (struct __sai__GetTLSCertificate*)p->ptr; + else + delete[] (struct __sai__GetTLSCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__UpdateCoreFromUrl: + if (p->size < 0) + delete (struct __sai__UpdateCoreFromUrl*)p->ptr; + else + delete[] (struct __sai__UpdateCoreFromUrl*)p->ptr; + break; + case SOAP_TYPE___sai__GetProvisioningMode: + if (p->size < 0) + delete (struct __sai__GetProvisioningMode*)p->ptr; + else + delete[] (struct __sai__GetProvisioningMode*)p->ptr; + break; + case SOAP_TYPE___sai__SetProvisioningMode: + if (p->size < 0) + delete (struct __sai__SetProvisioningMode*)p->ptr; + else + delete[] (struct __sai__SetProvisioningMode*)p->ptr; + break; + case SOAP_TYPE___sai__Unprovision: + if (p->size < 0) + delete (struct __sai__Unprovision*)p->ptr; + else + delete[] (struct __sai__Unprovision*)p->ptr; + break; + case SOAP_TYPE___sai__CommitChanges: + if (p->size < 0) + delete (struct __sai__CommitChanges*)p->ptr; + else + delete[] (struct __sai__CommitChanges*)p->ptr; + break; + case SOAP_TYPE___sai__GetCoreVersion: + if (p->size < 0) + delete (struct __sai__GetCoreVersion*)p->ptr; + else + delete[] (struct __sai__GetCoreVersion*)p->ptr; + break; + case SOAP_TYPE___sai__AddUserAclEntryEx: + if (p->size < 0) + delete (struct __sai__AddUserAclEntryEx*)p->ptr; + else + delete[] (struct __sai__AddUserAclEntryEx*)p->ptr; + break; + case SOAP_TYPE___sai__GetUserAclEntryEx: + if (p->size < 0) + delete (struct __sai__GetUserAclEntryEx*)p->ptr; + else + delete[] (struct __sai__GetUserAclEntryEx*)p->ptr; + break; + case SOAP_TYPE___sai__UpdateUserAclEntryEx: + if (p->size < 0) + delete (struct __sai__UpdateUserAclEntryEx*)p->ptr; + else + delete[] (struct __sai__UpdateUserAclEntryEx*)p->ptr; + break; + case SOAP_TYPE___sai__SetAdminAclEntryEx: + if (p->size < 0) + delete (struct __sai__SetAdminAclEntryEx*)p->ptr; + else + delete[] (struct __sai__SetAdminAclEntryEx*)p->ptr; + break; + case SOAP_TYPE___sai__GetDigestRealm: + if (p->size < 0) + delete (struct __sai__GetDigestRealm*)p->ptr; + else + delete[] (struct __sai__GetDigestRealm*)p->ptr; + break; + case SOAP_TYPE___sai__SetKerberosOptions: + if (p->size < 0) + delete (struct __sai__SetKerberosOptions*)p->ptr; + else + delete[] (struct __sai__SetKerberosOptions*)p->ptr; + break; + case SOAP_TYPE___sai__GetKerberosOptions: + if (p->size < 0) + delete (struct __sai__GetKerberosOptions*)p->ptr; + else + delete[] (struct __sai__GetKerberosOptions*)p->ptr; + break; + case SOAP_TYPE___sai__SetEnabledInterfaces: + if (p->size < 0) + delete (struct __sai__SetEnabledInterfaces*)p->ptr; + else + delete[] (struct __sai__SetEnabledInterfaces*)p->ptr; + break; + case SOAP_TYPE___sai__GetEnabledInterfaces: + if (p->size < 0) + delete (struct __sai__GetEnabledInterfaces*)p->ptr; + else + delete[] (struct __sai__GetEnabledInterfaces*)p->ptr; + break; + case SOAP_TYPE___sai__SetTlsOptions: + if (p->size < 0) + delete (struct __sai__SetTlsOptions*)p->ptr; + else + delete[] (struct __sai__SetTlsOptions*)p->ptr; + break; + case SOAP_TYPE___sai__GetTlsOptions: + if (p->size < 0) + delete (struct __sai__GetTlsOptions*)p->ptr; + else + delete[] (struct __sai__GetTlsOptions*)p->ptr; + break; + case SOAP_TYPE___sai__AddTrustedRootCertificate: + if (p->size < 0) + delete (struct __sai__AddTrustedRootCertificate*)p->ptr; + else + delete[] (struct __sai__AddTrustedRootCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__GetTrustedRootCertificate: + if (p->size < 0) + delete (struct __sai__GetTrustedRootCertificate*)p->ptr; + else + delete[] (struct __sai__GetTrustedRootCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__DeleteTrustedRootCertificate: + if (p->size < 0) + delete (struct __sai__DeleteTrustedRootCertificate*)p->ptr; + else + delete[] (struct __sai__DeleteTrustedRootCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__EnumerateTrustedRootCertificates: + if (p->size < 0) + delete (struct __sai__EnumerateTrustedRootCertificates*)p->ptr; + else + delete[] (struct __sai__EnumerateTrustedRootCertificates*)p->ptr; + break; + case SOAP_TYPE___sai__SetTrustedFqdnCN: + if (p->size < 0) + delete (struct __sai__SetTrustedFqdnCN*)p->ptr; + else + delete[] (struct __sai__SetTrustedFqdnCN*)p->ptr; + break; + case SOAP_TYPE___sai__GetTrustedFqdnCN: + if (p->size < 0) + delete (struct __sai__GetTrustedFqdnCN*)p->ptr; + else + delete[] (struct __sai__GetTrustedFqdnCN*)p->ptr; + break; + case SOAP_TYPE___sai__SetCRL: + if (p->size < 0) + delete (struct __sai__SetCRL*)p->ptr; + else + delete[] (struct __sai__SetCRL*)p->ptr; + break; + case SOAP_TYPE___sai__GetCRL: + if (p->size < 0) + delete (struct __sai__GetCRL*)p->ptr; + else + delete[] (struct __sai__GetCRL*)p->ptr; + break; + case SOAP_TYPE___sai__GetServerCertificateReq: + if (p->size < 0) + delete (struct __sai__GetServerCertificateReq*)p->ptr; + else + delete[] (struct __sai__GetServerCertificateReq*)p->ptr; + break; + case SOAP_TYPE___sai__GetPkiCapabilities: + if (p->size < 0) + delete (struct __sai__GetPkiCapabilities*)p->ptr; + else + delete[] (struct __sai__GetPkiCapabilities*)p->ptr; + break; + case SOAP_TYPE___sai__SetPowerSavingOptions: + if (p->size < 0) + delete (struct __sai__SetPowerSavingOptions*)p->ptr; + else + delete[] (struct __sai__SetPowerSavingOptions*)p->ptr; + break; + case SOAP_TYPE___sai__GetPowerSavingOptions: + if (p->size < 0) + delete (struct __sai__GetPowerSavingOptions*)p->ptr; + else + delete[] (struct __sai__GetPowerSavingOptions*)p->ptr; + break; + case SOAP_TYPE___sai__SetTLSPSK: + if (p->size < 0) + delete (struct __sai__SetTLSPSK*)p->ptr; + else + delete[] (struct __sai__SetTLSPSK*)p->ptr; + break; + case SOAP_TYPE___sai__PartialUnprovision: + if (p->size < 0) + delete (struct __sai__PartialUnprovision*)p->ptr; + else + delete[] (struct __sai__PartialUnprovision*)p->ptr; + break; + case SOAP_TYPE___sai__SetMEBxPassword: + if (p->size < 0) + delete (struct __sai__SetMEBxPassword*)p->ptr; + else + delete[] (struct __sai__SetMEBxPassword*)p->ptr; + break; + case SOAP_TYPE___sai__SetProvisioningServerOTP: + if (p->size < 0) + delete (struct __sai__SetProvisioningServerOTP*)p->ptr; + else + delete[] (struct __sai__SetProvisioningServerOTP*)p->ptr; + break; + case SOAP_TYPE___sai__GetProvisioningServerOTP: + if (p->size < 0) + delete (struct __sai__GetProvisioningServerOTP*)p->ptr; + else + delete[] (struct __sai__GetProvisioningServerOTP*)p->ptr; + break; + case SOAP_TYPE___sai__EnumerateCertificateHashEntries: + if (p->size < 0) + delete (struct __sai__EnumerateCertificateHashEntries*)p->ptr; + else + delete[] (struct __sai__EnumerateCertificateHashEntries*)p->ptr; + break; + case SOAP_TYPE___sai__GetCertificateHashEntry: + if (p->size < 0) + delete (struct __sai__GetCertificateHashEntry*)p->ptr; + else + delete[] (struct __sai__GetCertificateHashEntry*)p->ptr; + break; + case SOAP_TYPE___sai__AddCertificateHashEntry: + if (p->size < 0) + delete (struct __sai__AddCertificateHashEntry*)p->ptr; + else + delete[] (struct __sai__AddCertificateHashEntry*)p->ptr; + break; + case SOAP_TYPE___sai__DeleteCertificateHashEntry: + if (p->size < 0) + delete (struct __sai__DeleteCertificateHashEntry*)p->ptr; + else + delete[] (struct __sai__DeleteCertificateHashEntry*)p->ptr; + break; + case SOAP_TYPE___sai__EnableCertificateHashEntry: + if (p->size < 0) + delete (struct __sai__EnableCertificateHashEntry*)p->ptr; + else + delete[] (struct __sai__EnableCertificateHashEntry*)p->ptr; + break; + case SOAP_TYPE___sai__GetZeroTouchConfigurationMode: + if (p->size < 0) + delete (struct __sai__GetZeroTouchConfigurationMode*)p->ptr; + else + delete[] (struct __sai__GetZeroTouchConfigurationMode*)p->ptr; + break; + case SOAP_TYPE___sai__SetZeroTouchConfigurationMode: + if (p->size < 0) + delete (struct __sai__SetZeroTouchConfigurationMode*)p->ptr; + else + delete[] (struct __sai__SetZeroTouchConfigurationMode*)p->ptr; + break; + case SOAP_TYPE___sai__GetProvisioningAuditRecord: + if (p->size < 0) + delete (struct __sai__GetProvisioningAuditRecord*)p->ptr; + else + delete[] (struct __sai__GetProvisioningAuditRecord*)p->ptr; + break; + case SOAP_TYPE___sai__GetProvisioningPID: + if (p->size < 0) + delete (struct __sai__GetProvisioningPID*)p->ptr; + else + delete[] (struct __sai__GetProvisioningPID*)p->ptr; + break; + case SOAP_TYPE___sai__ExtendProvisioningPeriod: + if (p->size < 0) + delete (struct __sai__ExtendProvisioningPeriod*)p->ptr; + else + delete[] (struct __sai__ExtendProvisioningPeriod*)p->ptr; + break; + case SOAP_TYPE___sai__GetRealmAuthOptions: + if (p->size < 0) + delete (struct __sai__GetRealmAuthOptions*)p->ptr; + else + delete[] (struct __sai__GetRealmAuthOptions*)p->ptr; + break; + case SOAP_TYPE___sai__SetRealmAuthOptions: + if (p->size < 0) + delete (struct __sai__SetRealmAuthOptions*)p->ptr; + else + delete[] (struct __sai__SetRealmAuthOptions*)p->ptr; + break; + case SOAP_TYPE___sai__SetEnvironmentDetection: + if (p->size < 0) + delete (struct __sai__SetEnvironmentDetection*)p->ptr; + else + delete[] (struct __sai__SetEnvironmentDetection*)p->ptr; + break; + case SOAP_TYPE___sai__GetEnvironmentDetection: + if (p->size < 0) + delete (struct __sai__GetEnvironmentDetection*)p->ptr; + else + delete[] (struct __sai__GetEnvironmentDetection*)p->ptr; + break; + case SOAP_TYPE___sai__EnumeratePowerPackages: + if (p->size < 0) + delete (struct __sai__EnumeratePowerPackages*)p->ptr; + else + delete[] (struct __sai__EnumeratePowerPackages*)p->ptr; + break; + case SOAP_TYPE___sai__GetPowerPackage: + if (p->size < 0) + delete (struct __sai__GetPowerPackage*)p->ptr; + else + delete[] (struct __sai__GetPowerPackage*)p->ptr; + break; + case SOAP_TYPE___sai__GetActivePowerPackage: + if (p->size < 0) + delete (struct __sai__GetActivePowerPackage*)p->ptr; + else + delete[] (struct __sai__GetActivePowerPackage*)p->ptr; + break; + case SOAP_TYPE___sai__SetActivePowerPackage: + if (p->size < 0) + delete (struct __sai__SetActivePowerPackage*)p->ptr; + else + delete[] (struct __sai__SetActivePowerPackage*)p->ptr; + break; + case SOAP_TYPE___sai__SetGlobalPowerPolicy: + if (p->size < 0) + delete (struct __sai__SetGlobalPowerPolicy*)p->ptr; + else + delete[] (struct __sai__SetGlobalPowerPolicy*)p->ptr; + break; + case SOAP_TYPE___sai__GetGlobalPowerPolicy: + if (p->size < 0) + delete (struct __sai__GetGlobalPowerPolicy*)p->ptr; + else + delete[] (struct __sai__GetGlobalPowerPolicy*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreAddKey: + if (p->size < 0) + delete (struct __sai__CertStoreAddKey*)p->ptr; + else + delete[] (struct __sai__CertStoreAddKey*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreEnumerateKeys: + if (p->size < 0) + delete (struct __sai__CertStoreEnumerateKeys*)p->ptr; + else + delete[] (struct __sai__CertStoreEnumerateKeys*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreGetKey: + if (p->size < 0) + delete (struct __sai__CertStoreGetKey*)p->ptr; + else + delete[] (struct __sai__CertStoreGetKey*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreRemoveKey: + if (p->size < 0) + delete (struct __sai__CertStoreRemoveKey*)p->ptr; + else + delete[] (struct __sai__CertStoreRemoveKey*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreAddCertificate: + if (p->size < 0) + delete (struct __sai__CertStoreAddCertificate*)p->ptr; + else + delete[] (struct __sai__CertStoreAddCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreGetCertificate: + if (p->size < 0) + delete (struct __sai__CertStoreGetCertificate*)p->ptr; + else + delete[] (struct __sai__CertStoreGetCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreEnumerateCertificates: + if (p->size < 0) + delete (struct __sai__CertStoreEnumerateCertificates*)p->ptr; + else + delete[] (struct __sai__CertStoreEnumerateCertificates*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreRemoveCertificate: + if (p->size < 0) + delete (struct __sai__CertStoreRemoveCertificate*)p->ptr; + else + delete[] (struct __sai__CertStoreRemoveCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreGetPKCS10Request: + if (p->size < 0) + delete (struct __sai__CertStoreGetPKCS10Request*)p->ptr; + else + delete[] (struct __sai__CertStoreGetPKCS10Request*)p->ptr; + break; + case SOAP_TYPE___sai__CertStoreUpdateCertificate: + if (p->size < 0) + delete (struct __sai__CertStoreUpdateCertificate*)p->ptr; + else + delete[] (struct __sai__CertStoreUpdateCertificate*)p->ptr; + break; + case SOAP_TYPE___sai__SetTLSCredentials: + if (p->size < 0) + delete (struct __sai__SetTLSCredentials*)p->ptr; + else + delete[] (struct __sai__SetTLSCredentials*)p->ptr; + break; + case SOAP_TYPE___sai__GetTLSCredentials: + if (p->size < 0) + delete (struct __sai__GetTLSCredentials*)p->ptr; + else + delete[] (struct __sai__GetTLSCredentials*)p->ptr; + break; + case SOAP_TYPE___sai__EnableVpnRouting: + if (p->size < 0) + delete (struct __sai__EnableVpnRouting*)p->ptr; + else + delete[] (struct __sai__EnableVpnRouting*)p->ptr; + break; + case SOAP_TYPE___sai__GetConfigurationServerFQDN: + if (p->size < 0) + delete (struct __sai__GetConfigurationServerFQDN*)p->ptr; + else + delete[] (struct __sai__GetConfigurationServerFQDN*)p->ptr; + break; + case SOAP_TYPE___sai__SetConfigurationServerFQDN: + if (p->size < 0) + delete (struct __sai__SetConfigurationServerFQDN*)p->ptr; + else + delete[] (struct __sai__SetConfigurationServerFQDN*)p->ptr; + break; + case SOAP_TYPE___sai__SetAclEnabledState: + if (p->size < 0) + delete (struct __sai__SetAclEnabledState*)p->ptr; + else + delete[] (struct __sai__SetAclEnabledState*)p->ptr; + break; + case SOAP_TYPE___sai__GetAclEnabledState: + if (p->size < 0) + delete (struct __sai__GetAclEnabledState*)p->ptr; + else + delete[] (struct __sai__GetAclEnabledState*)p->ptr; + break; + case SOAP_TYPE___str__ExecuteStorageOperation: + if (p->size < 0) + delete (struct __str__ExecuteStorageOperation*)p->ptr; + else + delete[] (struct __str__ExecuteStorageOperation*)p->ptr; + break; + case SOAP_TYPE___stra__GetGlobalStorageAttributes: + if (p->size < 0) + delete (struct __stra__GetGlobalStorageAttributes*)p->ptr; + else + delete[] (struct __stra__GetGlobalStorageAttributes*)p->ptr; + break; + case SOAP_TYPE___stra__SetGlobalStorageAttributes: + if (p->size < 0) + delete (struct __stra__SetGlobalStorageAttributes*)p->ptr; + else + delete[] (struct __stra__SetGlobalStorageAttributes*)p->ptr; + break; + case SOAP_TYPE___stra__AdminGetRegisteredApplications: + if (p->size < 0) + delete (struct __stra__AdminGetRegisteredApplications*)p->ptr; + else + delete[] (struct __stra__AdminGetRegisteredApplications*)p->ptr; + break; + case SOAP_TYPE___stra__AdminGetApplicationAttributes: + if (p->size < 0) + delete (struct __stra__AdminGetApplicationAttributes*)p->ptr; + else + delete[] (struct __stra__AdminGetApplicationAttributes*)p->ptr; + break; + case SOAP_TYPE___stra__AdminRemoveApplication: + if (p->size < 0) + delete (struct __stra__AdminRemoveApplication*)p->ptr; + else + delete[] (struct __stra__AdminRemoveApplication*)p->ptr; + break; + case SOAP_TYPE___stra__AddStorageEaclEntry: + if (p->size < 0) + delete (struct __stra__AddStorageEaclEntry*)p->ptr; + else + delete[] (struct __stra__AddStorageEaclEntry*)p->ptr; + break; + case SOAP_TYPE___stra__EnumerateStorageEaclEntries: + if (p->size < 0) + delete (struct __stra__EnumerateStorageEaclEntries*)p->ptr; + else + delete[] (struct __stra__EnumerateStorageEaclEntries*)p->ptr; + break; + case SOAP_TYPE___stra__GetStorageEaclEntry: + if (p->size < 0) + delete (struct __stra__GetStorageEaclEntry*)p->ptr; + else + delete[] (struct __stra__GetStorageEaclEntry*)p->ptr; + break; + case SOAP_TYPE___stra__RemoveStorageEaclEntry: + if (p->size < 0) + delete (struct __stra__RemoveStorageEaclEntry*)p->ptr; + else + delete[] (struct __stra__RemoveStorageEaclEntry*)p->ptr; + break; + case SOAP_TYPE___stra__AddStorageFpaclEntry: + if (p->size < 0) + delete (struct __stra__AddStorageFpaclEntry*)p->ptr; + else + delete[] (struct __stra__AddStorageFpaclEntry*)p->ptr; + break; + case SOAP_TYPE___stra__EnumerateStorageAllocEntries: + if (p->size < 0) + delete (struct __stra__EnumerateStorageAllocEntries*)p->ptr; + else + delete[] (struct __stra__EnumerateStorageAllocEntries*)p->ptr; + break; + case SOAP_TYPE___stra__GetStorageAllocEntry: + if (p->size < 0) + delete (struct __stra__GetStorageAllocEntry*)p->ptr; + else + delete[] (struct __stra__GetStorageAllocEntry*)p->ptr; + break; + case SOAP_TYPE___stra__UpdateStorageFpaclEntry: + if (p->size < 0) + delete (struct __stra__UpdateStorageFpaclEntry*)p->ptr; + else + delete[] (struct __stra__UpdateStorageFpaclEntry*)p->ptr; + break; + case SOAP_TYPE___stra__RemoveStorageFpaclEntry: + if (p->size < 0) + delete (struct __stra__RemoveStorageFpaclEntry*)p->ptr; + else + delete[] (struct __stra__RemoveStorageFpaclEntry*)p->ptr; + break; + case SOAP_TYPE___tim__GetLowAccuracyTimeSynch: + if (p->size < 0) + delete (struct __tim__GetLowAccuracyTimeSynch*)p->ptr; + else + delete[] (struct __tim__GetLowAccuracyTimeSynch*)p->ptr; + break; + case SOAP_TYPE___tim__SetHighAccuracyTimeSynch: + if (p->size < 0) + delete (struct __tim__SetHighAccuracyTimeSynch*)p->ptr; + else + delete[] (struct __tim__SetHighAccuracyTimeSynch*)p->ptr; + break; + case SOAP_TYPE___wcxs__AddWirelessProfile: + if (p->size < 0) + delete (struct __wcxs__AddWirelessProfile*)p->ptr; + else + delete[] (struct __wcxs__AddWirelessProfile*)p->ptr; + break; + case SOAP_TYPE___wcxs__GetWirelessProfile: + if (p->size < 0) + delete (struct __wcxs__GetWirelessProfile*)p->ptr; + else + delete[] (struct __wcxs__GetWirelessProfile*)p->ptr; + break; + case SOAP_TYPE___wcxs__RemoveWirelessProfile: + if (p->size < 0) + delete (struct __wcxs__RemoveWirelessProfile*)p->ptr; + else + delete[] (struct __wcxs__RemoveWirelessProfile*)p->ptr; + break; + case SOAP_TYPE___wcxs__UpdateWirelessProfile: + if (p->size < 0) + delete (struct __wcxs__UpdateWirelessProfile*)p->ptr; + else + delete[] (struct __wcxs__UpdateWirelessProfile*)p->ptr; + break; + case SOAP_TYPE___wcxs__EnumerateWirelessProfiles: + if (p->size < 0) + delete (struct __wcxs__EnumerateWirelessProfiles*)p->ptr; + else + delete[] (struct __wcxs__EnumerateWirelessProfiles*)p->ptr; + break; + case SOAP_TYPE___wcxs__GetWirelessCapabilities: + if (p->size < 0) + delete (struct __wcxs__GetWirelessCapabilities*)p->ptr; + else + delete[] (struct __wcxs__GetWirelessCapabilities*)p->ptr; + break; + case SOAP_TYPE___wcxs__GetWirelessSettings: + if (p->size < 0) + delete (struct __wcxs__GetWirelessSettings*)p->ptr; + else + delete[] (struct __wcxs__GetWirelessSettings*)p->ptr; + break; + case SOAP_TYPE_SOAP_ENV__Header: + if (p->size < 0) + delete (struct SOAP_ENV__Header*)p->ptr; + else + delete[] (struct SOAP_ENV__Header*)p->ptr; + break; + case SOAP_TYPE_SOAP_ENV__Code: + if (p->size < 0) + delete (struct SOAP_ENV__Code*)p->ptr; + else + delete[] (struct SOAP_ENV__Code*)p->ptr; + break; + case SOAP_TYPE_SOAP_ENV__Detail: + if (p->size < 0) + delete (struct SOAP_ENV__Detail*)p->ptr; + else + delete[] (struct SOAP_ENV__Detail*)p->ptr; + break; + case SOAP_TYPE_SOAP_ENV__Reason: + if (p->size < 0) + delete (struct SOAP_ENV__Reason*)p->ptr; + else + delete[] (struct SOAP_ENV__Reason*)p->ptr; + break; + case SOAP_TYPE_SOAP_ENV__Fault: + if (p->size < 0) + delete (struct SOAP_ENV__Fault*)p->ptr; + else + delete[] (struct SOAP_ENV__Fault*)p->ptr; + break; + case SOAP_TYPE_xsd__anyURI: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_cmn__HostNameType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_cmn__IPv4AddressStringType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_cmn__IPv6AddressStringType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_cmn__GuidBuf: + if (p->size < 0) + delete (xsd__base64Binary*)p->ptr; + else + delete[] (xsd__base64Binary*)p->ptr; + break; + case SOAP_TYPE_sai__AclStringType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_sai__AclPasswordStringType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_sai__MEBxPasswordType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_sai__ProvisioningOTPType: + if (p->size < 0) + delete (xsd__base64Binary*)p->ptr; + else + delete[] (xsd__base64Binary*)p->ptr; + break; + case SOAP_TYPE_sai__FriendlyNameType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE__sai__SpnString: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE__sai__KerberosRealmName: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_net__MACAddressType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_emi__CommunityStringType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_cb__IPv4AddressStringType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_cb__IPv6AddressStringType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE__cb__FilterName: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE__cb__PolicyName: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE__apr__AgentDescription: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_wcxs__ProfileNameType: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_wcxs__RawKey64Type: + if (p->size < 0) + delete (xsd__base64Binary*)p->ptr; + else + delete[] (xsd__base64Binary*)p->ptr; + break; + case SOAP_TYPE_wcxs__RawKey128Type: + if (p->size < 0) + delete (xsd__base64Binary*)p->ptr; + else + delete[] (xsd__base64Binary*)p->ptr; + break; + case SOAP_TYPE_wcxs__RawKey256Type: + if (p->size < 0) + delete (xsd__base64Binary*)p->ptr; + else + delete[] (xsd__base64Binary*)p->ptr; + break; + case SOAP_TYPE_wcxs__PassPhrase5Type: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_wcxs__PassPhraseWEP128Type: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_wcxs__PassPhrase63Type: + if (p->size < 0) + delete (std::string*)p->ptr; + else + delete[] (std::string*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfwcxs__ProfileNameType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfwcxs__FeatureType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfinf__EnabledInterfacesType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToinf__FirmwareVersionType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfunsignedShort: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTohwa__AssetDataType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfhwa__AssetTypeType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__AlertAuthOptionsType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__SensorHandleType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToemi__EventLogRecordType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__EventFilterHandleType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionHandleType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfstra__StorageApplicationHandleType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfunsignedByte: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfstra__StorageAllocEntryHandleType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfstra__StorageEaclEntryHandleType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfnet__InterfaceHandleType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfcmn__GuidBuf: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTosai__CrlType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfsai__CertificateHandleType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTosai__TlsOptionsType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfsai__EnabledInterfacesType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfstd__string: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfunsignedInt: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfxsd__base64Binary: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTosai__KerberosSpnType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfsai__UserAclRealmType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + case SOAP_TYPE_std__vectorTemplateOfsai__UserAclEntryHandleType: + if (p->size < 0) + delete (std::vector*)p->ptr; + else + delete[] (std::vector*)p->ptr; + break; + } +} + +SOAP_FMAC3 void* SOAP_FMAC4 soap_class_id_enter(struct soap *soap, const char *id, void *p, int t, size_t n, const char *type, const char *arrayType) +{ return soap_id_enter(soap, id, p, t, n, 0, type, arrayType, soap_instantiate); +} + +SOAP_FMAC3 void* SOAP_FMAC4 soap_container_id_forward(struct soap *soap, const char *href, void *p, size_t len, int st, int tt, size_t n, unsigned int k) +{ return soap_id_forward(soap, href, p, len, st, tt, n, k, soap_container_insert); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_container_insert(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ switch (tt) + { + case SOAP_TYPE_std__vectorTemplateOfwcxs__ProfileNameType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(std::string *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfwcxs__FeatureType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(enum wcxs__FeatureType *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(inf__IderSessionLogEntryType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfinf__EnabledInterfacesType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(enum inf__EnabledInterfacesType *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToinf__FirmwareVersionType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(inf__FirmwareVersionType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(idr__IderSessionLogEntryType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(apr__CircuitBreakerHardwarePolicyType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(apr__ConsoleWatchdogActionType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(apr__ConsoleWatchdogEntryType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfunsignedShort: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned short *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTohwa__AssetDataType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(hwa__AssetDataType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfhwa__AssetTypeType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(enum hwa__AssetTypeType *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(cb__CircuitBreakerCapabilitiesType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(cb__CircuitBreakerFilterInfoType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(cb__CircuitBreakerFilterStatisticsType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(cb__CircuitBreakerHardwarePolicyType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(cb__CircuitBreakerPolicyInfoType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__AlertAuthOptionsType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(enum emi__AlertAuthOptionsType *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__SensorHandleType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerToemi__EventLogRecordType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(emi__EventLogRecordType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__EventFilterHandleType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionHandleType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned char *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfstra__StorageApplicationHandleType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfunsignedByte: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned char *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfstra__StorageAllocEntryHandleType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfstra__StorageEaclEntryHandleType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfnet__InterfaceHandleType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfcmn__GuidBuf: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(xsd__base64Binary *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTosai__CrlType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(sai__CrlType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfsai__CertificateHandleType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTosai__TlsOptionsType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(sai__TlsOptionsType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfsai__EnabledInterfacesType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(enum sai__EnabledInterfacesType *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfstd__string: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(std::string *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfunsignedInt: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfxsd__base64Binary: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(xsd__base64Binary *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfPointerTosai__KerberosSpnType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(sai__KerberosSpnType **)q; + break; + case SOAP_TYPE_std__vectorTemplateOfsai__UserAclRealmType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(enum sai__UserAclRealmType *)q; + break; + case SOAP_TYPE_std__vectorTemplateOfsai__UserAclEntryHandleType: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Container insert type=%d in %d location=%p object=%p len=%lu\n", st, tt, p, q, (unsigned long)len)); + (*(std::vector*)p)[len] = *(unsigned int *)q; + break; + default: + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not insert type=%d in %d\n", st, tt)); + } +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_byte + *a = SOAP_DEFAULT_byte; +#else + *a = (char)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte); + if (soap_out_byte(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type) +{ + return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte); +} + +SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type) +{ + if ((p = soap_in_byte(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type) +{ + return soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_short(struct soap *soap, short *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_short + *a = SOAP_DEFAULT_short; +#else + *a = (short)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_short(struct soap *soap, const short *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_short); + if (soap_out_short(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_short(struct soap *soap, const char *tag, int id, const short *a, const char *type) +{ + return soap_outshort(soap, tag, id, a, type, SOAP_TYPE_short); +} + +SOAP_FMAC3 short * SOAP_FMAC4 soap_get_short(struct soap *soap, short *p, const char *tag, const char *type) +{ + if ((p = soap_in_short(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 short * SOAP_FMAC4 soap_in_short(struct soap *soap, const char *tag, short *a, const char *type) +{ + return soap_inshort(soap, tag, a, type, SOAP_TYPE_short); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_int + *a = SOAP_DEFAULT_int; +#else + *a = (int)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int); + if (soap_out_int(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type) +{ + return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int); +} + +SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type) +{ + if ((p = soap_in_int(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type) +{ + return soap_inint(soap, tag, a, type, SOAP_TYPE_int); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__ProfilePriorityType(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__ProfilePriorityType(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_wcxs__ProfilePriorityType); + if (soap_out_wcxs__ProfilePriorityType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfilePriorityType(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_wcxs__ProfilePriorityType); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_wcxs__ProfilePriorityType(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__ProfilePriorityType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_wcxs__ProfilePriorityType(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_wcxs__ProfilePriorityType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SystemCapabilitiesSupportedType(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SystemCapabilitiesSupportedType(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__SystemCapabilitiesSupportedType); + if (soap_out_rci__SystemCapabilitiesSupportedType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SystemCapabilitiesSupportedType(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_rci__SystemCapabilitiesSupportedType); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_rci__SystemCapabilitiesSupportedType(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__SystemCapabilitiesSupportedType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_rci__SystemCapabilitiesSupportedType(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_rci__SystemCapabilitiesSupportedType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_apr__WatchdogState(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_apr__WatchdogState(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_apr__WatchdogState); + if (soap_out_apr__WatchdogState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__WatchdogState(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_apr__WatchdogState); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_apr__WatchdogState(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_apr__WatchdogState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_apr__WatchdogState(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_apr__WatchdogState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE); + if (soap_out_hwa__PT_USCOREMEMORY_USCORETYPE(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREMEMORY_USCORETYPE(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEMORY_USCORETYPE(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR); + if (soap_out_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE); + if (soap_out_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS); + if (soap_out_hwa__PT_USCOREPROCESSOR_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREPROCESSOR_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR_USCORESTATUS(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY); + if (soap_out_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCOREFAMILY); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE); + if (soap_out_hwa__PT_USCOREPROCESSOR_USCORETYPE(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREPROCESSOR_USCORETYPE(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR_USCORETYPE(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_hwa__PT_USCOREPROCESSOR_USCORETYPE); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__AlertSubscriptionPolicyIDType(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__AlertSubscriptionPolicyIDType(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__AlertSubscriptionPolicyIDType); + if (soap_out_emi__AlertSubscriptionPolicyIDType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionPolicyIDType(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_emi__AlertSubscriptionPolicyIDType); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_emi__AlertSubscriptionPolicyIDType(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertSubscriptionPolicyIDType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_emi__AlertSubscriptionPolicyIDType(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_emi__AlertSubscriptionPolicyIDType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__LinkPolicyType(struct soap *soap, unsigned char *a) +{ soap_default_unsignedByte(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__LinkPolicyType(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_net__LinkPolicyType); + if (soap_out_net__LinkPolicyType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__LinkPolicyType(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_net__LinkPolicyType); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_net__LinkPolicyType(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__LinkPolicyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_net__LinkPolicyType(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_net__LinkPolicyType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedByte(struct soap *soap, unsigned char *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_unsignedByte + *a = SOAP_DEFAULT_unsignedByte; +#else + *a = (unsigned char)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedByte(struct soap *soap, const unsigned char *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_unsignedByte); + if (soap_out_unsignedByte(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedByte(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type) +{ + return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_unsignedByte); +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_unsignedByte(struct soap *soap, unsigned char *p, const char *tag, const char *type) +{ + if ((p = soap_in_unsignedByte(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_unsignedByte(struct soap *soap, const char *tag, unsigned char *a, const char *type) +{ + return soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_unsignedByte); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__OemParametersType(struct soap *soap, unsigned short *a) +{ soap_default_unsignedShort(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__OemParametersType(struct soap *soap, const unsigned short *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__OemParametersType); + if (soap_out_rci__OemParametersType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__OemParametersType(struct soap *soap, const char *tag, int id, const unsigned short *a, const char *type) +{ + return soap_outunsignedShort(soap, tag, id, a, type, SOAP_TYPE_rci__OemParametersType); +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_rci__OemParametersType(struct soap *soap, unsigned short *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__OemParametersType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_rci__OemParametersType(struct soap *soap, const char *tag, unsigned short *a, const char *type) +{ + return soap_inunsignedShort(soap, tag, a, type, SOAP_TYPE_rci__OemParametersType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SpecialCommandParameterType(struct soap *soap, unsigned short *a) +{ soap_default_unsignedShort(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SpecialCommandParameterType(struct soap *soap, const unsigned short *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__SpecialCommandParameterType); + if (soap_out_rci__SpecialCommandParameterType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SpecialCommandParameterType(struct soap *soap, const char *tag, int id, const unsigned short *a, const char *type) +{ + return soap_outunsignedShort(soap, tag, id, a, type, SOAP_TYPE_rci__SpecialCommandParameterType); +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_rci__SpecialCommandParameterType(struct soap *soap, unsigned short *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__SpecialCommandParameterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_rci__SpecialCommandParameterType(struct soap *soap, const char *tag, unsigned short *a, const char *type) +{ + return soap_inunsignedShort(soap, tag, a, type, SOAP_TYPE_rci__SpecialCommandParameterType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__BootOptionsType(struct soap *soap, unsigned short *a) +{ soap_default_unsignedShort(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__BootOptionsType(struct soap *soap, const unsigned short *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__BootOptionsType); + if (soap_out_rci__BootOptionsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__BootOptionsType(struct soap *soap, const char *tag, int id, const unsigned short *a, const char *type) +{ + return soap_outunsignedShort(soap, tag, id, a, type, SOAP_TYPE_rci__BootOptionsType); +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_rci__BootOptionsType(struct soap *soap, unsigned short *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__BootOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_rci__BootOptionsType(struct soap *soap, const char *tag, unsigned short *a, const char *type) +{ + return soap_inunsignedShort(soap, tag, a, type, SOAP_TYPE_rci__BootOptionsType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SpecialCommandsSupportedType(struct soap *soap, unsigned short *a) +{ soap_default_unsignedShort(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SpecialCommandsSupportedType(struct soap *soap, const unsigned short *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__SpecialCommandsSupportedType); + if (soap_out_rci__SpecialCommandsSupportedType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SpecialCommandsSupportedType(struct soap *soap, const char *tag, int id, const unsigned short *a, const char *type) +{ + return soap_outunsignedShort(soap, tag, id, a, type, SOAP_TYPE_rci__SpecialCommandsSupportedType); +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_rci__SpecialCommandsSupportedType(struct soap *soap, unsigned short *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__SpecialCommandsSupportedType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_rci__SpecialCommandsSupportedType(struct soap *soap, const char *tag, unsigned short *a, const char *type) +{ + return soap_inunsignedShort(soap, tag, a, type, SOAP_TYPE_rci__SpecialCommandsSupportedType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap *soap, unsigned short *a) +{ soap_default_unsignedShort(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap *soap, const unsigned short *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL); + if (soap_out_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap *soap, const char *tag, int id, const unsigned short *a, const char *type) +{ + return soap_outunsignedShort(soap, tag, id, a, type, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL); +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap *soap, unsigned short *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(struct soap *soap, const char *tag, unsigned short *a, const char *type) +{ + return soap_inunsignedShort(soap, tag, a, type, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedShort(struct soap *soap, unsigned short *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_unsignedShort + *a = SOAP_DEFAULT_unsignedShort; +#else + *a = (unsigned short)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedShort(struct soap *soap, const unsigned short *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_unsignedShort); + if (soap_out_unsignedShort(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedShort(struct soap *soap, const char *tag, int id, const unsigned short *a, const char *type) +{ + return soap_outunsignedShort(soap, tag, id, a, type, SOAP_TYPE_unsignedShort); +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_get_unsignedShort(struct soap *soap, unsigned short *p, const char *tag, const char *type) +{ + if ((p = soap_in_unsignedShort(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short * SOAP_FMAC4 soap_in_unsignedShort(struct soap *soap, const char *tag, unsigned short *a, const char *type) +{ + return soap_inunsignedShort(soap, tag, a, type, SOAP_TYPE_unsignedShort); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__OemDefinedCapabilitiesType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__OemDefinedCapabilitiesType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__OemDefinedCapabilitiesType); + if (soap_out_rci__OemDefinedCapabilitiesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__OemDefinedCapabilitiesType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_rci__OemDefinedCapabilitiesType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_rci__OemDefinedCapabilitiesType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__OemDefinedCapabilitiesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_rci__OemDefinedCapabilitiesType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_rci__OemDefinedCapabilitiesType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SystemFirmwareCapabilitiesType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SystemFirmwareCapabilitiesType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__SystemFirmwareCapabilitiesType); + if (soap_out_rci__SystemFirmwareCapabilitiesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SystemFirmwareCapabilitiesType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_rci__SystemFirmwareCapabilitiesType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_rci__SystemFirmwareCapabilitiesType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__SystemFirmwareCapabilitiesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_rci__SystemFirmwareCapabilitiesType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_rci__SystemFirmwareCapabilitiesType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__PT_USCORESTATUS); + if (soap_out_rci__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_rci__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_rci__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_rci__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_rci__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SystemPowerStateType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SystemPowerStateType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__SystemPowerStateType); + if (soap_out_rci__SystemPowerStateType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SystemPowerStateType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_rci__SystemPowerStateType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_rci__SystemPowerStateType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__SystemPowerStateType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_rci__SystemPowerStateType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_rci__SystemPowerStateType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__IPv4AddressType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__IPv4AddressType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_inf__IPv4AddressType); + if (soap_out_inf__IPv4AddressType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__IPv4AddressType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_inf__IPv4AddressType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_inf__IPv4AddressType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_inf__IPv4AddressType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_inf__IPv4AddressType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_inf__IPv4AddressType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__TimeType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__TimeType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_inf__TimeType); + if (soap_out_inf__TimeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__TimeType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_inf__TimeType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_inf__TimeType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_inf__TimeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_inf__TimeType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_inf__TimeType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_inf__PT_USCORESTATUS); + if (soap_out_inf__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_inf__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_inf__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_inf__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_inf__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_inf__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_str__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_str__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_str__PT_USCORESTATUS); + if (soap_out_str__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_str__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_str__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_str__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_str__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_str__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_str__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_tim__TimeType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_tim__TimeType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_tim__TimeType); + if (soap_out_tim__TimeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_tim__TimeType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_tim__TimeType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_tim__TimeType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_tim__TimeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_tim__TimeType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_tim__TimeType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_tim__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_tim__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_tim__PT_USCORESTATUS); + if (soap_out_tim__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_tim__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_tim__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_tim__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_tim__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_tim__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_tim__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_idr__IPv4AddressType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_idr__IPv4AddressType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_idr__IPv4AddressType); + if (soap_out_idr__IPv4AddressType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__IPv4AddressType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_idr__IPv4AddressType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_idr__IPv4AddressType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_idr__IPv4AddressType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_idr__IPv4AddressType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_idr__IPv4AddressType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_idr__TimeType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_idr__TimeType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_idr__TimeType); + if (soap_out_idr__TimeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__TimeType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_idr__TimeType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_idr__TimeType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_idr__TimeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_idr__TimeType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_idr__TimeType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_idr__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_idr__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_idr__PT_USCORESTATUS); + if (soap_out_idr__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_idr__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_idr__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_idr__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_idr__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_idr__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_apl__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_apl__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_apl__PT_USCORESTATUS); + if (soap_out_apl__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apl__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_apl__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_apl__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_apl__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_apl__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_apl__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_apr__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_apr__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_apr__PT_USCORESTATUS); + if (soap_out_apr__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_apr__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_apr__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_apr__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_apr__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_apr__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS); + if (soap_out_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCORESTATUS); + if (soap_out_hwa__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_hwa__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_hwa__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_hwa__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_hwa__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__TimeType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__TimeType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__TimeType); + if (soap_out_cb__TimeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__TimeType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_cb__TimeType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cb__TimeType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__TimeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cb__TimeType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_cb__TimeType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__PT_USCORESTATUS); + if (soap_out_cb__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_cb__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cb__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cb__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_cb__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__SensorHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__SensorHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__SensorHandleType); + if (soap_out_emi__SensorHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__SensorHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_emi__SensorHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__SensorHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__SensorHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__SensorHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_emi__SensorHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__IPv4AddressType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__IPv4AddressType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__IPv4AddressType); + if (soap_out_emi__IPv4AddressType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__IPv4AddressType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_emi__IPv4AddressType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__IPv4AddressType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__IPv4AddressType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__IPv4AddressType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_emi__IPv4AddressType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__PT_USCORESTATUS); + if (soap_out_emi__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_emi__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_emi__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__EventFilterHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__EventFilterHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__EventFilterHandleType); + if (soap_out_emi__EventFilterHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventFilterHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_emi__EventFilterHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__EventFilterHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__EventFilterHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__EventFilterHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_emi__EventFilterHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__AlertSubscriptionHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__AlertSubscriptionHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__AlertSubscriptionHandleType); + if (soap_out_emi__AlertSubscriptionHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_emi__AlertSubscriptionHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__AlertSubscriptionHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertSubscriptionHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__AlertSubscriptionHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_emi__AlertSubscriptionHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__TimeType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__TimeType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__TimeType); + if (soap_out_emi__TimeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__TimeType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_emi__TimeType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_emi__TimeType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__TimeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_emi__TimeType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_emi__TimeType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__StorageAllocEntryHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__StorageAllocEntryHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_stra__StorageAllocEntryHandleType); + if (soap_out_stra__StorageAllocEntryHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageAllocEntryHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_stra__StorageAllocEntryHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_stra__StorageAllocEntryHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageAllocEntryHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_stra__StorageAllocEntryHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_stra__StorageAllocEntryHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__StorageEaclEntryHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__StorageEaclEntryHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_stra__StorageEaclEntryHandleType); + if (soap_out_stra__StorageEaclEntryHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageEaclEntryHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_stra__StorageEaclEntryHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_stra__StorageEaclEntryHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageEaclEntryHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_stra__StorageEaclEntryHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_stra__StorageEaclEntryHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__StorageApplicationHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__StorageApplicationHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_stra__StorageApplicationHandleType); + if (soap_out_stra__StorageApplicationHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageApplicationHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_stra__StorageApplicationHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_stra__StorageApplicationHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageApplicationHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_stra__StorageApplicationHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_stra__StorageApplicationHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_stra__PT_USCORESTATUS); + if (soap_out_stra__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_stra__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_stra__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_stra__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_stra__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__InterfaceHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__InterfaceHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_net__InterfaceHandleType); + if (soap_out_net__InterfaceHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__InterfaceHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_net__InterfaceHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_net__InterfaceHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__InterfaceHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_net__InterfaceHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_net__InterfaceHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__IPv4AddressType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__IPv4AddressType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_net__IPv4AddressType); + if (soap_out_net__IPv4AddressType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__IPv4AddressType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_net__IPv4AddressType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_net__IPv4AddressType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__IPv4AddressType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_net__IPv4AddressType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_net__IPv4AddressType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_net__PT_USCORESTATUS); + if (soap_out_net__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_net__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_net__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_net__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_net__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__CertificateHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__CertificateHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__CertificateHandleType); + if (soap_out_sai__CertificateHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CertificateHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_sai__CertificateHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_sai__CertificateHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__CertificateHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_sai__CertificateHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_sai__CertificateHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__IPv4AddressType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__IPv4AddressType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__IPv4AddressType); + if (soap_out_sai__IPv4AddressType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__IPv4AddressType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_sai__IPv4AddressType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_sai__IPv4AddressType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__IPv4AddressType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_sai__IPv4AddressType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_sai__IPv4AddressType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__UserAclEntryHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__UserAclEntryHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__UserAclEntryHandleType); + if (soap_out_sai__UserAclEntryHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclEntryHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_sai__UserAclEntryHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_sai__UserAclEntryHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__UserAclEntryHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_sai__UserAclEntryHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_sai__UserAclEntryHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__PT_USCORESTATUS); + if (soap_out_sai__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_sai__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_sai__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_sai__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_sai__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cstr__KeyPairHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cstr__KeyPairHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cstr__KeyPairHandleType); + if (soap_out_cstr__KeyPairHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cstr__KeyPairHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_cstr__KeyPairHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cstr__KeyPairHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_cstr__KeyPairHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cstr__KeyPairHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_cstr__KeyPairHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__InterfaceHandleType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__InterfaceHandleType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cmn__InterfaceHandleType); + if (soap_out_cmn__InterfaceHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__InterfaceHandleType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_cmn__InterfaceHandleType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cmn__InterfaceHandleType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_cmn__InterfaceHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cmn__InterfaceHandleType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_cmn__InterfaceHandleType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__IPv4AddressType(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__IPv4AddressType(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cmn__IPv4AddressType); + if (soap_out_cmn__IPv4AddressType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__IPv4AddressType(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_cmn__IPv4AddressType); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cmn__IPv4AddressType(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_cmn__IPv4AddressType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cmn__IPv4AddressType(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_cmn__IPv4AddressType); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__PT_USCORESTATUS(struct soap *soap, unsigned int *a) +{ soap_default_unsignedInt(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__PT_USCORESTATUS(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cmn__PT_USCORESTATUS); + if (soap_out_cmn__PT_USCORESTATUS(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__PT_USCORESTATUS(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_cmn__PT_USCORESTATUS); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_cmn__PT_USCORESTATUS(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_cmn__PT_USCORESTATUS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_cmn__PT_USCORESTATUS(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_cmn__PT_USCORESTATUS); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedInt(struct soap *soap, unsigned int *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_unsignedInt + *a = SOAP_DEFAULT_unsignedInt; +#else + *a = (unsigned int)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedInt(struct soap *soap, const unsigned int *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_unsignedInt); + if (soap_out_unsignedInt(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedInt(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type) +{ + return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_unsignedInt); +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_unsignedInt(struct soap *soap, unsigned int *p, const char *tag, const char *type) +{ + if ((p = soap_in_unsignedInt(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_unsignedInt(struct soap *soap, const char *tag, unsigned int *a, const char *type) +{ + return soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_unsignedInt); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_bool(struct soap *soap, bool *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_bool + *a = SOAP_DEFAULT_bool; +#else + *a = (bool)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_bool(struct soap *soap, const bool *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_bool); + if (soap_out_bool(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_bool[] = +{ { (long)false, "false" }, + { (long)true, "true" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_bool2s(struct soap *soap, bool n) +{ const char *s = soap_code_str(soap_codes_bool, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_bool(struct soap *soap, const char *tag, int id, const bool *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_bool), type); + soap_send(soap, soap_bool2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 bool * SOAP_FMAC4 soap_get_bool(struct soap *soap, bool *p, const char *tag, const char *type) +{ + if ((p = soap_in_bool(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2bool(struct soap *soap, const char *s, bool *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_bool, s); + if (map) + *a = (bool)(map->code != 0); + else + { long n; + if (soap_s2long(soap, s, &n) || n < 0 || n > 1) + return soap->error = SOAP_TYPE; + *a = (bool)(n != 0); + } + return SOAP_OK; +} + +SOAP_FMAC3 bool * SOAP_FMAC4 soap_in_bool(struct soap *soap, const char *tag, bool *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":boolean")) + { soap->error = SOAP_TYPE; + return NULL; + } + a = (bool *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_bool, sizeof(bool), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2bool(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (bool *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_bool, 0, sizeof(bool), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__FeatureType(struct soap *soap, enum wcxs__FeatureType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_wcxs__FeatureType + *a = SOAP_DEFAULT_wcxs__FeatureType; +#else + *a = (enum wcxs__FeatureType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__FeatureType(struct soap *soap, const enum wcxs__FeatureType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_wcxs__FeatureType); + if (soap_out_wcxs__FeatureType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_wcxs__FeatureType[] = +{ { (long)wcxs__FeatureType__802_x002e11a, "802.11a" }, + { (long)wcxs__FeatureType__802_x002e11b, "802.11b" }, + { (long)wcxs__FeatureType__802_x002e11g, "802.11g" }, + { (long)wcxs__FeatureType__802_x002e11n, "802.11n" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_wcxs__FeatureType2s(struct soap *soap, enum wcxs__FeatureType n) +{ const char *s = soap_code_str(soap_codes_wcxs__FeatureType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__FeatureType(struct soap *soap, const char *tag, int id, const enum wcxs__FeatureType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__FeatureType), type); + soap_send(soap, soap_wcxs__FeatureType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum wcxs__FeatureType * SOAP_FMAC4 soap_get_wcxs__FeatureType(struct soap *soap, enum wcxs__FeatureType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__FeatureType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2wcxs__FeatureType(struct soap *soap, const char *s, enum wcxs__FeatureType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_wcxs__FeatureType, s); + if (map) + *a = (enum wcxs__FeatureType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 3))) + return soap->error = SOAP_TYPE; + *a = (enum wcxs__FeatureType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum wcxs__FeatureType * SOAP_FMAC4 soap_in_wcxs__FeatureType(struct soap *soap, const char *tag, enum wcxs__FeatureType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum wcxs__FeatureType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__FeatureType, sizeof(enum wcxs__FeatureType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2wcxs__FeatureType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum wcxs__FeatureType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__FeatureType, 0, sizeof(enum wcxs__FeatureType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__KeyIndexType(struct soap *soap, enum wcxs__KeyIndexType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_wcxs__KeyIndexType + *a = SOAP_DEFAULT_wcxs__KeyIndexType; +#else + *a = (enum wcxs__KeyIndexType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__KeyIndexType(struct soap *soap, const enum wcxs__KeyIndexType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_wcxs__KeyIndexType); + if (soap_out_wcxs__KeyIndexType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_wcxs__KeyIndexType[] = +{ { (long)wcxs__KeyIndexType__1, "1" }, + { (long)wcxs__KeyIndexType__2, "2" }, + { (long)wcxs__KeyIndexType__3, "3" }, + { (long)wcxs__KeyIndexType__4, "4" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_wcxs__KeyIndexType2s(struct soap *soap, enum wcxs__KeyIndexType n) +{ const char *s = soap_code_str(soap_codes_wcxs__KeyIndexType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__KeyIndexType(struct soap *soap, const char *tag, int id, const enum wcxs__KeyIndexType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__KeyIndexType), type); + soap_send(soap, soap_wcxs__KeyIndexType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum wcxs__KeyIndexType * SOAP_FMAC4 soap_get_wcxs__KeyIndexType(struct soap *soap, enum wcxs__KeyIndexType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__KeyIndexType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2wcxs__KeyIndexType(struct soap *soap, const char *s, enum wcxs__KeyIndexType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_wcxs__KeyIndexType, s); + if (map) + *a = (enum wcxs__KeyIndexType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 4))) + return soap->error = SOAP_TYPE; + *a = (enum wcxs__KeyIndexType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum wcxs__KeyIndexType * SOAP_FMAC4 soap_in_wcxs__KeyIndexType(struct soap *soap, const char *tag, enum wcxs__KeyIndexType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum wcxs__KeyIndexType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__KeyIndexType, sizeof(enum wcxs__KeyIndexType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2wcxs__KeyIndexType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum wcxs__KeyIndexType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__KeyIndexType, 0, sizeof(enum wcxs__KeyIndexType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__SpecialCommandType(struct soap *soap, enum rci__SpecialCommandType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_rci__SpecialCommandType + *a = SOAP_DEFAULT_rci__SpecialCommandType; +#else + *a = (enum rci__SpecialCommandType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__SpecialCommandType(struct soap *soap, const enum rci__SpecialCommandType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__SpecialCommandType); + if (soap_out_rci__SpecialCommandType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_rci__SpecialCommandType[] = +{ { (long)rci__SpecialCommandType__0, "0" }, + { (long)rci__SpecialCommandType__1, "1" }, + { (long)rci__SpecialCommandType__2, "2" }, + { (long)rci__SpecialCommandType__3, "3" }, + { (long)rci__SpecialCommandType__4, "4" }, + { (long)rci__SpecialCommandType__5, "5" }, + { (long)rci__SpecialCommandType__193, "193" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_rci__SpecialCommandType2s(struct soap *soap, enum rci__SpecialCommandType n) +{ const char *s = soap_code_str(soap_codes_rci__SpecialCommandType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__SpecialCommandType(struct soap *soap, const char *tag, int id, const enum rci__SpecialCommandType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_rci__SpecialCommandType), type); + soap_send(soap, soap_rci__SpecialCommandType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum rci__SpecialCommandType * SOAP_FMAC4 soap_get_rci__SpecialCommandType(struct soap *soap, enum rci__SpecialCommandType *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__SpecialCommandType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2rci__SpecialCommandType(struct soap *soap, const char *s, enum rci__SpecialCommandType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_rci__SpecialCommandType, s); + if (map) + *a = (enum rci__SpecialCommandType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 193))) + return soap->error = SOAP_TYPE; + *a = (enum rci__SpecialCommandType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum rci__SpecialCommandType * SOAP_FMAC4 soap_in_rci__SpecialCommandType(struct soap *soap, const char *tag, enum rci__SpecialCommandType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum rci__SpecialCommandType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_rci__SpecialCommandType, sizeof(enum rci__SpecialCommandType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2rci__SpecialCommandType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum rci__SpecialCommandType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_rci__SpecialCommandType, 0, sizeof(enum rci__SpecialCommandType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_rci__RemoteControlCommandType(struct soap *soap, enum rci__RemoteControlCommandType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_rci__RemoteControlCommandType + *a = SOAP_DEFAULT_rci__RemoteControlCommandType; +#else + *a = (enum rci__RemoteControlCommandType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_rci__RemoteControlCommandType(struct soap *soap, const enum rci__RemoteControlCommandType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_rci__RemoteControlCommandType); + if (soap_out_rci__RemoteControlCommandType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_rci__RemoteControlCommandType[] = +{ { (long)rci__RemoteControlCommandType__16, "16" }, + { (long)rci__RemoteControlCommandType__17, "17" }, + { (long)rci__RemoteControlCommandType__18, "18" }, + { (long)rci__RemoteControlCommandType__19, "19" }, + { (long)rci__RemoteControlCommandType__33, "33" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_rci__RemoteControlCommandType2s(struct soap *soap, enum rci__RemoteControlCommandType n) +{ const char *s = soap_code_str(soap_codes_rci__RemoteControlCommandType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_rci__RemoteControlCommandType(struct soap *soap, const char *tag, int id, const enum rci__RemoteControlCommandType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_rci__RemoteControlCommandType), type); + soap_send(soap, soap_rci__RemoteControlCommandType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum rci__RemoteControlCommandType * SOAP_FMAC4 soap_get_rci__RemoteControlCommandType(struct soap *soap, enum rci__RemoteControlCommandType *p, const char *tag, const char *type) +{ + if ((p = soap_in_rci__RemoteControlCommandType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2rci__RemoteControlCommandType(struct soap *soap, const char *s, enum rci__RemoteControlCommandType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_rci__RemoteControlCommandType, s); + if (map) + *a = (enum rci__RemoteControlCommandType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 33))) + return soap->error = SOAP_TYPE; + *a = (enum rci__RemoteControlCommandType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum rci__RemoteControlCommandType * SOAP_FMAC4 soap_in_rci__RemoteControlCommandType(struct soap *soap, const char *tag, enum rci__RemoteControlCommandType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum rci__RemoteControlCommandType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_rci__RemoteControlCommandType, sizeof(enum rci__RemoteControlCommandType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2rci__RemoteControlCommandType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum rci__RemoteControlCommandType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_rci__RemoteControlCommandType, 0, sizeof(enum rci__RemoteControlCommandType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__EnabledInterfacesType(struct soap *soap, enum inf__EnabledInterfacesType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_inf__EnabledInterfacesType + *a = SOAP_DEFAULT_inf__EnabledInterfacesType; +#else + *a = (enum inf__EnabledInterfacesType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__EnabledInterfacesType(struct soap *soap, const enum inf__EnabledInterfacesType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_inf__EnabledInterfacesType); + if (soap_out_inf__EnabledInterfacesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_inf__EnabledInterfacesType[] = +{ { (long)inf__EnabledInterfacesType__WebUI, "WebUI" }, + { (long)inf__EnabledInterfacesType__SerialOverLAN, "SerialOverLAN" }, + { (long)inf__EnabledInterfacesType__IdeRedirection, "IdeRedirection" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_inf__EnabledInterfacesType2s(struct soap *soap, enum inf__EnabledInterfacesType n) +{ const char *s = soap_code_str(soap_codes_inf__EnabledInterfacesType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__EnabledInterfacesType(struct soap *soap, const char *tag, int id, const enum inf__EnabledInterfacesType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_inf__EnabledInterfacesType), type); + soap_send(soap, soap_inf__EnabledInterfacesType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum inf__EnabledInterfacesType * SOAP_FMAC4 soap_get_inf__EnabledInterfacesType(struct soap *soap, enum inf__EnabledInterfacesType *p, const char *tag, const char *type) +{ + if ((p = soap_in_inf__EnabledInterfacesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2inf__EnabledInterfacesType(struct soap *soap, const char *s, enum inf__EnabledInterfacesType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_inf__EnabledInterfacesType, s); + if (map) + *a = (enum inf__EnabledInterfacesType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum inf__EnabledInterfacesType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum inf__EnabledInterfacesType * SOAP_FMAC4 soap_in_inf__EnabledInterfacesType(struct soap *soap, const char *tag, enum inf__EnabledInterfacesType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum inf__EnabledInterfacesType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_inf__EnabledInterfacesType, sizeof(enum inf__EnabledInterfacesType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2inf__EnabledInterfacesType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum inf__EnabledInterfacesType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_inf__EnabledInterfacesType, 0, sizeof(enum inf__EnabledInterfacesType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__PasswordModelType(struct soap *soap, enum inf__PasswordModelType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_inf__PasswordModelType + *a = SOAP_DEFAULT_inf__PasswordModelType; +#else + *a = (enum inf__PasswordModelType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__PasswordModelType(struct soap *soap, const enum inf__PasswordModelType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_inf__PasswordModelType); + if (soap_out_inf__PasswordModelType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_inf__PasswordModelType[] = +{ { (long)inf__PasswordModelType__PasswordModelCoupled, "PasswordModelCoupled" }, + { (long)inf__PasswordModelType__PasswordModelSeperate, "PasswordModelSeperate" }, + { (long)inf__PasswordModelType__PasswordModelSeperateHash, "PasswordModelSeperateHash" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_inf__PasswordModelType2s(struct soap *soap, enum inf__PasswordModelType n) +{ const char *s = soap_code_str(soap_codes_inf__PasswordModelType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__PasswordModelType(struct soap *soap, const char *tag, int id, const enum inf__PasswordModelType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_inf__PasswordModelType), type); + soap_send(soap, soap_inf__PasswordModelType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum inf__PasswordModelType * SOAP_FMAC4 soap_get_inf__PasswordModelType(struct soap *soap, enum inf__PasswordModelType *p, const char *tag, const char *type) +{ + if ((p = soap_in_inf__PasswordModelType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2inf__PasswordModelType(struct soap *soap, const char *s, enum inf__PasswordModelType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_inf__PasswordModelType, s); + if (map) + *a = (enum inf__PasswordModelType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum inf__PasswordModelType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum inf__PasswordModelType * SOAP_FMAC4 soap_in_inf__PasswordModelType(struct soap *soap, const char *tag, enum inf__PasswordModelType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum inf__PasswordModelType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_inf__PasswordModelType, sizeof(enum inf__PasswordModelType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2inf__PasswordModelType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum inf__PasswordModelType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_inf__PasswordModelType, 0, sizeof(enum inf__PasswordModelType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__ProvisioningStateType(struct soap *soap, enum inf__ProvisioningStateType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_inf__ProvisioningStateType + *a = SOAP_DEFAULT_inf__ProvisioningStateType; +#else + *a = (enum inf__ProvisioningStateType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__ProvisioningStateType(struct soap *soap, const enum inf__ProvisioningStateType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_inf__ProvisioningStateType); + if (soap_out_inf__ProvisioningStateType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_inf__ProvisioningStateType[] = +{ { (long)inf__ProvisioningStateType__ProvisioningStatePre, "ProvisioningStatePre" }, + { (long)inf__ProvisioningStateType__ProvisioningStateIn, "ProvisioningStateIn" }, + { (long)inf__ProvisioningStateType__ProvisioningStatePost, "ProvisioningStatePost" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_inf__ProvisioningStateType2s(struct soap *soap, enum inf__ProvisioningStateType n) +{ const char *s = soap_code_str(soap_codes_inf__ProvisioningStateType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__ProvisioningStateType(struct soap *soap, const char *tag, int id, const enum inf__ProvisioningStateType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_inf__ProvisioningStateType), type); + soap_send(soap, soap_inf__ProvisioningStateType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum inf__ProvisioningStateType * SOAP_FMAC4 soap_get_inf__ProvisioningStateType(struct soap *soap, enum inf__ProvisioningStateType *p, const char *tag, const char *type) +{ + if ((p = soap_in_inf__ProvisioningStateType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2inf__ProvisioningStateType(struct soap *soap, const char *s, enum inf__ProvisioningStateType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_inf__ProvisioningStateType, s); + if (map) + *a = (enum inf__ProvisioningStateType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum inf__ProvisioningStateType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum inf__ProvisioningStateType * SOAP_FMAC4 soap_in_inf__ProvisioningStateType(struct soap *soap, const char *tag, enum inf__ProvisioningStateType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum inf__ProvisioningStateType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_inf__ProvisioningStateType, sizeof(enum inf__ProvisioningStateType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2inf__ProvisioningStateType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum inf__ProvisioningStateType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_inf__ProvisioningStateType, 0, sizeof(enum inf__ProvisioningStateType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_inf__ProvisioningModeType(struct soap *soap, enum inf__ProvisioningModeType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_inf__ProvisioningModeType + *a = SOAP_DEFAULT_inf__ProvisioningModeType; +#else + *a = (enum inf__ProvisioningModeType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_inf__ProvisioningModeType(struct soap *soap, const enum inf__ProvisioningModeType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_inf__ProvisioningModeType); + if (soap_out_inf__ProvisioningModeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_inf__ProvisioningModeType[] = +{ { (long)inf__ProvisioningModeType__0, "0" }, + { (long)inf__ProvisioningModeType__1, "1" }, + { (long)inf__ProvisioningModeType__2, "2" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_inf__ProvisioningModeType2s(struct soap *soap, enum inf__ProvisioningModeType n) +{ const char *s = soap_code_str(soap_codes_inf__ProvisioningModeType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__ProvisioningModeType(struct soap *soap, const char *tag, int id, const enum inf__ProvisioningModeType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_inf__ProvisioningModeType), type); + soap_send(soap, soap_inf__ProvisioningModeType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum inf__ProvisioningModeType * SOAP_FMAC4 soap_get_inf__ProvisioningModeType(struct soap *soap, enum inf__ProvisioningModeType *p, const char *tag, const char *type) +{ + if ((p = soap_in_inf__ProvisioningModeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2inf__ProvisioningModeType(struct soap *soap, const char *s, enum inf__ProvisioningModeType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_inf__ProvisioningModeType, s); + if (map) + *a = (enum inf__ProvisioningModeType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum inf__ProvisioningModeType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum inf__ProvisioningModeType * SOAP_FMAC4 soap_in_inf__ProvisioningModeType(struct soap *soap, const char *tag, enum inf__ProvisioningModeType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum inf__ProvisioningModeType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_inf__ProvisioningModeType, sizeof(enum inf__ProvisioningModeType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2inf__ProvisioningModeType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum inf__ProvisioningModeType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_inf__ProvisioningModeType, 0, sizeof(enum inf__ProvisioningModeType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_apr__CbActionType(struct soap *soap, enum apr__CbActionType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_apr__CbActionType + *a = SOAP_DEFAULT_apr__CbActionType; +#else + *a = (enum apr__CbActionType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_apr__CbActionType(struct soap *soap, const enum apr__CbActionType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_apr__CbActionType); + if (soap_out_apr__CbActionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_apr__CbActionType[] = +{ { (long)apr__CbActionType__0, "0" }, + { (long)apr__CbActionType__1, "1" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_apr__CbActionType2s(struct soap *soap, enum apr__CbActionType n) +{ const char *s = soap_code_str(soap_codes_apr__CbActionType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__CbActionType(struct soap *soap, const char *tag, int id, const enum apr__CbActionType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_apr__CbActionType), type); + soap_send(soap, soap_apr__CbActionType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum apr__CbActionType * SOAP_FMAC4 soap_get_apr__CbActionType(struct soap *soap, enum apr__CbActionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_apr__CbActionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2apr__CbActionType(struct soap *soap, const char *s, enum apr__CbActionType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_apr__CbActionType, s); + if (map) + *a = (enum apr__CbActionType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1))) + return soap->error = SOAP_TYPE; + *a = (enum apr__CbActionType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum apr__CbActionType * SOAP_FMAC4 soap_in_apr__CbActionType(struct soap *soap, const char *tag, enum apr__CbActionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum apr__CbActionType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_apr__CbActionType, sizeof(enum apr__CbActionType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2apr__CbActionType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum apr__CbActionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_apr__CbActionType, 0, sizeof(enum apr__CbActionType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_hwa__AssetTypeType(struct soap *soap, enum hwa__AssetTypeType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_hwa__AssetTypeType + *a = SOAP_DEFAULT_hwa__AssetTypeType; +#else + *a = (enum hwa__AssetTypeType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_hwa__AssetTypeType(struct soap *soap, const enum hwa__AssetTypeType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_hwa__AssetTypeType); + if (soap_out_hwa__AssetTypeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_hwa__AssetTypeType[] = +{ { (long)hwa__AssetTypeType__2, "2" }, + { (long)hwa__AssetTypeType__3, "3" }, + { (long)hwa__AssetTypeType__4, "4" }, + { (long)hwa__AssetTypeType__5, "5" }, + { (long)hwa__AssetTypeType__6, "6" }, + { (long)hwa__AssetTypeType__7, "7" }, + { (long)hwa__AssetTypeType__8, "8" }, + { (long)hwa__AssetTypeType__9, "9" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_hwa__AssetTypeType2s(struct soap *soap, enum hwa__AssetTypeType n) +{ const char *s = soap_code_str(soap_codes_hwa__AssetTypeType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__AssetTypeType(struct soap *soap, const char *tag, int id, const enum hwa__AssetTypeType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__AssetTypeType), type); + soap_send(soap, soap_hwa__AssetTypeType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum hwa__AssetTypeType * SOAP_FMAC4 soap_get_hwa__AssetTypeType(struct soap *soap, enum hwa__AssetTypeType *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__AssetTypeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2hwa__AssetTypeType(struct soap *soap, const char *s, enum hwa__AssetTypeType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_hwa__AssetTypeType, s); + if (map) + *a = (enum hwa__AssetTypeType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 9))) + return soap->error = SOAP_TYPE; + *a = (enum hwa__AssetTypeType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum hwa__AssetTypeType * SOAP_FMAC4 soap_in_hwa__AssetTypeType(struct soap *soap, const char *tag, enum hwa__AssetTypeType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum hwa__AssetTypeType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__AssetTypeType, sizeof(enum hwa__AssetTypeType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2hwa__AssetTypeType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum hwa__AssetTypeType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__AssetTypeType, 0, sizeof(enum hwa__AssetTypeType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__HcbTriggerReasonType(struct soap *soap, enum cb__HcbTriggerReasonType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_cb__HcbTriggerReasonType + *a = SOAP_DEFAULT_cb__HcbTriggerReasonType; +#else + *a = (enum cb__HcbTriggerReasonType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__HcbTriggerReasonType(struct soap *soap, const enum cb__HcbTriggerReasonType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__HcbTriggerReasonType); + if (soap_out_cb__HcbTriggerReasonType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_cb__HcbTriggerReasonType[] = +{ { (long)cb__HcbTriggerReasonType__0, "0" }, + { (long)cb__HcbTriggerReasonType__1, "1" }, + { (long)cb__HcbTriggerReasonType__2, "2" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__HcbTriggerReasonType2s(struct soap *soap, enum cb__HcbTriggerReasonType n) +{ const char *s = soap_code_str(soap_codes_cb__HcbTriggerReasonType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__HcbTriggerReasonType(struct soap *soap, const char *tag, int id, const enum cb__HcbTriggerReasonType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__HcbTriggerReasonType), type); + soap_send(soap, soap_cb__HcbTriggerReasonType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum cb__HcbTriggerReasonType * SOAP_FMAC4 soap_get_cb__HcbTriggerReasonType(struct soap *soap, enum cb__HcbTriggerReasonType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__HcbTriggerReasonType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__HcbTriggerReasonType(struct soap *soap, const char *s, enum cb__HcbTriggerReasonType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_cb__HcbTriggerReasonType, s); + if (map) + *a = (enum cb__HcbTriggerReasonType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum cb__HcbTriggerReasonType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum cb__HcbTriggerReasonType * SOAP_FMAC4 soap_in_cb__HcbTriggerReasonType(struct soap *soap, const char *tag, enum cb__HcbTriggerReasonType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum cb__HcbTriggerReasonType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_cb__HcbTriggerReasonType, sizeof(enum cb__HcbTriggerReasonType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2cb__HcbTriggerReasonType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum cb__HcbTriggerReasonType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__HcbTriggerReasonType, 0, sizeof(enum cb__HcbTriggerReasonType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__HcbStateType(struct soap *soap, enum cb__HcbStateType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_cb__HcbStateType + *a = SOAP_DEFAULT_cb__HcbStateType; +#else + *a = (enum cb__HcbStateType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__HcbStateType(struct soap *soap, const enum cb__HcbStateType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__HcbStateType); + if (soap_out_cb__HcbStateType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_cb__HcbStateType[] = +{ { (long)cb__HcbStateType__0, "0" }, + { (long)cb__HcbStateType__1, "1" }, + { (long)cb__HcbStateType__2, "2" }, + { (long)cb__HcbStateType__3, "3" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__HcbStateType2s(struct soap *soap, enum cb__HcbStateType n) +{ const char *s = soap_code_str(soap_codes_cb__HcbStateType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__HcbStateType(struct soap *soap, const char *tag, int id, const enum cb__HcbStateType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__HcbStateType), type); + soap_send(soap, soap_cb__HcbStateType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum cb__HcbStateType * SOAP_FMAC4 soap_get_cb__HcbStateType(struct soap *soap, enum cb__HcbStateType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__HcbStateType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__HcbStateType(struct soap *soap, const char *s, enum cb__HcbStateType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_cb__HcbStateType, s); + if (map) + *a = (enum cb__HcbStateType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 3))) + return soap->error = SOAP_TYPE; + *a = (enum cb__HcbStateType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum cb__HcbStateType * SOAP_FMAC4 soap_in_cb__HcbStateType(struct soap *soap, const char *tag, enum cb__HcbStateType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum cb__HcbStateType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_cb__HcbStateType, sizeof(enum cb__HcbStateType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2cb__HcbStateType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum cb__HcbStateType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__HcbStateType, 0, sizeof(enum cb__HcbStateType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__CircuitBreakerApplicationType(struct soap *soap, enum cb__CircuitBreakerApplicationType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_cb__CircuitBreakerApplicationType + *a = SOAP_DEFAULT_cb__CircuitBreakerApplicationType; +#else + *a = (enum cb__CircuitBreakerApplicationType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__CircuitBreakerApplicationType(struct soap *soap, const enum cb__CircuitBreakerApplicationType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerApplicationType); + if (soap_out_cb__CircuitBreakerApplicationType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_cb__CircuitBreakerApplicationType[] = +{ { (long)cb__CircuitBreakerApplicationType__0, "0" }, + { (long)cb__CircuitBreakerApplicationType__1, "1" }, + { (long)cb__CircuitBreakerApplicationType__3, "3" }, + { (long)cb__CircuitBreakerApplicationType__4, "4" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__CircuitBreakerApplicationType2s(struct soap *soap, enum cb__CircuitBreakerApplicationType n) +{ const char *s = soap_code_str(soap_codes_cb__CircuitBreakerApplicationType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerApplicationType(struct soap *soap, const char *tag, int id, const enum cb__CircuitBreakerApplicationType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerApplicationType), type); + soap_send(soap, soap_cb__CircuitBreakerApplicationType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum cb__CircuitBreakerApplicationType * SOAP_FMAC4 soap_get_cb__CircuitBreakerApplicationType(struct soap *soap, enum cb__CircuitBreakerApplicationType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerApplicationType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__CircuitBreakerApplicationType(struct soap *soap, const char *s, enum cb__CircuitBreakerApplicationType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_cb__CircuitBreakerApplicationType, s); + if (map) + *a = (enum cb__CircuitBreakerApplicationType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 4))) + return soap->error = SOAP_TYPE; + *a = (enum cb__CircuitBreakerApplicationType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum cb__CircuitBreakerApplicationType * SOAP_FMAC4 soap_in_cb__CircuitBreakerApplicationType(struct soap *soap, const char *tag, enum cb__CircuitBreakerApplicationType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum cb__CircuitBreakerApplicationType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerApplicationType, sizeof(enum cb__CircuitBreakerApplicationType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2cb__CircuitBreakerApplicationType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum cb__CircuitBreakerApplicationType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerApplicationType, 0, sizeof(enum cb__CircuitBreakerApplicationType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__CircuitBreakerProfileType(struct soap *soap, enum cb__CircuitBreakerProfileType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_cb__CircuitBreakerProfileType + *a = SOAP_DEFAULT_cb__CircuitBreakerProfileType; +#else + *a = (enum cb__CircuitBreakerProfileType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__CircuitBreakerProfileType(struct soap *soap, const enum cb__CircuitBreakerProfileType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerProfileType); + if (soap_out_cb__CircuitBreakerProfileType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_cb__CircuitBreakerProfileType[] = +{ { (long)cb__CircuitBreakerProfileType__0, "0" }, + { (long)cb__CircuitBreakerProfileType__1, "1" }, + { (long)cb__CircuitBreakerProfileType__2, "2" }, + { (long)cb__CircuitBreakerProfileType__3, "3" }, + { (long)cb__CircuitBreakerProfileType__4, "4" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__CircuitBreakerProfileType2s(struct soap *soap, enum cb__CircuitBreakerProfileType n) +{ const char *s = soap_code_str(soap_codes_cb__CircuitBreakerProfileType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerProfileType(struct soap *soap, const char *tag, int id, const enum cb__CircuitBreakerProfileType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerProfileType), type); + soap_send(soap, soap_cb__CircuitBreakerProfileType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum cb__CircuitBreakerProfileType * SOAP_FMAC4 soap_get_cb__CircuitBreakerProfileType(struct soap *soap, enum cb__CircuitBreakerProfileType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerProfileType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__CircuitBreakerProfileType(struct soap *soap, const char *s, enum cb__CircuitBreakerProfileType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_cb__CircuitBreakerProfileType, s); + if (map) + *a = (enum cb__CircuitBreakerProfileType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 4))) + return soap->error = SOAP_TYPE; + *a = (enum cb__CircuitBreakerProfileType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum cb__CircuitBreakerProfileType * SOAP_FMAC4 soap_in_cb__CircuitBreakerProfileType(struct soap *soap, const char *tag, enum cb__CircuitBreakerProfileType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum cb__CircuitBreakerProfileType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerProfileType, sizeof(enum cb__CircuitBreakerProfileType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2cb__CircuitBreakerProfileType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum cb__CircuitBreakerProfileType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerProfileType, 0, sizeof(enum cb__CircuitBreakerProfileType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap *soap, enum cb__CircuitBreakerFilterIPAddressDirectionType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_cb__CircuitBreakerFilterIPAddressDirectionType + *a = SOAP_DEFAULT_cb__CircuitBreakerFilterIPAddressDirectionType; +#else + *a = (enum cb__CircuitBreakerFilterIPAddressDirectionType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap *soap, const enum cb__CircuitBreakerFilterIPAddressDirectionType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType); + if (soap_out_cb__CircuitBreakerFilterIPAddressDirectionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_cb__CircuitBreakerFilterIPAddressDirectionType[] = +{ { (long)cb__CircuitBreakerFilterIPAddressDirectionType__0, "0" }, + { (long)cb__CircuitBreakerFilterIPAddressDirectionType__1, "1" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__CircuitBreakerFilterIPAddressDirectionType2s(struct soap *soap, enum cb__CircuitBreakerFilterIPAddressDirectionType n) +{ const char *s = soap_code_str(soap_codes_cb__CircuitBreakerFilterIPAddressDirectionType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap *soap, const char *tag, int id, const enum cb__CircuitBreakerFilterIPAddressDirectionType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType), type); + soap_send(soap, soap_cb__CircuitBreakerFilterIPAddressDirectionType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum cb__CircuitBreakerFilterIPAddressDirectionType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap *soap, enum cb__CircuitBreakerFilterIPAddressDirectionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerFilterIPAddressDirectionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__CircuitBreakerFilterIPAddressDirectionType(struct soap *soap, const char *s, enum cb__CircuitBreakerFilterIPAddressDirectionType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_cb__CircuitBreakerFilterIPAddressDirectionType, s); + if (map) + *a = (enum cb__CircuitBreakerFilterIPAddressDirectionType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1))) + return soap->error = SOAP_TYPE; + *a = (enum cb__CircuitBreakerFilterIPAddressDirectionType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum cb__CircuitBreakerFilterIPAddressDirectionType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterIPAddressDirectionType(struct soap *soap, const char *tag, enum cb__CircuitBreakerFilterIPAddressDirectionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum cb__CircuitBreakerFilterIPAddressDirectionType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType, sizeof(enum cb__CircuitBreakerFilterIPAddressDirectionType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2cb__CircuitBreakerFilterIPAddressDirectionType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum cb__CircuitBreakerFilterIPAddressDirectionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerFilterIPAddressDirectionType, 0, sizeof(enum cb__CircuitBreakerFilterIPAddressDirectionType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__CircuitBreakerFilterDirectionType(struct soap *soap, enum cb__CircuitBreakerFilterDirectionType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_cb__CircuitBreakerFilterDirectionType + *a = SOAP_DEFAULT_cb__CircuitBreakerFilterDirectionType; +#else + *a = (enum cb__CircuitBreakerFilterDirectionType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__CircuitBreakerFilterDirectionType(struct soap *soap, const enum cb__CircuitBreakerFilterDirectionType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerFilterDirectionType); + if (soap_out_cb__CircuitBreakerFilterDirectionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_cb__CircuitBreakerFilterDirectionType[] = +{ { (long)cb__CircuitBreakerFilterDirectionType__0, "0" }, + { (long)cb__CircuitBreakerFilterDirectionType__1, "1" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_cb__CircuitBreakerFilterDirectionType2s(struct soap *soap, enum cb__CircuitBreakerFilterDirectionType n) +{ const char *s = soap_code_str(soap_codes_cb__CircuitBreakerFilterDirectionType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterDirectionType(struct soap *soap, const char *tag, int id, const enum cb__CircuitBreakerFilterDirectionType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerFilterDirectionType), type); + soap_send(soap, soap_cb__CircuitBreakerFilterDirectionType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum cb__CircuitBreakerFilterDirectionType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterDirectionType(struct soap *soap, enum cb__CircuitBreakerFilterDirectionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerFilterDirectionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2cb__CircuitBreakerFilterDirectionType(struct soap *soap, const char *s, enum cb__CircuitBreakerFilterDirectionType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_cb__CircuitBreakerFilterDirectionType, s); + if (map) + *a = (enum cb__CircuitBreakerFilterDirectionType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1))) + return soap->error = SOAP_TYPE; + *a = (enum cb__CircuitBreakerFilterDirectionType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum cb__CircuitBreakerFilterDirectionType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterDirectionType(struct soap *soap, const char *tag, enum cb__CircuitBreakerFilterDirectionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum cb__CircuitBreakerFilterDirectionType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerFilterDirectionType, sizeof(enum cb__CircuitBreakerFilterDirectionType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2cb__CircuitBreakerFilterDirectionType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum cb__CircuitBreakerFilterDirectionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerFilterDirectionType, 0, sizeof(enum cb__CircuitBreakerFilterDirectionType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__AlertAuthOptionsType(struct soap *soap, enum emi__AlertAuthOptionsType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_emi__AlertAuthOptionsType + *a = SOAP_DEFAULT_emi__AlertAuthOptionsType; +#else + *a = (enum emi__AlertAuthOptionsType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__AlertAuthOptionsType(struct soap *soap, const enum emi__AlertAuthOptionsType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__AlertAuthOptionsType); + if (soap_out_emi__AlertAuthOptionsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_emi__AlertAuthOptionsType[] = +{ { (long)emi__AlertAuthOptionsType__Kerberos, "Kerberos" }, + { (long)emi__AlertAuthOptionsType__Digest, "Digest" }, + { (long)emi__AlertAuthOptionsType__Basic, "Basic" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_emi__AlertAuthOptionsType2s(struct soap *soap, enum emi__AlertAuthOptionsType n) +{ const char *s = soap_code_str(soap_codes_emi__AlertAuthOptionsType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertAuthOptionsType(struct soap *soap, const char *tag, int id, const enum emi__AlertAuthOptionsType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__AlertAuthOptionsType), type); + soap_send(soap, soap_emi__AlertAuthOptionsType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum emi__AlertAuthOptionsType * SOAP_FMAC4 soap_get_emi__AlertAuthOptionsType(struct soap *soap, enum emi__AlertAuthOptionsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertAuthOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2emi__AlertAuthOptionsType(struct soap *soap, const char *s, enum emi__AlertAuthOptionsType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_emi__AlertAuthOptionsType, s); + if (map) + *a = (enum emi__AlertAuthOptionsType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum emi__AlertAuthOptionsType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum emi__AlertAuthOptionsType * SOAP_FMAC4 soap_in_emi__AlertAuthOptionsType(struct soap *soap, const char *tag, enum emi__AlertAuthOptionsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum emi__AlertAuthOptionsType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_emi__AlertAuthOptionsType, sizeof(enum emi__AlertAuthOptionsType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2emi__AlertAuthOptionsType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum emi__AlertAuthOptionsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__AlertAuthOptionsType, 0, sizeof(enum emi__AlertAuthOptionsType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__EventSeverityType(struct soap *soap, enum emi__EventSeverityType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_emi__EventSeverityType + *a = SOAP_DEFAULT_emi__EventSeverityType; +#else + *a = (enum emi__EventSeverityType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__EventSeverityType(struct soap *soap, const enum emi__EventSeverityType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__EventSeverityType); + if (soap_out_emi__EventSeverityType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_emi__EventSeverityType[] = +{ { (long)emi__EventSeverityType__0, "0" }, + { (long)emi__EventSeverityType__1, "1" }, + { (long)emi__EventSeverityType__2, "2" }, + { (long)emi__EventSeverityType__4, "4" }, + { (long)emi__EventSeverityType__8, "8" }, + { (long)emi__EventSeverityType__16, "16" }, + { (long)emi__EventSeverityType__32, "32" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_emi__EventSeverityType2s(struct soap *soap, enum emi__EventSeverityType n) +{ const char *s = soap_code_str(soap_codes_emi__EventSeverityType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventSeverityType(struct soap *soap, const char *tag, int id, const enum emi__EventSeverityType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__EventSeverityType), type); + soap_send(soap, soap_emi__EventSeverityType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum emi__EventSeverityType * SOAP_FMAC4 soap_get_emi__EventSeverityType(struct soap *soap, enum emi__EventSeverityType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__EventSeverityType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2emi__EventSeverityType(struct soap *soap, const char *s, enum emi__EventSeverityType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_emi__EventSeverityType, s); + if (map) + *a = (enum emi__EventSeverityType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 32))) + return soap->error = SOAP_TYPE; + *a = (enum emi__EventSeverityType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum emi__EventSeverityType * SOAP_FMAC4 soap_in_emi__EventSeverityType(struct soap *soap, const char *tag, enum emi__EventSeverityType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum emi__EventSeverityType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_emi__EventSeverityType, sizeof(enum emi__EventSeverityType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2emi__EventSeverityType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum emi__EventSeverityType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__EventSeverityType, 0, sizeof(enum emi__EventSeverityType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap *soap, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE + *a = SOAP_DEFAULT_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE; +#else + *a = (enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap *soap, const enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE); + if (soap_out_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE[] = +{ { (long)stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE__0, "0" }, + { (long)stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE__1, "1" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE2s(struct soap *soap, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE n) +{ const char *s = soap_code_str(soap_codes_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap *soap, const char *tag, int id, const enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE), type); + soap_send(soap, soap_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE * SOAP_FMAC4 soap_get_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap *soap, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap *soap, const char *s, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE, s); + if (map) + *a = (enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1))) + return soap->error = SOAP_TYPE; + *a = (enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE * SOAP_FMAC4 soap_in_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(struct soap *soap, const char *tag, enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE, sizeof(enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE, 0, sizeof(enum stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__InterfaceModeType(struct soap *soap, enum net__InterfaceModeType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_net__InterfaceModeType + *a = SOAP_DEFAULT_net__InterfaceModeType; +#else + *a = (enum net__InterfaceModeType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__InterfaceModeType(struct soap *soap, const enum net__InterfaceModeType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_net__InterfaceModeType); + if (soap_out_net__InterfaceModeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_net__InterfaceModeType[] = +{ { (long)net__InterfaceModeType__SEPARATE_USCOREMAC_USCOREADDRESS, "SEPARATE_MAC_ADDRESS" }, + { (long)net__InterfaceModeType__SHARED_USCOREMAC_USCOREADDRESS, "SHARED_MAC_ADDRESS" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_net__InterfaceModeType2s(struct soap *soap, enum net__InterfaceModeType n) +{ const char *s = soap_code_str(soap_codes_net__InterfaceModeType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__InterfaceModeType(struct soap *soap, const char *tag, int id, const enum net__InterfaceModeType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_net__InterfaceModeType), type); + soap_send(soap, soap_net__InterfaceModeType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum net__InterfaceModeType * SOAP_FMAC4 soap_get_net__InterfaceModeType(struct soap *soap, enum net__InterfaceModeType *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__InterfaceModeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2net__InterfaceModeType(struct soap *soap, const char *s, enum net__InterfaceModeType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_net__InterfaceModeType, s); + if (map) + *a = (enum net__InterfaceModeType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1))) + return soap->error = SOAP_TYPE; + *a = (enum net__InterfaceModeType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum net__InterfaceModeType * SOAP_FMAC4 soap_in_net__InterfaceModeType(struct soap *soap, const char *tag, enum net__InterfaceModeType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum net__InterfaceModeType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_net__InterfaceModeType, sizeof(enum net__InterfaceModeType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2net__InterfaceModeType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum net__InterfaceModeType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_net__InterfaceModeType, 0, sizeof(enum net__InterfaceModeType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__DhcpModeType(struct soap *soap, enum net__DhcpModeType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_net__DhcpModeType + *a = SOAP_DEFAULT_net__DhcpModeType; +#else + *a = (enum net__DhcpModeType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__DhcpModeType(struct soap *soap, const enum net__DhcpModeType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_net__DhcpModeType); + if (soap_out_net__DhcpModeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_net__DhcpModeType[] = +{ { (long)net__DhcpModeType__0, "0" }, + { (long)net__DhcpModeType__1, "1" }, + { (long)net__DhcpModeType__2, "2" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_net__DhcpModeType2s(struct soap *soap, enum net__DhcpModeType n) +{ const char *s = soap_code_str(soap_codes_net__DhcpModeType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__DhcpModeType(struct soap *soap, const char *tag, int id, const enum net__DhcpModeType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_net__DhcpModeType), type); + soap_send(soap, soap_net__DhcpModeType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum net__DhcpModeType * SOAP_FMAC4 soap_get_net__DhcpModeType(struct soap *soap, enum net__DhcpModeType *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__DhcpModeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2net__DhcpModeType(struct soap *soap, const char *s, enum net__DhcpModeType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_net__DhcpModeType, s); + if (map) + *a = (enum net__DhcpModeType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum net__DhcpModeType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum net__DhcpModeType * SOAP_FMAC4 soap_in_net__DhcpModeType(struct soap *soap, const char *tag, enum net__DhcpModeType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum net__DhcpModeType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_net__DhcpModeType, sizeof(enum net__DhcpModeType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2net__DhcpModeType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum net__DhcpModeType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_net__DhcpModeType, 0, sizeof(enum net__DhcpModeType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_xcfg__CertNameOptionsType(struct soap *soap, enum xcfg__CertNameOptionsType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_xcfg__CertNameOptionsType + *a = SOAP_DEFAULT_xcfg__CertNameOptionsType; +#else + *a = (enum xcfg__CertNameOptionsType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_xcfg__CertNameOptionsType(struct soap *soap, const enum xcfg__CertNameOptionsType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_xcfg__CertNameOptionsType); + if (soap_out_xcfg__CertNameOptionsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_xcfg__CertNameOptionsType[] = +{ { (long)xcfg__CertNameOptionsType__CertNameMatch, "CertNameMatch" }, + { (long)xcfg__CertNameOptionsType__DomainSuffixMatch, "DomainSuffixMatch" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_xcfg__CertNameOptionsType2s(struct soap *soap, enum xcfg__CertNameOptionsType n) +{ const char *s = soap_code_str(soap_codes_xcfg__CertNameOptionsType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__CertNameOptionsType(struct soap *soap, const char *tag, int id, const enum xcfg__CertNameOptionsType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__CertNameOptionsType), type); + soap_send(soap, soap_xcfg__CertNameOptionsType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum xcfg__CertNameOptionsType * SOAP_FMAC4 soap_get_xcfg__CertNameOptionsType(struct soap *soap, enum xcfg__CertNameOptionsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__CertNameOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2xcfg__CertNameOptionsType(struct soap *soap, const char *s, enum xcfg__CertNameOptionsType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_xcfg__CertNameOptionsType, s); + if (map) + *a = (enum xcfg__CertNameOptionsType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1))) + return soap->error = SOAP_TYPE; + *a = (enum xcfg__CertNameOptionsType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum xcfg__CertNameOptionsType * SOAP_FMAC4 soap_in_xcfg__CertNameOptionsType(struct soap *soap, const char *tag, enum xcfg__CertNameOptionsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum xcfg__CertNameOptionsType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__CertNameOptionsType, sizeof(enum xcfg__CertNameOptionsType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2xcfg__CertNameOptionsType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum xcfg__CertNameOptionsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__CertNameOptionsType, 0, sizeof(enum xcfg__CertNameOptionsType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__HTTPAuthOptionType(struct soap *soap, enum sai__HTTPAuthOptionType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__HTTPAuthOptionType + *a = SOAP_DEFAULT_sai__HTTPAuthOptionType; +#else + *a = (enum sai__HTTPAuthOptionType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__HTTPAuthOptionType(struct soap *soap, const enum sai__HTTPAuthOptionType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__HTTPAuthOptionType); + if (soap_out_sai__HTTPAuthOptionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__HTTPAuthOptionType[] = +{ { (long)sai__HTTPAuthOptionType__NoAuth, "NoAuth" }, + { (long)sai__HTTPAuthOptionType__Auth, "Auth" }, + { (long)sai__HTTPAuthOptionType__Disable, "Disable" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__HTTPAuthOptionType2s(struct soap *soap, enum sai__HTTPAuthOptionType n) +{ const char *s = soap_code_str(soap_codes_sai__HTTPAuthOptionType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__HTTPAuthOptionType(struct soap *soap, const char *tag, int id, const enum sai__HTTPAuthOptionType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__HTTPAuthOptionType), type); + soap_send(soap, soap_sai__HTTPAuthOptionType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__HTTPAuthOptionType * SOAP_FMAC4 soap_get_sai__HTTPAuthOptionType(struct soap *soap, enum sai__HTTPAuthOptionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__HTTPAuthOptionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__HTTPAuthOptionType(struct soap *soap, const char *s, enum sai__HTTPAuthOptionType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__HTTPAuthOptionType, s); + if (map) + *a = (enum sai__HTTPAuthOptionType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum sai__HTTPAuthOptionType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__HTTPAuthOptionType * SOAP_FMAC4 soap_in_sai__HTTPAuthOptionType(struct soap *soap, const char *tag, enum sai__HTTPAuthOptionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__HTTPAuthOptionType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__HTTPAuthOptionType, sizeof(enum sai__HTTPAuthOptionType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__HTTPAuthOptionType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__HTTPAuthOptionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__HTTPAuthOptionType, 0, sizeof(enum sai__HTTPAuthOptionType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__HashTypeType(struct soap *soap, enum sai__HashTypeType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__HashTypeType + *a = SOAP_DEFAULT_sai__HashTypeType; +#else + *a = (enum sai__HashTypeType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__HashTypeType(struct soap *soap, const enum sai__HashTypeType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__HashTypeType); + if (soap_out_sai__HashTypeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__HashTypeType[] = +{ { (long)sai__HashTypeType__1, "1" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__HashTypeType2s(struct soap *soap, enum sai__HashTypeType n) +{ const char *s = soap_code_str(soap_codes_sai__HashTypeType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__HashTypeType(struct soap *soap, const char *tag, int id, const enum sai__HashTypeType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__HashTypeType), type); + soap_send(soap, soap_sai__HashTypeType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__HashTypeType * SOAP_FMAC4 soap_get_sai__HashTypeType(struct soap *soap, enum sai__HashTypeType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__HashTypeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__HashTypeType(struct soap *soap, const char *s, enum sai__HashTypeType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__HashTypeType, s); + if (map) + *a = (enum sai__HashTypeType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1))) + return soap->error = SOAP_TYPE; + *a = (enum sai__HashTypeType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__HashTypeType * SOAP_FMAC4 soap_in_sai__HashTypeType(struct soap *soap, const char *tag, enum sai__HashTypeType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__HashTypeType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__HashTypeType, sizeof(enum sai__HashTypeType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__HashTypeType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__HashTypeType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__HashTypeType, 0, sizeof(enum sai__HashTypeType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__ProvisioningTLSModeType(struct soap *soap, enum sai__ProvisioningTLSModeType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__ProvisioningTLSModeType + *a = SOAP_DEFAULT_sai__ProvisioningTLSModeType; +#else + *a = (enum sai__ProvisioningTLSModeType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__ProvisioningTLSModeType(struct soap *soap, const enum sai__ProvisioningTLSModeType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__ProvisioningTLSModeType); + if (soap_out_sai__ProvisioningTLSModeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__ProvisioningTLSModeType[] = +{ { (long)sai__ProvisioningTLSModeType__0, "0" }, + { (long)sai__ProvisioningTLSModeType__1, "1" }, + { (long)sai__ProvisioningTLSModeType__2, "2" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__ProvisioningTLSModeType2s(struct soap *soap, enum sai__ProvisioningTLSModeType n) +{ const char *s = soap_code_str(soap_codes_sai__ProvisioningTLSModeType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__ProvisioningTLSModeType(struct soap *soap, const char *tag, int id, const enum sai__ProvisioningTLSModeType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__ProvisioningTLSModeType), type); + soap_send(soap, soap_sai__ProvisioningTLSModeType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__ProvisioningTLSModeType * SOAP_FMAC4 soap_get_sai__ProvisioningTLSModeType(struct soap *soap, enum sai__ProvisioningTLSModeType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__ProvisioningTLSModeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__ProvisioningTLSModeType(struct soap *soap, const char *s, enum sai__ProvisioningTLSModeType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__ProvisioningTLSModeType, s); + if (map) + *a = (enum sai__ProvisioningTLSModeType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum sai__ProvisioningTLSModeType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__ProvisioningTLSModeType * SOAP_FMAC4 soap_in_sai__ProvisioningTLSModeType(struct soap *soap, const char *tag, enum sai__ProvisioningTLSModeType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__ProvisioningTLSModeType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__ProvisioningTLSModeType, sizeof(enum sai__ProvisioningTLSModeType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__ProvisioningTLSModeType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__ProvisioningTLSModeType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__ProvisioningTLSModeType, 0, sizeof(enum sai__ProvisioningTLSModeType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__TlsAthenticationType(struct soap *soap, enum sai__TlsAthenticationType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__TlsAthenticationType + *a = SOAP_DEFAULT_sai__TlsAthenticationType; +#else + *a = (enum sai__TlsAthenticationType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__TlsAthenticationType(struct soap *soap, const enum sai__TlsAthenticationType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__TlsAthenticationType); + if (soap_out_sai__TlsAthenticationType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__TlsAthenticationType[] = +{ { (long)sai__TlsAthenticationType__NoAuth, "NoAuth" }, + { (long)sai__TlsAthenticationType__ServerAuth, "ServerAuth" }, + { (long)sai__TlsAthenticationType__MutualAuth, "MutualAuth" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__TlsAthenticationType2s(struct soap *soap, enum sai__TlsAthenticationType n) +{ const char *s = soap_code_str(soap_codes_sai__TlsAthenticationType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__TlsAthenticationType(struct soap *soap, const char *tag, int id, const enum sai__TlsAthenticationType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__TlsAthenticationType), type); + soap_send(soap, soap_sai__TlsAthenticationType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__TlsAthenticationType * SOAP_FMAC4 soap_get_sai__TlsAthenticationType(struct soap *soap, enum sai__TlsAthenticationType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__TlsAthenticationType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__TlsAthenticationType(struct soap *soap, const char *s, enum sai__TlsAthenticationType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__TlsAthenticationType, s); + if (map) + *a = (enum sai__TlsAthenticationType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum sai__TlsAthenticationType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__TlsAthenticationType * SOAP_FMAC4 soap_in_sai__TlsAthenticationType(struct soap *soap, const char *tag, enum sai__TlsAthenticationType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__TlsAthenticationType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__TlsAthenticationType, sizeof(enum sai__TlsAthenticationType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__TlsAthenticationType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__TlsAthenticationType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__TlsAthenticationType, 0, sizeof(enum sai__TlsAthenticationType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__InterfaceType(struct soap *soap, enum sai__InterfaceType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__InterfaceType + *a = SOAP_DEFAULT_sai__InterfaceType; +#else + *a = (enum sai__InterfaceType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__InterfaceType(struct soap *soap, const enum sai__InterfaceType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__InterfaceType); + if (soap_out_sai__InterfaceType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__InterfaceType[] = +{ { (long)sai__InterfaceType__NetworkInterface, "NetworkInterface" }, + { (long)sai__InterfaceType__LocalHostInterface, "LocalHostInterface" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__InterfaceType2s(struct soap *soap, enum sai__InterfaceType n) +{ const char *s = soap_code_str(soap_codes_sai__InterfaceType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__InterfaceType(struct soap *soap, const char *tag, int id, const enum sai__InterfaceType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__InterfaceType), type); + soap_send(soap, soap_sai__InterfaceType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__InterfaceType * SOAP_FMAC4 soap_get_sai__InterfaceType(struct soap *soap, enum sai__InterfaceType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__InterfaceType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__InterfaceType(struct soap *soap, const char *s, enum sai__InterfaceType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__InterfaceType, s); + if (map) + *a = (enum sai__InterfaceType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1))) + return soap->error = SOAP_TYPE; + *a = (enum sai__InterfaceType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__InterfaceType * SOAP_FMAC4 soap_in_sai__InterfaceType(struct soap *soap, const char *tag, enum sai__InterfaceType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__InterfaceType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__InterfaceType, sizeof(enum sai__InterfaceType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__InterfaceType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__InterfaceType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__InterfaceType, 0, sizeof(enum sai__InterfaceType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__EnabledInterfacesType(struct soap *soap, enum sai__EnabledInterfacesType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__EnabledInterfacesType + *a = SOAP_DEFAULT_sai__EnabledInterfacesType; +#else + *a = (enum sai__EnabledInterfacesType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__EnabledInterfacesType(struct soap *soap, const enum sai__EnabledInterfacesType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__EnabledInterfacesType); + if (soap_out_sai__EnabledInterfacesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__EnabledInterfacesType[] = +{ { (long)sai__EnabledInterfacesType__WebUI, "WebUI" }, + { (long)sai__EnabledInterfacesType__SerialOverLAN, "SerialOverLAN" }, + { (long)sai__EnabledInterfacesType__IdeRedirection, "IdeRedirection" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__EnabledInterfacesType2s(struct soap *soap, enum sai__EnabledInterfacesType n) +{ const char *s = soap_code_str(soap_codes_sai__EnabledInterfacesType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__EnabledInterfacesType(struct soap *soap, const char *tag, int id, const enum sai__EnabledInterfacesType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__EnabledInterfacesType), type); + soap_send(soap, soap_sai__EnabledInterfacesType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__EnabledInterfacesType * SOAP_FMAC4 soap_get_sai__EnabledInterfacesType(struct soap *soap, enum sai__EnabledInterfacesType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__EnabledInterfacesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__EnabledInterfacesType(struct soap *soap, const char *s, enum sai__EnabledInterfacesType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__EnabledInterfacesType, s); + if (map) + *a = (enum sai__EnabledInterfacesType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum sai__EnabledInterfacesType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__EnabledInterfacesType * SOAP_FMAC4 soap_in_sai__EnabledInterfacesType(struct soap *soap, const char *tag, enum sai__EnabledInterfacesType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__EnabledInterfacesType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__EnabledInterfacesType, sizeof(enum sai__EnabledInterfacesType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__EnabledInterfacesType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__EnabledInterfacesType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__EnabledInterfacesType, 0, sizeof(enum sai__EnabledInterfacesType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__PowerStateType(struct soap *soap, enum sai__PowerStateType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__PowerStateType + *a = SOAP_DEFAULT_sai__PowerStateType; +#else + *a = (enum sai__PowerStateType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__PowerStateType(struct soap *soap, const enum sai__PowerStateType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__PowerStateType); + if (soap_out_sai__PowerStateType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__PowerStateType[] = +{ { (long)sai__PowerStateType__PowerStateS0, "PowerStateS0" }, + { (long)sai__PowerStateType__PowerStateS1, "PowerStateS1" }, + { (long)sai__PowerStateType__PowerStateS2, "PowerStateS2" }, + { (long)sai__PowerStateType__PowerStateS3, "PowerStateS3" }, + { (long)sai__PowerStateType__PowerStateS4, "PowerStateS4" }, + { (long)sai__PowerStateType__PowerStateS5, "PowerStateS5" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__PowerStateType2s(struct soap *soap, enum sai__PowerStateType n) +{ const char *s = soap_code_str(soap_codes_sai__PowerStateType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__PowerStateType(struct soap *soap, const char *tag, int id, const enum sai__PowerStateType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__PowerStateType), type); + soap_send(soap, soap_sai__PowerStateType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__PowerStateType * SOAP_FMAC4 soap_get_sai__PowerStateType(struct soap *soap, enum sai__PowerStateType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__PowerStateType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__PowerStateType(struct soap *soap, const char *s, enum sai__PowerStateType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__PowerStateType, s); + if (map) + *a = (enum sai__PowerStateType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 5))) + return soap->error = SOAP_TYPE; + *a = (enum sai__PowerStateType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__PowerStateType * SOAP_FMAC4 soap_in_sai__PowerStateType(struct soap *soap, const char *tag, enum sai__PowerStateType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__PowerStateType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__PowerStateType, sizeof(enum sai__PowerStateType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__PowerStateType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__PowerStateType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__PowerStateType, 0, sizeof(enum sai__PowerStateType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__KerberosEncryptionType(struct soap *soap, enum sai__KerberosEncryptionType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__KerberosEncryptionType + *a = SOAP_DEFAULT_sai__KerberosEncryptionType; +#else + *a = (enum sai__KerberosEncryptionType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__KerberosEncryptionType(struct soap *soap, const enum sai__KerberosEncryptionType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__KerberosEncryptionType); + if (soap_out_sai__KerberosEncryptionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__KerberosEncryptionType[] = +{ { (long)sai__KerberosEncryptionType__HMAC_USCORERC4, "HMAC_RC4" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__KerberosEncryptionType2s(struct soap *soap, enum sai__KerberosEncryptionType n) +{ const char *s = soap_code_str(soap_codes_sai__KerberosEncryptionType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__KerberosEncryptionType(struct soap *soap, const char *tag, int id, const enum sai__KerberosEncryptionType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__KerberosEncryptionType), type); + soap_send(soap, soap_sai__KerberosEncryptionType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__KerberosEncryptionType * SOAP_FMAC4 soap_get_sai__KerberosEncryptionType(struct soap *soap, enum sai__KerberosEncryptionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__KerberosEncryptionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__KerberosEncryptionType(struct soap *soap, const char *s, enum sai__KerberosEncryptionType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__KerberosEncryptionType, s); + if (map) + *a = (enum sai__KerberosEncryptionType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 0))) + return soap->error = SOAP_TYPE; + *a = (enum sai__KerberosEncryptionType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__KerberosEncryptionType * SOAP_FMAC4 soap_in_sai__KerberosEncryptionType(struct soap *soap, const char *tag, enum sai__KerberosEncryptionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__KerberosEncryptionType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__KerberosEncryptionType, sizeof(enum sai__KerberosEncryptionType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__KerberosEncryptionType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__KerberosEncryptionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__KerberosEncryptionType, 0, sizeof(enum sai__KerberosEncryptionType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__KerberosSpnProtocolType(struct soap *soap, enum sai__KerberosSpnProtocolType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__KerberosSpnProtocolType + *a = SOAP_DEFAULT_sai__KerberosSpnProtocolType; +#else + *a = (enum sai__KerberosSpnProtocolType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__KerberosSpnProtocolType(struct soap *soap, const enum sai__KerberosSpnProtocolType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__KerberosSpnProtocolType); + if (soap_out_sai__KerberosSpnProtocolType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__KerberosSpnProtocolType[] = +{ { (long)sai__KerberosSpnProtocolType__HTTP, "HTTP" }, + { (long)sai__KerberosSpnProtocolType__HTTPS, "HTTPS" }, + { (long)sai__KerberosSpnProtocolType__SOL_USCOREIDER, "SOL_IDER" }, + { (long)sai__KerberosSpnProtocolType__SOL_USCOREIDER_USCORESSL, "SOL_IDER_SSL" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__KerberosSpnProtocolType2s(struct soap *soap, enum sai__KerberosSpnProtocolType n) +{ const char *s = soap_code_str(soap_codes_sai__KerberosSpnProtocolType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__KerberosSpnProtocolType(struct soap *soap, const char *tag, int id, const enum sai__KerberosSpnProtocolType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__KerberosSpnProtocolType), type); + soap_send(soap, soap_sai__KerberosSpnProtocolType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__KerberosSpnProtocolType * SOAP_FMAC4 soap_get_sai__KerberosSpnProtocolType(struct soap *soap, enum sai__KerberosSpnProtocolType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__KerberosSpnProtocolType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__KerberosSpnProtocolType(struct soap *soap, const char *s, enum sai__KerberosSpnProtocolType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__KerberosSpnProtocolType, s); + if (map) + *a = (enum sai__KerberosSpnProtocolType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 3))) + return soap->error = SOAP_TYPE; + *a = (enum sai__KerberosSpnProtocolType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__KerberosSpnProtocolType * SOAP_FMAC4 soap_in_sai__KerberosSpnProtocolType(struct soap *soap, const char *tag, enum sai__KerberosSpnProtocolType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__KerberosSpnProtocolType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__KerberosSpnProtocolType, sizeof(enum sai__KerberosSpnProtocolType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__KerberosSpnProtocolType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__KerberosSpnProtocolType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__KerberosSpnProtocolType, 0, sizeof(enum sai__KerberosSpnProtocolType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__AccessPermissionType(struct soap *soap, enum sai__AccessPermissionType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__AccessPermissionType + *a = SOAP_DEFAULT_sai__AccessPermissionType; +#else + *a = (enum sai__AccessPermissionType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__AccessPermissionType(struct soap *soap, const enum sai__AccessPermissionType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__AccessPermissionType); + if (soap_out_sai__AccessPermissionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__AccessPermissionType[] = +{ { (long)sai__AccessPermissionType__LocalAccessPermission, "LocalAccessPermission" }, + { (long)sai__AccessPermissionType__NetworkAccessPermission, "NetworkAccessPermission" }, + { (long)sai__AccessPermissionType__AnyAccessPermission, "AnyAccessPermission" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__AccessPermissionType2s(struct soap *soap, enum sai__AccessPermissionType n) +{ const char *s = soap_code_str(soap_codes_sai__AccessPermissionType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AccessPermissionType(struct soap *soap, const char *tag, int id, const enum sai__AccessPermissionType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__AccessPermissionType), type); + soap_send(soap, soap_sai__AccessPermissionType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__AccessPermissionType * SOAP_FMAC4 soap_get_sai__AccessPermissionType(struct soap *soap, enum sai__AccessPermissionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__AccessPermissionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__AccessPermissionType(struct soap *soap, const char *s, enum sai__AccessPermissionType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__AccessPermissionType, s); + if (map) + *a = (enum sai__AccessPermissionType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum sai__AccessPermissionType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__AccessPermissionType * SOAP_FMAC4 soap_in_sai__AccessPermissionType(struct soap *soap, const char *tag, enum sai__AccessPermissionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__AccessPermissionType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__AccessPermissionType, sizeof(enum sai__AccessPermissionType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__AccessPermissionType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__AccessPermissionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__AccessPermissionType, 0, sizeof(enum sai__AccessPermissionType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__ProvisioningModeType(struct soap *soap, enum sai__ProvisioningModeType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__ProvisioningModeType + *a = SOAP_DEFAULT_sai__ProvisioningModeType; +#else + *a = (enum sai__ProvisioningModeType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__ProvisioningModeType(struct soap *soap, const enum sai__ProvisioningModeType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__ProvisioningModeType); + if (soap_out_sai__ProvisioningModeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__ProvisioningModeType[] = +{ { (long)sai__ProvisioningModeType__0, "0" }, + { (long)sai__ProvisioningModeType__1, "1" }, + { (long)sai__ProvisioningModeType__2, "2" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__ProvisioningModeType2s(struct soap *soap, enum sai__ProvisioningModeType n) +{ const char *s = soap_code_str(soap_codes_sai__ProvisioningModeType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__ProvisioningModeType(struct soap *soap, const char *tag, int id, const enum sai__ProvisioningModeType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__ProvisioningModeType), type); + soap_send(soap, soap_sai__ProvisioningModeType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__ProvisioningModeType * SOAP_FMAC4 soap_get_sai__ProvisioningModeType(struct soap *soap, enum sai__ProvisioningModeType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__ProvisioningModeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__ProvisioningModeType(struct soap *soap, const char *s, enum sai__ProvisioningModeType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__ProvisioningModeType, s); + if (map) + *a = (enum sai__ProvisioningModeType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 2))) + return soap->error = SOAP_TYPE; + *a = (enum sai__ProvisioningModeType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__ProvisioningModeType * SOAP_FMAC4 soap_in_sai__ProvisioningModeType(struct soap *soap, const char *tag, enum sai__ProvisioningModeType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__ProvisioningModeType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__ProvisioningModeType, sizeof(enum sai__ProvisioningModeType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__ProvisioningModeType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__ProvisioningModeType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__ProvisioningModeType, 0, sizeof(enum sai__ProvisioningModeType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__RngKeyEncodingType(struct soap *soap, enum sai__RngKeyEncodingType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__RngKeyEncodingType + *a = SOAP_DEFAULT_sai__RngKeyEncodingType; +#else + *a = (enum sai__RngKeyEncodingType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__RngKeyEncodingType(struct soap *soap, const enum sai__RngKeyEncodingType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__RngKeyEncodingType); + if (soap_out_sai__RngKeyEncodingType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__RngKeyEncodingType[] = +{ { (long)sai__RngKeyEncodingType__20, "20" }, + { (long)sai__RngKeyEncodingType__21, "21" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__RngKeyEncodingType2s(struct soap *soap, enum sai__RngKeyEncodingType n) +{ const char *s = soap_code_str(soap_codes_sai__RngKeyEncodingType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RngKeyEncodingType(struct soap *soap, const char *tag, int id, const enum sai__RngKeyEncodingType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__RngKeyEncodingType), type); + soap_send(soap, soap_sai__RngKeyEncodingType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__RngKeyEncodingType * SOAP_FMAC4 soap_get_sai__RngKeyEncodingType(struct soap *soap, enum sai__RngKeyEncodingType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__RngKeyEncodingType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__RngKeyEncodingType(struct soap *soap, const char *s, enum sai__RngKeyEncodingType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__RngKeyEncodingType, s); + if (map) + *a = (enum sai__RngKeyEncodingType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 21))) + return soap->error = SOAP_TYPE; + *a = (enum sai__RngKeyEncodingType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__RngKeyEncodingType * SOAP_FMAC4 soap_in_sai__RngKeyEncodingType(struct soap *soap, const char *tag, enum sai__RngKeyEncodingType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__RngKeyEncodingType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__RngKeyEncodingType, sizeof(enum sai__RngKeyEncodingType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__RngKeyEncodingType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__RngKeyEncodingType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__RngKeyEncodingType, 0, sizeof(enum sai__RngKeyEncodingType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__RsaCertificateEncodingType(struct soap *soap, enum sai__RsaCertificateEncodingType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__RsaCertificateEncodingType + *a = SOAP_DEFAULT_sai__RsaCertificateEncodingType; +#else + *a = (enum sai__RsaCertificateEncodingType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__RsaCertificateEncodingType(struct soap *soap, const enum sai__RsaCertificateEncodingType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__RsaCertificateEncodingType); + if (soap_out_sai__RsaCertificateEncodingType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__RsaCertificateEncodingType[] = +{ { (long)sai__RsaCertificateEncodingType__10, "10" }, + { (long)sai__RsaCertificateEncodingType__11, "11" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__RsaCertificateEncodingType2s(struct soap *soap, enum sai__RsaCertificateEncodingType n) +{ const char *s = soap_code_str(soap_codes_sai__RsaCertificateEncodingType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RsaCertificateEncodingType(struct soap *soap, const char *tag, int id, const enum sai__RsaCertificateEncodingType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__RsaCertificateEncodingType), type); + soap_send(soap, soap_sai__RsaCertificateEncodingType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__RsaCertificateEncodingType * SOAP_FMAC4 soap_get_sai__RsaCertificateEncodingType(struct soap *soap, enum sai__RsaCertificateEncodingType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__RsaCertificateEncodingType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__RsaCertificateEncodingType(struct soap *soap, const char *s, enum sai__RsaCertificateEncodingType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__RsaCertificateEncodingType, s); + if (map) + *a = (enum sai__RsaCertificateEncodingType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 11))) + return soap->error = SOAP_TYPE; + *a = (enum sai__RsaCertificateEncodingType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__RsaCertificateEncodingType * SOAP_FMAC4 soap_in_sai__RsaCertificateEncodingType(struct soap *soap, const char *tag, enum sai__RsaCertificateEncodingType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__RsaCertificateEncodingType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__RsaCertificateEncodingType, sizeof(enum sai__RsaCertificateEncodingType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__RsaCertificateEncodingType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__RsaCertificateEncodingType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__RsaCertificateEncodingType, 0, sizeof(enum sai__RsaCertificateEncodingType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__RsaKeyEncodingType(struct soap *soap, enum sai__RsaKeyEncodingType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__RsaKeyEncodingType + *a = SOAP_DEFAULT_sai__RsaKeyEncodingType; +#else + *a = (enum sai__RsaKeyEncodingType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__RsaKeyEncodingType(struct soap *soap, const enum sai__RsaKeyEncodingType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__RsaKeyEncodingType); + if (soap_out_sai__RsaKeyEncodingType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__RsaKeyEncodingType[] = +{ { (long)sai__RsaKeyEncodingType__30, "30" }, + { (long)sai__RsaKeyEncodingType__31, "31" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__RsaKeyEncodingType2s(struct soap *soap, enum sai__RsaKeyEncodingType n) +{ const char *s = soap_code_str(soap_codes_sai__RsaKeyEncodingType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RsaKeyEncodingType(struct soap *soap, const char *tag, int id, const enum sai__RsaKeyEncodingType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__RsaKeyEncodingType), type); + soap_send(soap, soap_sai__RsaKeyEncodingType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__RsaKeyEncodingType * SOAP_FMAC4 soap_get_sai__RsaKeyEncodingType(struct soap *soap, enum sai__RsaKeyEncodingType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__RsaKeyEncodingType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__RsaKeyEncodingType(struct soap *soap, const char *s, enum sai__RsaKeyEncodingType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__RsaKeyEncodingType, s); + if (map) + *a = (enum sai__RsaKeyEncodingType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 31))) + return soap->error = SOAP_TYPE; + *a = (enum sai__RsaKeyEncodingType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__RsaKeyEncodingType * SOAP_FMAC4 soap_in_sai__RsaKeyEncodingType(struct soap *soap, const char *tag, enum sai__RsaKeyEncodingType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__RsaKeyEncodingType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__RsaKeyEncodingType, sizeof(enum sai__RsaKeyEncodingType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__RsaKeyEncodingType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__RsaKeyEncodingType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__RsaKeyEncodingType, 0, sizeof(enum sai__RsaKeyEncodingType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__UserAclRealmType(struct soap *soap, enum sai__UserAclRealmType *a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_sai__UserAclRealmType + *a = SOAP_DEFAULT_sai__UserAclRealmType; +#else + *a = (enum sai__UserAclRealmType)0; +#endif +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__UserAclRealmType(struct soap *soap, const enum sai__UserAclRealmType *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__UserAclRealmType); + if (soap_out_sai__UserAclRealmType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +static const struct soap_code_map soap_codes_sai__UserAclRealmType[] = +{ { (long)sai__UserAclRealmType__0, "0" }, + { (long)sai__UserAclRealmType__1, "1" }, + { (long)sai__UserAclRealmType__2, "2" }, + { (long)sai__UserAclRealmType__3, "3" }, + { (long)sai__UserAclRealmType__4, "4" }, + { (long)sai__UserAclRealmType__5, "5" }, + { (long)sai__UserAclRealmType__6, "6" }, + { (long)sai__UserAclRealmType__7, "7" }, + { (long)sai__UserAclRealmType__8, "8" }, + { (long)sai__UserAclRealmType__9, "9" }, + { (long)sai__UserAclRealmType__10, "10" }, + { (long)sai__UserAclRealmType__11, "11" }, + { (long)sai__UserAclRealmType__12, "12" }, + { (long)sai__UserAclRealmType__13, "13" }, + { (long)sai__UserAclRealmType__14, "14" }, + { (long)sai__UserAclRealmType__15, "15" }, + { (long)sai__UserAclRealmType__16, "16" }, + { (long)sai__UserAclRealmType__17, "17" }, + { (long)sai__UserAclRealmType__18, "18" }, + { (long)sai__UserAclRealmType__19, "19" }, + { 0, NULL } +}; + +SOAP_FMAC3S const char* SOAP_FMAC4S soap_sai__UserAclRealmType2s(struct soap *soap, enum sai__UserAclRealmType n) +{ const char *s = soap_code_str(soap_codes_sai__UserAclRealmType, (long)n); + if (s) + return s; + return soap_long2s(soap, (long)n); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclRealmType(struct soap *soap, const char *tag, int id, const enum sai__UserAclRealmType *a, const char *type) +{ soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__UserAclRealmType), type); + soap_send(soap, soap_sai__UserAclRealmType2s(soap, *a)); + return soap_element_end_out(soap, tag); +} + +SOAP_FMAC3 enum sai__UserAclRealmType * SOAP_FMAC4 soap_get_sai__UserAclRealmType(struct soap *soap, enum sai__UserAclRealmType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__UserAclRealmType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3S int SOAP_FMAC4S soap_s2sai__UserAclRealmType(struct soap *soap, const char *s, enum sai__UserAclRealmType *a) +{ + const struct soap_code_map *map; + if (!s) + return SOAP_OK; + map = soap_code(soap_codes_sai__UserAclRealmType, s); + if (map) + *a = (enum sai__UserAclRealmType)map->code; + else + { long n; + if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 19))) + return soap->error = SOAP_TYPE; + *a = (enum sai__UserAclRealmType)n; + } + return SOAP_OK; +} + +SOAP_FMAC3 enum sai__UserAclRealmType * SOAP_FMAC4 soap_in_sai__UserAclRealmType(struct soap *soap, const char *tag, enum sai__UserAclRealmType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (enum sai__UserAclRealmType *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_sai__UserAclRealmType, sizeof(enum sai__UserAclRealmType), 0, NULL, NULL, NULL); + if (!a) + return NULL; + if (soap->body && !*soap->href) + { if (!a || soap_s2sai__UserAclRealmType(soap, soap_value(soap), a) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (enum sai__UserAclRealmType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__UserAclRealmType, 0, sizeof(enum sai__UserAclRealmType), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__PassPhrase63Type(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__PassPhrase63Type(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__PassPhrase63Type(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_wcxs__PassPhrase63Type); + if (soap_out_wcxs__PassPhrase63Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__PassPhrase63Type(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_wcxs__PassPhrase63Type), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_wcxs__PassPhrase63Type(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__PassPhrase63Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_wcxs__PassPhrase63Type(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_wcxs__PassPhrase63Type, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 8, 63))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_wcxs__PassPhrase63Type, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_wcxs__PassPhrase63Type, 0, sizeof(std::string), 0, soap_copy_wcxs__PassPhrase63Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_wcxs__PassPhrase63Type(struct soap *soap, int n) +{ return soap_instantiate_wcxs__PassPhrase63Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__PassPhrase63Type(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_wcxs__PassPhrase63Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__PassPhrase63Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__PassPhrase63Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__PassPhrase63Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__PassPhraseWEP128Type(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__PassPhraseWEP128Type(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__PassPhraseWEP128Type(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_wcxs__PassPhraseWEP128Type); + if (soap_out_wcxs__PassPhraseWEP128Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__PassPhraseWEP128Type(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_wcxs__PassPhraseWEP128Type), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_wcxs__PassPhraseWEP128Type(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__PassPhraseWEP128Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_wcxs__PassPhraseWEP128Type(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_wcxs__PassPhraseWEP128Type, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, -1))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_wcxs__PassPhraseWEP128Type, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_wcxs__PassPhraseWEP128Type, 0, sizeof(std::string), 0, soap_copy_wcxs__PassPhraseWEP128Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_wcxs__PassPhraseWEP128Type(struct soap *soap, int n) +{ return soap_instantiate_wcxs__PassPhraseWEP128Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__PassPhraseWEP128Type(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_wcxs__PassPhraseWEP128Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__PassPhraseWEP128Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__PassPhraseWEP128Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__PassPhraseWEP128Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__PassPhrase5Type(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__PassPhrase5Type(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__PassPhrase5Type(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_wcxs__PassPhrase5Type); + if (soap_out_wcxs__PassPhrase5Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__PassPhrase5Type(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_wcxs__PassPhrase5Type), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_wcxs__PassPhrase5Type(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__PassPhrase5Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_wcxs__PassPhrase5Type(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_wcxs__PassPhrase5Type, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, -1))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_wcxs__PassPhrase5Type, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_wcxs__PassPhrase5Type, 0, sizeof(std::string), 0, soap_copy_wcxs__PassPhrase5Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_wcxs__PassPhrase5Type(struct soap *soap, int n) +{ return soap_instantiate_wcxs__PassPhrase5Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__PassPhrase5Type(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_wcxs__PassPhrase5Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__PassPhrase5Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__PassPhrase5Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__PassPhrase5Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__RawKey256Type(struct soap *soap, xsd__base64Binary const*a) +{ a->soap_serialize(soap); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__RawKey256Type(struct soap *soap, xsd__base64Binary *a) +{ a->xsd__base64Binary::soap_default(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__RawKey256Type(struct soap *soap, const xsd__base64Binary *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, (struct soap_array*)&a->__ptr, 1, tag, SOAP_TYPE_wcxs__RawKey256Type); + if (soap_out_wcxs__RawKey256Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__RawKey256Type(struct soap *soap, const char *tag, int id, const xsd__base64Binary *a, const char *type) +{ + id = soap_attachment(soap, tag, id, a, (struct soap_array*)&a->__ptr, a->id, a->type, a->options, 1, type, SOAP_TYPE_wcxs__RawKey256Type); + if (id < 0) + return soap->error; + soap_element_begin_out(soap, tag, id, type); + soap_putbase64(soap, a->__ptr, a->__size); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_wcxs__RawKey256Type(struct soap *soap, xsd__base64Binary *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__RawKey256Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_wcxs__RawKey256Type(struct soap *soap, const char *tag, xsd__base64Binary *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":base64Binary") && soap_match_tag(soap, soap->type, ":base64")) + { soap->error = SOAP_TYPE; + return NULL; + } + a = (xsd__base64Binary *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__RawKey256Type, sizeof(xsd__base64Binary), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + a->soap_default(soap); + if (soap->body && !*soap->href) + { + a->__ptr = soap_getbase64(soap, &a->__size, 0); + if (soap_xop_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + if ((!a->__ptr && soap->error) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { if (*soap->href != '#') + { if (soap_dime_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + } + else + a = (xsd__base64Binary *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__RawKey256Type, 0, sizeof(xsd__base64Binary), 0, soap_copy_wcxs__RawKey256Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_wcxs__RawKey256Type(struct soap *soap, int n) +{ return soap_instantiate_wcxs__RawKey256Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__RawKey256Type(struct soap *soap, xsd__base64Binary *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_wcxs__RawKey256Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__RawKey256Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__RawKey256Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xsd__base64Binary; + if (size) + *size = sizeof(xsd__base64Binary); + ((xsd__base64Binary*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xsd__base64Binary[n]; + if (size) + *size = n * sizeof(xsd__base64Binary); + for (int i = 0; i < n; i++) + ((xsd__base64Binary*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xsd__base64Binary*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__RawKey256Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xsd__base64Binary %p -> %p\n", q, p)); + *(xsd__base64Binary*)p = *(xsd__base64Binary*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__RawKey128Type(struct soap *soap, xsd__base64Binary const*a) +{ a->soap_serialize(soap); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__RawKey128Type(struct soap *soap, xsd__base64Binary *a) +{ a->xsd__base64Binary::soap_default(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__RawKey128Type(struct soap *soap, const xsd__base64Binary *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, (struct soap_array*)&a->__ptr, 1, tag, SOAP_TYPE_wcxs__RawKey128Type); + if (soap_out_wcxs__RawKey128Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__RawKey128Type(struct soap *soap, const char *tag, int id, const xsd__base64Binary *a, const char *type) +{ + id = soap_attachment(soap, tag, id, a, (struct soap_array*)&a->__ptr, a->id, a->type, a->options, 1, type, SOAP_TYPE_wcxs__RawKey128Type); + if (id < 0) + return soap->error; + soap_element_begin_out(soap, tag, id, type); + soap_putbase64(soap, a->__ptr, a->__size); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_wcxs__RawKey128Type(struct soap *soap, xsd__base64Binary *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__RawKey128Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_wcxs__RawKey128Type(struct soap *soap, const char *tag, xsd__base64Binary *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":base64Binary") && soap_match_tag(soap, soap->type, ":base64")) + { soap->error = SOAP_TYPE; + return NULL; + } + a = (xsd__base64Binary *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__RawKey128Type, sizeof(xsd__base64Binary), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + a->soap_default(soap); + if (soap->body && !*soap->href) + { + a->__ptr = soap_getbase64(soap, &a->__size, 0); + if (soap_xop_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + if ((!a->__ptr && soap->error) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { if (*soap->href != '#') + { if (soap_dime_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + } + else + a = (xsd__base64Binary *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__RawKey128Type, 0, sizeof(xsd__base64Binary), 0, soap_copy_wcxs__RawKey128Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_wcxs__RawKey128Type(struct soap *soap, int n) +{ return soap_instantiate_wcxs__RawKey128Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__RawKey128Type(struct soap *soap, xsd__base64Binary *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_wcxs__RawKey128Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__RawKey128Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__RawKey128Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xsd__base64Binary; + if (size) + *size = sizeof(xsd__base64Binary); + ((xsd__base64Binary*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xsd__base64Binary[n]; + if (size) + *size = n * sizeof(xsd__base64Binary); + for (int i = 0; i < n; i++) + ((xsd__base64Binary*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xsd__base64Binary*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__RawKey128Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xsd__base64Binary %p -> %p\n", q, p)); + *(xsd__base64Binary*)p = *(xsd__base64Binary*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__RawKey64Type(struct soap *soap, xsd__base64Binary const*a) +{ a->soap_serialize(soap); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__RawKey64Type(struct soap *soap, xsd__base64Binary *a) +{ a->xsd__base64Binary::soap_default(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__RawKey64Type(struct soap *soap, const xsd__base64Binary *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, (struct soap_array*)&a->__ptr, 1, tag, SOAP_TYPE_wcxs__RawKey64Type); + if (soap_out_wcxs__RawKey64Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__RawKey64Type(struct soap *soap, const char *tag, int id, const xsd__base64Binary *a, const char *type) +{ + id = soap_attachment(soap, tag, id, a, (struct soap_array*)&a->__ptr, a->id, a->type, a->options, 1, type, SOAP_TYPE_wcxs__RawKey64Type); + if (id < 0) + return soap->error; + soap_element_begin_out(soap, tag, id, type); + soap_putbase64(soap, a->__ptr, a->__size); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_wcxs__RawKey64Type(struct soap *soap, xsd__base64Binary *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__RawKey64Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_wcxs__RawKey64Type(struct soap *soap, const char *tag, xsd__base64Binary *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":base64Binary") && soap_match_tag(soap, soap->type, ":base64")) + { soap->error = SOAP_TYPE; + return NULL; + } + a = (xsd__base64Binary *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__RawKey64Type, sizeof(xsd__base64Binary), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + a->soap_default(soap); + if (soap->body && !*soap->href) + { + a->__ptr = soap_getbase64(soap, &a->__size, 0); + if (soap_xop_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + if ((!a->__ptr && soap->error) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { if (*soap->href != '#') + { if (soap_dime_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + } + else + a = (xsd__base64Binary *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__RawKey64Type, 0, sizeof(xsd__base64Binary), 0, soap_copy_wcxs__RawKey64Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_wcxs__RawKey64Type(struct soap *soap, int n) +{ return soap_instantiate_wcxs__RawKey64Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__RawKey64Type(struct soap *soap, xsd__base64Binary *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_wcxs__RawKey64Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__RawKey64Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__RawKey64Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xsd__base64Binary; + if (size) + *size = sizeof(xsd__base64Binary); + ((xsd__base64Binary*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xsd__base64Binary[n]; + if (size) + *size = n * sizeof(xsd__base64Binary); + for (int i = 0; i < n; i++) + ((xsd__base64Binary*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xsd__base64Binary*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__RawKey64Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xsd__base64Binary %p -> %p\n", q, p)); + *(xsd__base64Binary*)p = *(xsd__base64Binary*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_wcxs__ProfileNameType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_wcxs__ProfileNameType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_wcxs__ProfileNameType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_wcxs__ProfileNameType); + if (soap_out_wcxs__ProfileNameType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileNameType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_wcxs__ProfileNameType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_wcxs__ProfileNameType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__ProfileNameType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_wcxs__ProfileNameType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_wcxs__ProfileNameType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 1, 35))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_wcxs__ProfileNameType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_wcxs__ProfileNameType, 0, sizeof(std::string), 0, soap_copy_wcxs__ProfileNameType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_wcxs__ProfileNameType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__ProfileNameType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileNameType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_wcxs__ProfileNameType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__ProfileNameType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__ProfileNameType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileNameType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__apr__AgentDescription(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default__apr__AgentDescription(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put__apr__AgentDescription(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__apr__AgentDescription); + if (soap_out__apr__AgentDescription(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__AgentDescription(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE__apr__AgentDescription), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__apr__AgentDescription(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__AgentDescription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in__apr__AgentDescription(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__apr__AgentDescription, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 0, 16))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__apr__AgentDescription, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE__apr__AgentDescription, 0, sizeof(std::string), 0, soap_copy__apr__AgentDescription); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__apr__AgentDescription(struct soap *soap, int n) +{ return soap_instantiate__apr__AgentDescription(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__AgentDescription(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__apr__AgentDescription(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__AgentDescription(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__AgentDescription, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__AgentDescription(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__PolicyName(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default__cb__PolicyName(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put__cb__PolicyName(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__cb__PolicyName); + if (soap_out__cb__PolicyName(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__PolicyName(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE__cb__PolicyName), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__cb__PolicyName(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__PolicyName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in__cb__PolicyName(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__cb__PolicyName, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 0, 16))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__cb__PolicyName, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE__cb__PolicyName, 0, sizeof(std::string), 0, soap_copy__cb__PolicyName); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__cb__PolicyName(struct soap *soap, int n) +{ return soap_instantiate__cb__PolicyName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__PolicyName(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__cb__PolicyName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__PolicyName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__PolicyName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__PolicyName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__FilterName(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default__cb__FilterName(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put__cb__FilterName(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__cb__FilterName); + if (soap_out__cb__FilterName(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__FilterName(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE__cb__FilterName), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__cb__FilterName(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__FilterName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in__cb__FilterName(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__cb__FilterName, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 0, 16))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__cb__FilterName, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE__cb__FilterName, 0, sizeof(std::string), 0, soap_copy__cb__FilterName); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__cb__FilterName(struct soap *soap, int n) +{ return soap_instantiate__cb__FilterName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__FilterName(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__cb__FilterName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__FilterName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__FilterName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__FilterName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cb__IPv6AddressStringType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__IPv6AddressStringType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__IPv6AddressStringType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__IPv6AddressStringType); + if (soap_out_cb__IPv6AddressStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__IPv6AddressStringType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_cb__IPv6AddressStringType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cb__IPv6AddressStringType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__IPv6AddressStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_cb__IPv6AddressStringType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cb__IPv6AddressStringType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, -1))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cb__IPv6AddressStringType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_cb__IPv6AddressStringType, 0, sizeof(std::string), 0, soap_copy_cb__IPv6AddressStringType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cb__IPv6AddressStringType(struct soap *soap, int n) +{ return soap_instantiate_cb__IPv6AddressStringType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__IPv6AddressStringType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cb__IPv6AddressStringType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__IPv6AddressStringType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__IPv6AddressStringType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__IPv6AddressStringType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cb__IPv4AddressStringType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cb__IPv4AddressStringType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cb__IPv4AddressStringType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cb__IPv4AddressStringType); + if (soap_out_cb__IPv4AddressStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__IPv4AddressStringType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_cb__IPv4AddressStringType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cb__IPv4AddressStringType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__IPv4AddressStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_cb__IPv4AddressStringType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cb__IPv4AddressStringType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, -1))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cb__IPv4AddressStringType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_cb__IPv4AddressStringType, 0, sizeof(std::string), 0, soap_copy_cb__IPv4AddressStringType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cb__IPv4AddressStringType(struct soap *soap, int n) +{ return soap_instantiate_cb__IPv4AddressStringType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__IPv4AddressStringType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cb__IPv4AddressStringType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__IPv4AddressStringType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__IPv4AddressStringType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__IPv4AddressStringType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_emi__CommunityStringType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_emi__CommunityStringType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_emi__CommunityStringType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_emi__CommunityStringType); + if (soap_out_emi__CommunityStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__CommunityStringType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_emi__CommunityStringType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_emi__CommunityStringType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__CommunityStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_emi__CommunityStringType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_emi__CommunityStringType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 1, 16))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_emi__CommunityStringType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_emi__CommunityStringType, 0, sizeof(std::string), 0, soap_copy_emi__CommunityStringType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_emi__CommunityStringType(struct soap *soap, int n) +{ return soap_instantiate_emi__CommunityStringType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__CommunityStringType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_emi__CommunityStringType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__CommunityStringType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__CommunityStringType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__CommunityStringType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_net__MACAddressType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_net__MACAddressType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_net__MACAddressType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_net__MACAddressType); + if (soap_out_net__MACAddressType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__MACAddressType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_net__MACAddressType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_net__MACAddressType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__MACAddressType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_net__MACAddressType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_net__MACAddressType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, -1))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_net__MACAddressType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_net__MACAddressType, 0, sizeof(std::string), 0, soap_copy_net__MACAddressType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_net__MACAddressType(struct soap *soap, int n) +{ return soap_instantiate_net__MACAddressType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__MACAddressType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_net__MACAddressType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_net__MACAddressType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_net__MACAddressType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__MACAddressType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__sai__KerberosRealmName(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default__sai__KerberosRealmName(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put__sai__KerberosRealmName(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__sai__KerberosRealmName); + if (soap_out__sai__KerberosRealmName(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__KerberosRealmName(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE__sai__KerberosRealmName), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__sai__KerberosRealmName(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__KerberosRealmName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in__sai__KerberosRealmName(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__sai__KerberosRealmName, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 1, 63))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__sai__KerberosRealmName, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE__sai__KerberosRealmName, 0, sizeof(std::string), 0, soap_copy__sai__KerberosRealmName); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__sai__KerberosRealmName(struct soap *soap, int n) +{ return soap_instantiate__sai__KerberosRealmName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__KerberosRealmName(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__sai__KerberosRealmName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__KerberosRealmName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__KerberosRealmName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__KerberosRealmName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__sai__SpnString(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default__sai__SpnString(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put__sai__SpnString(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__sai__SpnString); + if (soap_out__sai__SpnString(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SpnString(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE__sai__SpnString), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get__sai__SpnString(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SpnString(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in__sai__SpnString(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__sai__SpnString, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 0, 266))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE__sai__SpnString, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE__sai__SpnString, 0, sizeof(std::string), 0, soap_copy__sai__SpnString); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new__sai__SpnString(struct soap *soap, int n) +{ return soap_instantiate__sai__SpnString(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SpnString(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate__sai__SpnString(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SpnString(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SpnString, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SpnString(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__FriendlyNameType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__FriendlyNameType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__FriendlyNameType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__FriendlyNameType); + if (soap_out_sai__FriendlyNameType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__FriendlyNameType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_sai__FriendlyNameType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_sai__FriendlyNameType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__FriendlyNameType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_sai__FriendlyNameType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_sai__FriendlyNameType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 1, 32))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_sai__FriendlyNameType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_sai__FriendlyNameType, 0, sizeof(std::string), 0, soap_copy_sai__FriendlyNameType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_sai__FriendlyNameType(struct soap *soap, int n) +{ return soap_instantiate_sai__FriendlyNameType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__FriendlyNameType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_sai__FriendlyNameType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__FriendlyNameType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__FriendlyNameType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__FriendlyNameType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__ProvisioningOTPType(struct soap *soap, xsd__base64Binary const*a) +{ a->soap_serialize(soap); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__ProvisioningOTPType(struct soap *soap, xsd__base64Binary *a) +{ a->xsd__base64Binary::soap_default(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__ProvisioningOTPType(struct soap *soap, const xsd__base64Binary *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, (struct soap_array*)&a->__ptr, 1, tag, SOAP_TYPE_sai__ProvisioningOTPType); + if (soap_out_sai__ProvisioningOTPType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__ProvisioningOTPType(struct soap *soap, const char *tag, int id, const xsd__base64Binary *a, const char *type) +{ + id = soap_attachment(soap, tag, id, a, (struct soap_array*)&a->__ptr, a->id, a->type, a->options, 1, type, SOAP_TYPE_sai__ProvisioningOTPType); + if (id < 0) + return soap->error; + soap_element_begin_out(soap, tag, id, type); + soap_putbase64(soap, a->__ptr, a->__size); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_sai__ProvisioningOTPType(struct soap *soap, xsd__base64Binary *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__ProvisioningOTPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_sai__ProvisioningOTPType(struct soap *soap, const char *tag, xsd__base64Binary *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":base64Binary") && soap_match_tag(soap, soap->type, ":base64")) + { soap->error = SOAP_TYPE; + return NULL; + } + a = (xsd__base64Binary *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__ProvisioningOTPType, sizeof(xsd__base64Binary), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + a->soap_default(soap); + if (soap->body && !*soap->href) + { + a->__ptr = soap_getbase64(soap, &a->__size, 0); + if (soap_xop_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + if ((!a->__ptr && soap->error) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { if (*soap->href != '#') + { if (soap_dime_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + } + else + a = (xsd__base64Binary *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__ProvisioningOTPType, 0, sizeof(xsd__base64Binary), 0, soap_copy_sai__ProvisioningOTPType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_sai__ProvisioningOTPType(struct soap *soap, int n) +{ return soap_instantiate_sai__ProvisioningOTPType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__ProvisioningOTPType(struct soap *soap, xsd__base64Binary *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_sai__ProvisioningOTPType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__ProvisioningOTPType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__ProvisioningOTPType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xsd__base64Binary; + if (size) + *size = sizeof(xsd__base64Binary); + ((xsd__base64Binary*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xsd__base64Binary[n]; + if (size) + *size = n * sizeof(xsd__base64Binary); + for (int i = 0; i < n; i++) + ((xsd__base64Binary*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xsd__base64Binary*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__ProvisioningOTPType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xsd__base64Binary %p -> %p\n", q, p)); + *(xsd__base64Binary*)p = *(xsd__base64Binary*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__MEBxPasswordType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__MEBxPasswordType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__MEBxPasswordType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__MEBxPasswordType); + if (soap_out_sai__MEBxPasswordType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__MEBxPasswordType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_sai__MEBxPasswordType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_sai__MEBxPasswordType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__MEBxPasswordType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_sai__MEBxPasswordType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_sai__MEBxPasswordType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 0, 32))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_sai__MEBxPasswordType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_sai__MEBxPasswordType, 0, sizeof(std::string), 0, soap_copy_sai__MEBxPasswordType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_sai__MEBxPasswordType(struct soap *soap, int n) +{ return soap_instantiate_sai__MEBxPasswordType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__MEBxPasswordType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_sai__MEBxPasswordType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__MEBxPasswordType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__MEBxPasswordType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__MEBxPasswordType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__AclPasswordStringType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__AclPasswordStringType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__AclPasswordStringType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__AclPasswordStringType); + if (soap_out_sai__AclPasswordStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AclPasswordStringType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_sai__AclPasswordStringType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_sai__AclPasswordStringType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__AclPasswordStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_sai__AclPasswordStringType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_sai__AclPasswordStringType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, 32))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_sai__AclPasswordStringType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_sai__AclPasswordStringType, 0, sizeof(std::string), 0, soap_copy_sai__AclPasswordStringType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_sai__AclPasswordStringType(struct soap *soap, int n) +{ return soap_instantiate_sai__AclPasswordStringType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AclPasswordStringType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_sai__AclPasswordStringType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__AclPasswordStringType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__AclPasswordStringType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AclPasswordStringType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_sai__AclStringType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_sai__AclStringType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_sai__AclStringType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_sai__AclStringType); + if (soap_out_sai__AclStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AclStringType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_sai__AclStringType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_sai__AclStringType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__AclStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_sai__AclStringType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_sai__AclStringType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, 16))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_sai__AclStringType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_sai__AclStringType, 0, sizeof(std::string), 0, soap_copy_sai__AclStringType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_sai__AclStringType(struct soap *soap, int n) +{ return soap_instantiate_sai__AclStringType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AclStringType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_sai__AclStringType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__AclStringType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__AclStringType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AclStringType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cmn__GuidBuf(struct soap *soap, xsd__base64Binary const*a) +{ a->soap_serialize(soap); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__GuidBuf(struct soap *soap, xsd__base64Binary *a) +{ a->xsd__base64Binary::soap_default(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__GuidBuf(struct soap *soap, const xsd__base64Binary *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, (struct soap_array*)&a->__ptr, 1, tag, SOAP_TYPE_cmn__GuidBuf); + if (soap_out_cmn__GuidBuf(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__GuidBuf(struct soap *soap, const char *tag, int id, const xsd__base64Binary *a, const char *type) +{ + id = soap_attachment(soap, tag, id, a, (struct soap_array*)&a->__ptr, a->id, a->type, a->options, 1, type, SOAP_TYPE_cmn__GuidBuf); + if (id < 0) + return soap->error; + soap_element_begin_out(soap, tag, id, type); + soap_putbase64(soap, a->__ptr, a->__size); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_cmn__GuidBuf(struct soap *soap, xsd__base64Binary *p, const char *tag, const char *type) +{ + if ((p = soap_in_cmn__GuidBuf(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_cmn__GuidBuf(struct soap *soap, const char *tag, xsd__base64Binary *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":base64Binary") && soap_match_tag(soap, soap->type, ":base64")) + { soap->error = SOAP_TYPE; + return NULL; + } + a = (xsd__base64Binary *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cmn__GuidBuf, sizeof(xsd__base64Binary), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + a->soap_default(soap); + if (soap->body && !*soap->href) + { + a->__ptr = soap_getbase64(soap, &a->__size, 0); + if (soap_xop_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + if ((!a->__ptr && soap->error) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { if (*soap->href != '#') + { if (soap_dime_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + } + else + a = (xsd__base64Binary *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cmn__GuidBuf, 0, sizeof(xsd__base64Binary), 0, soap_copy_cmn__GuidBuf); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_cmn__GuidBuf(struct soap *soap, int n) +{ return soap_instantiate_cmn__GuidBuf(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__GuidBuf(struct soap *soap, xsd__base64Binary *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_cmn__GuidBuf(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cmn__GuidBuf(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cmn__GuidBuf, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xsd__base64Binary; + if (size) + *size = sizeof(xsd__base64Binary); + ((xsd__base64Binary*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xsd__base64Binary[n]; + if (size) + *size = n * sizeof(xsd__base64Binary); + for (int i = 0; i < n; i++) + ((xsd__base64Binary*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xsd__base64Binary*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__GuidBuf(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xsd__base64Binary %p -> %p\n", q, p)); + *(xsd__base64Binary*)p = *(xsd__base64Binary*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cmn__IPv6AddressStringType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__IPv6AddressStringType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__IPv6AddressStringType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cmn__IPv6AddressStringType); + if (soap_out_cmn__IPv6AddressStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__IPv6AddressStringType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_cmn__IPv6AddressStringType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cmn__IPv6AddressStringType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_cmn__IPv6AddressStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_cmn__IPv6AddressStringType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cmn__IPv6AddressStringType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, -1))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cmn__IPv6AddressStringType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_cmn__IPv6AddressStringType, 0, sizeof(std::string), 0, soap_copy_cmn__IPv6AddressStringType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cmn__IPv6AddressStringType(struct soap *soap, int n) +{ return soap_instantiate_cmn__IPv6AddressStringType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__IPv6AddressStringType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cmn__IPv6AddressStringType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cmn__IPv6AddressStringType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cmn__IPv6AddressStringType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__IPv6AddressStringType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cmn__IPv4AddressStringType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__IPv4AddressStringType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__IPv4AddressStringType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cmn__IPv4AddressStringType); + if (soap_out_cmn__IPv4AddressStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__IPv4AddressStringType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_cmn__IPv4AddressStringType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cmn__IPv4AddressStringType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_cmn__IPv4AddressStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_cmn__IPv4AddressStringType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cmn__IPv4AddressStringType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, -1))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cmn__IPv4AddressStringType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_cmn__IPv4AddressStringType, 0, sizeof(std::string), 0, soap_copy_cmn__IPv4AddressStringType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cmn__IPv4AddressStringType(struct soap *soap, int n) +{ return soap_instantiate_cmn__IPv4AddressStringType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__IPv4AddressStringType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cmn__IPv4AddressStringType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cmn__IPv4AddressStringType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cmn__IPv4AddressStringType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__IPv4AddressStringType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_cmn__HostNameType(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_cmn__HostNameType(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_cmn__HostNameType(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_cmn__HostNameType); + if (soap_out_cmn__HostNameType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__HostNameType(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_cmn__HostNameType), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_cmn__HostNameType(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_cmn__HostNameType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_cmn__HostNameType(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cmn__HostNameType, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, 0, 64))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_cmn__HostNameType, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_cmn__HostNameType, 0, sizeof(std::string), 0, soap_copy_cmn__HostNameType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_cmn__HostNameType(struct soap *soap, int n) +{ return soap_instantiate_cmn__HostNameType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__HostNameType(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_cmn__HostNameType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cmn__HostNameType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cmn__HostNameType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__HostNameType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +void _wcxs__GetWirelessSettingsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTowcxs__WirelessSettingsType(soap, &((_wcxs__GetWirelessSettingsResponse*)this)->WirelessSettings); + /* transient soap skipped */ +} + +void _wcxs__GetWirelessSettingsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_wcxs__GetWirelessSettingsResponse*)this)->Status); + ((_wcxs__GetWirelessSettingsResponse*)this)->WirelessSettings = NULL; + /* transient soap skipped */ +} + +int _wcxs__GetWirelessSettingsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__GetWirelessSettingsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__GetWirelessSettingsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__GetWirelessSettingsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessSettingsResponse(struct soap *soap, const char *tag, int id, const _wcxs__GetWirelessSettingsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__GetWirelessSettingsResponse), type); + soap_element_result(soap, "wcxs:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "wcxs:Status", -1, &(((_wcxs__GetWirelessSettingsResponse*)a)->Status), ""); + soap_out_PointerTowcxs__WirelessSettingsType(soap, "wcxs:WirelessSettings", -1, &(((_wcxs__GetWirelessSettingsResponse*)a)->WirelessSettings), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__GetWirelessSettingsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__GetWirelessSettingsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse * SOAP_FMAC4 soap_get__wcxs__GetWirelessSettingsResponse(struct soap *soap, _wcxs__GetWirelessSettingsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__GetWirelessSettingsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__GetWirelessSettingsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__GetWirelessSettingsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse * SOAP_FMAC4 soap_in__wcxs__GetWirelessSettingsResponse(struct soap *soap, const char *tag, _wcxs__GetWirelessSettingsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__GetWirelessSettingsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__GetWirelessSettingsResponse, sizeof(_wcxs__GetWirelessSettingsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__GetWirelessSettingsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__GetWirelessSettingsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_WirelessSettings1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "wcxs:Status", &(((_wcxs__GetWirelessSettingsResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_WirelessSettings1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTowcxs__WirelessSettingsType(soap, "wcxs:WirelessSettings", &(((_wcxs__GetWirelessSettingsResponse*)a)->WirelessSettings), "wcxs:WirelessSettingsType")) + { soap_flag_WirelessSettings1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "wcxs:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_WirelessSettings1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__GetWirelessSettingsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__GetWirelessSettingsResponse, 0, sizeof(_wcxs__GetWirelessSettingsResponse), 0, soap_copy__wcxs__GetWirelessSettingsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__GetWirelessSettingsResponse * SOAP_FMAC6 soap_new__wcxs__GetWirelessSettingsResponse(struct soap *soap, int n) +{ return soap_instantiate__wcxs__GetWirelessSettingsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessSettingsResponse(struct soap *soap, _wcxs__GetWirelessSettingsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessSettingsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__GetWirelessSettingsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__GetWirelessSettingsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__GetWirelessSettingsResponse; + if (size) + *size = sizeof(_wcxs__GetWirelessSettingsResponse); + ((_wcxs__GetWirelessSettingsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__GetWirelessSettingsResponse[n]; + if (size) + *size = n * sizeof(_wcxs__GetWirelessSettingsResponse); + for (int i = 0; i < n; i++) + ((_wcxs__GetWirelessSettingsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__GetWirelessSettingsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessSettingsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__GetWirelessSettingsResponse %p -> %p\n", q, p)); + *(_wcxs__GetWirelessSettingsResponse*)p = *(_wcxs__GetWirelessSettingsResponse*)q; +} + +void _wcxs__GetWirelessSettingsRequest::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _wcxs__GetWirelessSettingsRequest::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _wcxs__GetWirelessSettingsRequest::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__GetWirelessSettingsRequest); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__GetWirelessSettingsRequest::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__GetWirelessSettingsRequest(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessSettingsRequest(struct soap *soap, const char *tag, int id, const _wcxs__GetWirelessSettingsRequest *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__GetWirelessSettingsRequest), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__GetWirelessSettingsRequest::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__GetWirelessSettingsRequest(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest * SOAP_FMAC4 soap_get__wcxs__GetWirelessSettingsRequest(struct soap *soap, _wcxs__GetWirelessSettingsRequest *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__GetWirelessSettingsRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__GetWirelessSettingsRequest::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__GetWirelessSettingsRequest(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest * SOAP_FMAC4 soap_in__wcxs__GetWirelessSettingsRequest(struct soap *soap, const char *tag, _wcxs__GetWirelessSettingsRequest *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__GetWirelessSettingsRequest *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__GetWirelessSettingsRequest, sizeof(_wcxs__GetWirelessSettingsRequest), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__GetWirelessSettingsRequest) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__GetWirelessSettingsRequest *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__GetWirelessSettingsRequest *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__GetWirelessSettingsRequest, 0, sizeof(_wcxs__GetWirelessSettingsRequest), 0, soap_copy__wcxs__GetWirelessSettingsRequest); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__GetWirelessSettingsRequest * SOAP_FMAC6 soap_new__wcxs__GetWirelessSettingsRequest(struct soap *soap, int n) +{ return soap_instantiate__wcxs__GetWirelessSettingsRequest(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessSettingsRequest(struct soap *soap, _wcxs__GetWirelessSettingsRequest *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessSettingsRequest(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__GetWirelessSettingsRequest(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__GetWirelessSettingsRequest, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__GetWirelessSettingsRequest; + if (size) + *size = sizeof(_wcxs__GetWirelessSettingsRequest); + ((_wcxs__GetWirelessSettingsRequest*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__GetWirelessSettingsRequest[n]; + if (size) + *size = n * sizeof(_wcxs__GetWirelessSettingsRequest); + for (int i = 0; i < n; i++) + ((_wcxs__GetWirelessSettingsRequest*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__GetWirelessSettingsRequest*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessSettingsRequest(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__GetWirelessSettingsRequest %p -> %p\n", q, p)); + *(_wcxs__GetWirelessSettingsRequest*)p = *(_wcxs__GetWirelessSettingsRequest*)q; +} + +void _wcxs__GetWirelessCapabilitiesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTowcxs__WirelessCapabilitiesType(soap, &((_wcxs__GetWirelessCapabilitiesResponse*)this)->WirelessCapabilities); + /* transient soap skipped */ +} + +void _wcxs__GetWirelessCapabilitiesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_wcxs__GetWirelessCapabilitiesResponse*)this)->Status); + ((_wcxs__GetWirelessCapabilitiesResponse*)this)->WirelessCapabilities = NULL; + /* transient soap skipped */ +} + +int _wcxs__GetWirelessCapabilitiesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__GetWirelessCapabilitiesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__GetWirelessCapabilitiesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, const char *tag, int id, const _wcxs__GetWirelessCapabilitiesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse), type); + soap_element_result(soap, "wcxs:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "wcxs:Status", -1, &(((_wcxs__GetWirelessCapabilitiesResponse*)a)->Status), ""); + soap_out_PointerTowcxs__WirelessCapabilitiesType(soap, "wcxs:WirelessCapabilities", -1, &(((_wcxs__GetWirelessCapabilitiesResponse*)a)->WirelessCapabilities), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__GetWirelessCapabilitiesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__GetWirelessCapabilitiesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse * SOAP_FMAC4 soap_get__wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, _wcxs__GetWirelessCapabilitiesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__GetWirelessCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__GetWirelessCapabilitiesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__GetWirelessCapabilitiesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse * SOAP_FMAC4 soap_in__wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, const char *tag, _wcxs__GetWirelessCapabilitiesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__GetWirelessCapabilitiesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse, sizeof(_wcxs__GetWirelessCapabilitiesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__GetWirelessCapabilitiesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_WirelessCapabilities1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "wcxs:Status", &(((_wcxs__GetWirelessCapabilitiesResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_WirelessCapabilities1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTowcxs__WirelessCapabilitiesType(soap, "wcxs:WirelessCapabilities", &(((_wcxs__GetWirelessCapabilitiesResponse*)a)->WirelessCapabilities), "wcxs:WirelessCapabilitiesType")) + { soap_flag_WirelessCapabilities1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "wcxs:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_WirelessCapabilities1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__GetWirelessCapabilitiesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse, 0, sizeof(_wcxs__GetWirelessCapabilitiesResponse), 0, soap_copy__wcxs__GetWirelessCapabilitiesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__GetWirelessCapabilitiesResponse * SOAP_FMAC6 soap_new__wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, int n) +{ return soap_instantiate__wcxs__GetWirelessCapabilitiesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, _wcxs__GetWirelessCapabilitiesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__GetWirelessCapabilitiesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__GetWirelessCapabilitiesResponse; + if (size) + *size = sizeof(_wcxs__GetWirelessCapabilitiesResponse); + ((_wcxs__GetWirelessCapabilitiesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__GetWirelessCapabilitiesResponse[n]; + if (size) + *size = n * sizeof(_wcxs__GetWirelessCapabilitiesResponse); + for (int i = 0; i < n; i++) + ((_wcxs__GetWirelessCapabilitiesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__GetWirelessCapabilitiesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__GetWirelessCapabilitiesResponse %p -> %p\n", q, p)); + *(_wcxs__GetWirelessCapabilitiesResponse*)p = *(_wcxs__GetWirelessCapabilitiesResponse*)q; +} + +void _wcxs__GetWirelessCapabilitiesRequest::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _wcxs__GetWirelessCapabilitiesRequest::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _wcxs__GetWirelessCapabilitiesRequest::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__GetWirelessCapabilitiesRequest::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__GetWirelessCapabilitiesRequest(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, const char *tag, int id, const _wcxs__GetWirelessCapabilitiesRequest *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__GetWirelessCapabilitiesRequest::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__GetWirelessCapabilitiesRequest(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest * SOAP_FMAC4 soap_get__wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, _wcxs__GetWirelessCapabilitiesRequest *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__GetWirelessCapabilitiesRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__GetWirelessCapabilitiesRequest::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__GetWirelessCapabilitiesRequest(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest * SOAP_FMAC4 soap_in__wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, const char *tag, _wcxs__GetWirelessCapabilitiesRequest *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__GetWirelessCapabilitiesRequest *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest, sizeof(_wcxs__GetWirelessCapabilitiesRequest), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__GetWirelessCapabilitiesRequest *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__GetWirelessCapabilitiesRequest *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest, 0, sizeof(_wcxs__GetWirelessCapabilitiesRequest), 0, soap_copy__wcxs__GetWirelessCapabilitiesRequest); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__GetWirelessCapabilitiesRequest * SOAP_FMAC6 soap_new__wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, int n) +{ return soap_instantiate__wcxs__GetWirelessCapabilitiesRequest(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, _wcxs__GetWirelessCapabilitiesRequest *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__GetWirelessCapabilitiesRequest(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__GetWirelessCapabilitiesRequest; + if (size) + *size = sizeof(_wcxs__GetWirelessCapabilitiesRequest); + ((_wcxs__GetWirelessCapabilitiesRequest*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__GetWirelessCapabilitiesRequest[n]; + if (size) + *size = n * sizeof(_wcxs__GetWirelessCapabilitiesRequest); + for (int i = 0; i < n; i++) + ((_wcxs__GetWirelessCapabilitiesRequest*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__GetWirelessCapabilitiesRequest*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__GetWirelessCapabilitiesRequest %p -> %p\n", q, p)); + *(_wcxs__GetWirelessCapabilitiesRequest*)p = *(_wcxs__GetWirelessCapabilitiesRequest*)q; +} + +void _wcxs__EnumerateWirelessProfilesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfwcxs__ProfileNameType(soap, &((_wcxs__EnumerateWirelessProfilesResponse*)this)->ProfilesNames); + /* transient soap skipped */ +} + +void _wcxs__EnumerateWirelessProfilesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_wcxs__EnumerateWirelessProfilesResponse*)this)->Status); + soap_default_std__vectorTemplateOfwcxs__ProfileNameType(soap, &((_wcxs__EnumerateWirelessProfilesResponse*)this)->ProfilesNames); + /* transient soap skipped */ +} + +int _wcxs__EnumerateWirelessProfilesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__EnumerateWirelessProfilesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__EnumerateWirelessProfilesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, const char *tag, int id, const _wcxs__EnumerateWirelessProfilesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse), type); + soap_element_result(soap, "wcxs:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "wcxs:Status", -1, &(((_wcxs__EnumerateWirelessProfilesResponse*)a)->Status), ""); + soap_out_std__vectorTemplateOfwcxs__ProfileNameType(soap, "wcxs:ProfilesNames", -1, &(((_wcxs__EnumerateWirelessProfilesResponse*)a)->ProfilesNames), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__EnumerateWirelessProfilesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__EnumerateWirelessProfilesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse * SOAP_FMAC4 soap_get__wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, _wcxs__EnumerateWirelessProfilesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__EnumerateWirelessProfilesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__EnumerateWirelessProfilesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__EnumerateWirelessProfilesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse * SOAP_FMAC4 soap_in__wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, const char *tag, _wcxs__EnumerateWirelessProfilesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__EnumerateWirelessProfilesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse, sizeof(_wcxs__EnumerateWirelessProfilesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__EnumerateWirelessProfilesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "wcxs:Status", &(((_wcxs__EnumerateWirelessProfilesResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfwcxs__ProfileNameType(soap, "wcxs:ProfilesNames", &(((_wcxs__EnumerateWirelessProfilesResponse*)a)->ProfilesNames), "wcxs:ProfileNameType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "wcxs:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || ((_wcxs__EnumerateWirelessProfilesResponse*)a)->ProfilesNames.size() > 64)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__EnumerateWirelessProfilesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse, 0, sizeof(_wcxs__EnumerateWirelessProfilesResponse), 0, soap_copy__wcxs__EnumerateWirelessProfilesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__EnumerateWirelessProfilesResponse * SOAP_FMAC6 soap_new__wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, int n) +{ return soap_instantiate__wcxs__EnumerateWirelessProfilesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, _wcxs__EnumerateWirelessProfilesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse * SOAP_FMAC4 soap_instantiate__wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__EnumerateWirelessProfilesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__EnumerateWirelessProfilesResponse; + if (size) + *size = sizeof(_wcxs__EnumerateWirelessProfilesResponse); + ((_wcxs__EnumerateWirelessProfilesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__EnumerateWirelessProfilesResponse[n]; + if (size) + *size = n * sizeof(_wcxs__EnumerateWirelessProfilesResponse); + for (int i = 0; i < n; i++) + ((_wcxs__EnumerateWirelessProfilesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__EnumerateWirelessProfilesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__EnumerateWirelessProfilesResponse %p -> %p\n", q, p)); + *(_wcxs__EnumerateWirelessProfilesResponse*)p = *(_wcxs__EnumerateWirelessProfilesResponse*)q; +} + +void _wcxs__EnumerateWirelessProfilesRequest::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _wcxs__EnumerateWirelessProfilesRequest::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _wcxs__EnumerateWirelessProfilesRequest::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__EnumerateWirelessProfilesRequest::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__EnumerateWirelessProfilesRequest(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, const char *tag, int id, const _wcxs__EnumerateWirelessProfilesRequest *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__EnumerateWirelessProfilesRequest::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__EnumerateWirelessProfilesRequest(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest * SOAP_FMAC4 soap_get__wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, _wcxs__EnumerateWirelessProfilesRequest *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__EnumerateWirelessProfilesRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__EnumerateWirelessProfilesRequest::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__EnumerateWirelessProfilesRequest(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest * SOAP_FMAC4 soap_in__wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, const char *tag, _wcxs__EnumerateWirelessProfilesRequest *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__EnumerateWirelessProfilesRequest *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest, sizeof(_wcxs__EnumerateWirelessProfilesRequest), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__EnumerateWirelessProfilesRequest *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__EnumerateWirelessProfilesRequest *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest, 0, sizeof(_wcxs__EnumerateWirelessProfilesRequest), 0, soap_copy__wcxs__EnumerateWirelessProfilesRequest); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__EnumerateWirelessProfilesRequest * SOAP_FMAC6 soap_new__wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, int n) +{ return soap_instantiate__wcxs__EnumerateWirelessProfilesRequest(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, _wcxs__EnumerateWirelessProfilesRequest *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest * SOAP_FMAC4 soap_instantiate__wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__EnumerateWirelessProfilesRequest(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__EnumerateWirelessProfilesRequest; + if (size) + *size = sizeof(_wcxs__EnumerateWirelessProfilesRequest); + ((_wcxs__EnumerateWirelessProfilesRequest*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__EnumerateWirelessProfilesRequest[n]; + if (size) + *size = n * sizeof(_wcxs__EnumerateWirelessProfilesRequest); + for (int i = 0; i < n; i++) + ((_wcxs__EnumerateWirelessProfilesRequest*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__EnumerateWirelessProfilesRequest*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__EnumerateWirelessProfilesRequest %p -> %p\n", q, p)); + *(_wcxs__EnumerateWirelessProfilesRequest*)p = *(_wcxs__EnumerateWirelessProfilesRequest*)q; +} + +void _wcxs__UpdateWirelessProfileResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _wcxs__UpdateWirelessProfileResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_wcxs__UpdateWirelessProfileResponse*)this)->Status); + /* transient soap skipped */ +} + +int _wcxs__UpdateWirelessProfileResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__UpdateWirelessProfileResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__UpdateWirelessProfileResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__UpdateWirelessProfileResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__UpdateWirelessProfileResponse(struct soap *soap, const char *tag, int id, const _wcxs__UpdateWirelessProfileResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__UpdateWirelessProfileResponse), type); + soap_element_result(soap, "wcxs:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "wcxs:Status", -1, &(((_wcxs__UpdateWirelessProfileResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__UpdateWirelessProfileResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__UpdateWirelessProfileResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse * SOAP_FMAC4 soap_get__wcxs__UpdateWirelessProfileResponse(struct soap *soap, _wcxs__UpdateWirelessProfileResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__UpdateWirelessProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__UpdateWirelessProfileResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__UpdateWirelessProfileResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse * SOAP_FMAC4 soap_in__wcxs__UpdateWirelessProfileResponse(struct soap *soap, const char *tag, _wcxs__UpdateWirelessProfileResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__UpdateWirelessProfileResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__UpdateWirelessProfileResponse, sizeof(_wcxs__UpdateWirelessProfileResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__UpdateWirelessProfileResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__UpdateWirelessProfileResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "wcxs:Status", &(((_wcxs__UpdateWirelessProfileResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "wcxs:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__UpdateWirelessProfileResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__UpdateWirelessProfileResponse, 0, sizeof(_wcxs__UpdateWirelessProfileResponse), 0, soap_copy__wcxs__UpdateWirelessProfileResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__UpdateWirelessProfileResponse * SOAP_FMAC6 soap_new__wcxs__UpdateWirelessProfileResponse(struct soap *soap, int n) +{ return soap_instantiate__wcxs__UpdateWirelessProfileResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__UpdateWirelessProfileResponse(struct soap *soap, _wcxs__UpdateWirelessProfileResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse * SOAP_FMAC4 soap_instantiate__wcxs__UpdateWirelessProfileResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__UpdateWirelessProfileResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__UpdateWirelessProfileResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__UpdateWirelessProfileResponse; + if (size) + *size = sizeof(_wcxs__UpdateWirelessProfileResponse); + ((_wcxs__UpdateWirelessProfileResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__UpdateWirelessProfileResponse[n]; + if (size) + *size = n * sizeof(_wcxs__UpdateWirelessProfileResponse); + for (int i = 0; i < n; i++) + ((_wcxs__UpdateWirelessProfileResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__UpdateWirelessProfileResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__UpdateWirelessProfileResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__UpdateWirelessProfileResponse %p -> %p\n", q, p)); + *(_wcxs__UpdateWirelessProfileResponse*)p = *(_wcxs__UpdateWirelessProfileResponse*)q; +} + +void _wcxs__UpdateWirelessProfileRequest::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTowcxs__ProfileType(soap, &((_wcxs__UpdateWirelessProfileRequest*)this)->Profile); + /* transient soap skipped */ +} + +void _wcxs__UpdateWirelessProfileRequest::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_wcxs__UpdateWirelessProfileRequest*)this)->Profile = NULL; + /* transient soap skipped */ +} + +int _wcxs__UpdateWirelessProfileRequest::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__UpdateWirelessProfileRequest); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__UpdateWirelessProfileRequest::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__UpdateWirelessProfileRequest(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__UpdateWirelessProfileRequest(struct soap *soap, const char *tag, int id, const _wcxs__UpdateWirelessProfileRequest *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__UpdateWirelessProfileRequest), type); + soap_out_PointerTowcxs__ProfileType(soap, "wcxs:Profile", -1, &(((_wcxs__UpdateWirelessProfileRequest*)a)->Profile), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__UpdateWirelessProfileRequest::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__UpdateWirelessProfileRequest(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest * SOAP_FMAC4 soap_get__wcxs__UpdateWirelessProfileRequest(struct soap *soap, _wcxs__UpdateWirelessProfileRequest *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__UpdateWirelessProfileRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__UpdateWirelessProfileRequest::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__UpdateWirelessProfileRequest(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest * SOAP_FMAC4 soap_in__wcxs__UpdateWirelessProfileRequest(struct soap *soap, const char *tag, _wcxs__UpdateWirelessProfileRequest *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__UpdateWirelessProfileRequest *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__UpdateWirelessProfileRequest, sizeof(_wcxs__UpdateWirelessProfileRequest), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__UpdateWirelessProfileRequest) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__UpdateWirelessProfileRequest *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Profile1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Profile1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTowcxs__ProfileType(soap, "wcxs:Profile", &(((_wcxs__UpdateWirelessProfileRequest*)a)->Profile), "wcxs:ProfileType")) + { soap_flag_Profile1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Profile1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__UpdateWirelessProfileRequest *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__UpdateWirelessProfileRequest, 0, sizeof(_wcxs__UpdateWirelessProfileRequest), 0, soap_copy__wcxs__UpdateWirelessProfileRequest); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__UpdateWirelessProfileRequest * SOAP_FMAC6 soap_new__wcxs__UpdateWirelessProfileRequest(struct soap *soap, int n) +{ return soap_instantiate__wcxs__UpdateWirelessProfileRequest(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__UpdateWirelessProfileRequest(struct soap *soap, _wcxs__UpdateWirelessProfileRequest *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest * SOAP_FMAC4 soap_instantiate__wcxs__UpdateWirelessProfileRequest(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__UpdateWirelessProfileRequest(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__UpdateWirelessProfileRequest, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__UpdateWirelessProfileRequest; + if (size) + *size = sizeof(_wcxs__UpdateWirelessProfileRequest); + ((_wcxs__UpdateWirelessProfileRequest*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__UpdateWirelessProfileRequest[n]; + if (size) + *size = n * sizeof(_wcxs__UpdateWirelessProfileRequest); + for (int i = 0; i < n; i++) + ((_wcxs__UpdateWirelessProfileRequest*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__UpdateWirelessProfileRequest*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__UpdateWirelessProfileRequest(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__UpdateWirelessProfileRequest %p -> %p\n", q, p)); + *(_wcxs__UpdateWirelessProfileRequest*)p = *(_wcxs__UpdateWirelessProfileRequest*)q; +} + +void _wcxs__RemoveWirelessProfileResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _wcxs__RemoveWirelessProfileResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_wcxs__RemoveWirelessProfileResponse*)this)->Status); + /* transient soap skipped */ +} + +int _wcxs__RemoveWirelessProfileResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__RemoveWirelessProfileResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__RemoveWirelessProfileResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__RemoveWirelessProfileResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__RemoveWirelessProfileResponse(struct soap *soap, const char *tag, int id, const _wcxs__RemoveWirelessProfileResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__RemoveWirelessProfileResponse), type); + soap_element_result(soap, "wcxs:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "wcxs:Status", -1, &(((_wcxs__RemoveWirelessProfileResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__RemoveWirelessProfileResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__RemoveWirelessProfileResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse * SOAP_FMAC4 soap_get__wcxs__RemoveWirelessProfileResponse(struct soap *soap, _wcxs__RemoveWirelessProfileResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__RemoveWirelessProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__RemoveWirelessProfileResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__RemoveWirelessProfileResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse * SOAP_FMAC4 soap_in__wcxs__RemoveWirelessProfileResponse(struct soap *soap, const char *tag, _wcxs__RemoveWirelessProfileResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__RemoveWirelessProfileResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__RemoveWirelessProfileResponse, sizeof(_wcxs__RemoveWirelessProfileResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__RemoveWirelessProfileResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__RemoveWirelessProfileResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "wcxs:Status", &(((_wcxs__RemoveWirelessProfileResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "wcxs:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__RemoveWirelessProfileResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__RemoveWirelessProfileResponse, 0, sizeof(_wcxs__RemoveWirelessProfileResponse), 0, soap_copy__wcxs__RemoveWirelessProfileResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__RemoveWirelessProfileResponse * SOAP_FMAC6 soap_new__wcxs__RemoveWirelessProfileResponse(struct soap *soap, int n) +{ return soap_instantiate__wcxs__RemoveWirelessProfileResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__RemoveWirelessProfileResponse(struct soap *soap, _wcxs__RemoveWirelessProfileResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse * SOAP_FMAC4 soap_instantiate__wcxs__RemoveWirelessProfileResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__RemoveWirelessProfileResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__RemoveWirelessProfileResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__RemoveWirelessProfileResponse; + if (size) + *size = sizeof(_wcxs__RemoveWirelessProfileResponse); + ((_wcxs__RemoveWirelessProfileResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__RemoveWirelessProfileResponse[n]; + if (size) + *size = n * sizeof(_wcxs__RemoveWirelessProfileResponse); + for (int i = 0; i < n; i++) + ((_wcxs__RemoveWirelessProfileResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__RemoveWirelessProfileResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__RemoveWirelessProfileResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__RemoveWirelessProfileResponse %p -> %p\n", q, p)); + *(_wcxs__RemoveWirelessProfileResponse*)p = *(_wcxs__RemoveWirelessProfileResponse*)q; +} + +void _wcxs__RemoveWirelessProfileRequest::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_wcxs__ProfileNameType(soap, &((_wcxs__RemoveWirelessProfileRequest*)this)->ProfileName); + /* transient soap skipped */ +} + +void _wcxs__RemoveWirelessProfileRequest::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_wcxs__ProfileNameType(soap, &((_wcxs__RemoveWirelessProfileRequest*)this)->ProfileName); + /* transient soap skipped */ +} + +int _wcxs__RemoveWirelessProfileRequest::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__RemoveWirelessProfileRequest); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__RemoveWirelessProfileRequest::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__RemoveWirelessProfileRequest(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__RemoveWirelessProfileRequest(struct soap *soap, const char *tag, int id, const _wcxs__RemoveWirelessProfileRequest *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__RemoveWirelessProfileRequest), type); + soap_out_wcxs__ProfileNameType(soap, "wcxs:ProfileName", -1, &(((_wcxs__RemoveWirelessProfileRequest*)a)->ProfileName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__RemoveWirelessProfileRequest::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__RemoveWirelessProfileRequest(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest * SOAP_FMAC4 soap_get__wcxs__RemoveWirelessProfileRequest(struct soap *soap, _wcxs__RemoveWirelessProfileRequest *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__RemoveWirelessProfileRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__RemoveWirelessProfileRequest::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__RemoveWirelessProfileRequest(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest * SOAP_FMAC4 soap_in__wcxs__RemoveWirelessProfileRequest(struct soap *soap, const char *tag, _wcxs__RemoveWirelessProfileRequest *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__RemoveWirelessProfileRequest *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__RemoveWirelessProfileRequest, sizeof(_wcxs__RemoveWirelessProfileRequest), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__RemoveWirelessProfileRequest) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__RemoveWirelessProfileRequest *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ProfileName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ProfileName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_wcxs__ProfileNameType(soap, "wcxs:ProfileName", &(((_wcxs__RemoveWirelessProfileRequest*)a)->ProfileName), "wcxs:ProfileNameType")) + { soap_flag_ProfileName1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ProfileName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__RemoveWirelessProfileRequest *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__RemoveWirelessProfileRequest, 0, sizeof(_wcxs__RemoveWirelessProfileRequest), 0, soap_copy__wcxs__RemoveWirelessProfileRequest); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__RemoveWirelessProfileRequest * SOAP_FMAC6 soap_new__wcxs__RemoveWirelessProfileRequest(struct soap *soap, int n) +{ return soap_instantiate__wcxs__RemoveWirelessProfileRequest(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__RemoveWirelessProfileRequest(struct soap *soap, _wcxs__RemoveWirelessProfileRequest *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest * SOAP_FMAC4 soap_instantiate__wcxs__RemoveWirelessProfileRequest(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__RemoveWirelessProfileRequest(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__RemoveWirelessProfileRequest, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__RemoveWirelessProfileRequest; + if (size) + *size = sizeof(_wcxs__RemoveWirelessProfileRequest); + ((_wcxs__RemoveWirelessProfileRequest*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__RemoveWirelessProfileRequest[n]; + if (size) + *size = n * sizeof(_wcxs__RemoveWirelessProfileRequest); + for (int i = 0; i < n; i++) + ((_wcxs__RemoveWirelessProfileRequest*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__RemoveWirelessProfileRequest*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__RemoveWirelessProfileRequest(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__RemoveWirelessProfileRequest %p -> %p\n", q, p)); + *(_wcxs__RemoveWirelessProfileRequest*)p = *(_wcxs__RemoveWirelessProfileRequest*)q; +} + +void _wcxs__GetWirelessProfileResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTowcxs__ProfileType(soap, &((_wcxs__GetWirelessProfileResponse*)this)->Profile); + /* transient soap skipped */ +} + +void _wcxs__GetWirelessProfileResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_wcxs__GetWirelessProfileResponse*)this)->Status); + ((_wcxs__GetWirelessProfileResponse*)this)->Profile = NULL; + /* transient soap skipped */ +} + +int _wcxs__GetWirelessProfileResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__GetWirelessProfileResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__GetWirelessProfileResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__GetWirelessProfileResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessProfileResponse(struct soap *soap, const char *tag, int id, const _wcxs__GetWirelessProfileResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__GetWirelessProfileResponse), type); + soap_element_result(soap, "wcxs:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "wcxs:Status", -1, &(((_wcxs__GetWirelessProfileResponse*)a)->Status), ""); + soap_out_PointerTowcxs__ProfileType(soap, "wcxs:Profile", -1, &(((_wcxs__GetWirelessProfileResponse*)a)->Profile), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__GetWirelessProfileResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__GetWirelessProfileResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse * SOAP_FMAC4 soap_get__wcxs__GetWirelessProfileResponse(struct soap *soap, _wcxs__GetWirelessProfileResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__GetWirelessProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__GetWirelessProfileResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__GetWirelessProfileResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse * SOAP_FMAC4 soap_in__wcxs__GetWirelessProfileResponse(struct soap *soap, const char *tag, _wcxs__GetWirelessProfileResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__GetWirelessProfileResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__GetWirelessProfileResponse, sizeof(_wcxs__GetWirelessProfileResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__GetWirelessProfileResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__GetWirelessProfileResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Profile1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "wcxs:Status", &(((_wcxs__GetWirelessProfileResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Profile1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTowcxs__ProfileType(soap, "wcxs:Profile", &(((_wcxs__GetWirelessProfileResponse*)a)->Profile), "wcxs:ProfileType")) + { soap_flag_Profile1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "wcxs:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Profile1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__GetWirelessProfileResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__GetWirelessProfileResponse, 0, sizeof(_wcxs__GetWirelessProfileResponse), 0, soap_copy__wcxs__GetWirelessProfileResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__GetWirelessProfileResponse * SOAP_FMAC6 soap_new__wcxs__GetWirelessProfileResponse(struct soap *soap, int n) +{ return soap_instantiate__wcxs__GetWirelessProfileResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessProfileResponse(struct soap *soap, _wcxs__GetWirelessProfileResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessProfileResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__GetWirelessProfileResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__GetWirelessProfileResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__GetWirelessProfileResponse; + if (size) + *size = sizeof(_wcxs__GetWirelessProfileResponse); + ((_wcxs__GetWirelessProfileResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__GetWirelessProfileResponse[n]; + if (size) + *size = n * sizeof(_wcxs__GetWirelessProfileResponse); + for (int i = 0; i < n; i++) + ((_wcxs__GetWirelessProfileResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__GetWirelessProfileResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessProfileResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__GetWirelessProfileResponse %p -> %p\n", q, p)); + *(_wcxs__GetWirelessProfileResponse*)p = *(_wcxs__GetWirelessProfileResponse*)q; +} + +void _wcxs__GetWirelessProfileRequest::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_wcxs__ProfileNameType(soap, &((_wcxs__GetWirelessProfileRequest*)this)->ProfileName); + /* transient soap skipped */ +} + +void _wcxs__GetWirelessProfileRequest::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_wcxs__ProfileNameType(soap, &((_wcxs__GetWirelessProfileRequest*)this)->ProfileName); + /* transient soap skipped */ +} + +int _wcxs__GetWirelessProfileRequest::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__GetWirelessProfileRequest); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__GetWirelessProfileRequest::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__GetWirelessProfileRequest(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__GetWirelessProfileRequest(struct soap *soap, const char *tag, int id, const _wcxs__GetWirelessProfileRequest *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__GetWirelessProfileRequest), type); + soap_out_wcxs__ProfileNameType(soap, "wcxs:ProfileName", -1, &(((_wcxs__GetWirelessProfileRequest*)a)->ProfileName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__GetWirelessProfileRequest::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__GetWirelessProfileRequest(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest * SOAP_FMAC4 soap_get__wcxs__GetWirelessProfileRequest(struct soap *soap, _wcxs__GetWirelessProfileRequest *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__GetWirelessProfileRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__GetWirelessProfileRequest::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__GetWirelessProfileRequest(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest * SOAP_FMAC4 soap_in__wcxs__GetWirelessProfileRequest(struct soap *soap, const char *tag, _wcxs__GetWirelessProfileRequest *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__GetWirelessProfileRequest *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__GetWirelessProfileRequest, sizeof(_wcxs__GetWirelessProfileRequest), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__GetWirelessProfileRequest) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__GetWirelessProfileRequest *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ProfileName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ProfileName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_wcxs__ProfileNameType(soap, "wcxs:ProfileName", &(((_wcxs__GetWirelessProfileRequest*)a)->ProfileName), "wcxs:ProfileNameType")) + { soap_flag_ProfileName1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ProfileName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__GetWirelessProfileRequest *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__GetWirelessProfileRequest, 0, sizeof(_wcxs__GetWirelessProfileRequest), 0, soap_copy__wcxs__GetWirelessProfileRequest); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__GetWirelessProfileRequest * SOAP_FMAC6 soap_new__wcxs__GetWirelessProfileRequest(struct soap *soap, int n) +{ return soap_instantiate__wcxs__GetWirelessProfileRequest(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__GetWirelessProfileRequest(struct soap *soap, _wcxs__GetWirelessProfileRequest *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest * SOAP_FMAC4 soap_instantiate__wcxs__GetWirelessProfileRequest(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__GetWirelessProfileRequest(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__GetWirelessProfileRequest, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__GetWirelessProfileRequest; + if (size) + *size = sizeof(_wcxs__GetWirelessProfileRequest); + ((_wcxs__GetWirelessProfileRequest*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__GetWirelessProfileRequest[n]; + if (size) + *size = n * sizeof(_wcxs__GetWirelessProfileRequest); + for (int i = 0; i < n; i++) + ((_wcxs__GetWirelessProfileRequest*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__GetWirelessProfileRequest*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__GetWirelessProfileRequest(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__GetWirelessProfileRequest %p -> %p\n", q, p)); + *(_wcxs__GetWirelessProfileRequest*)p = *(_wcxs__GetWirelessProfileRequest*)q; +} + +void _wcxs__AddWirelessProfileResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _wcxs__AddWirelessProfileResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_wcxs__AddWirelessProfileResponse*)this)->Status); + /* transient soap skipped */ +} + +int _wcxs__AddWirelessProfileResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__AddWirelessProfileResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__AddWirelessProfileResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__AddWirelessProfileResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__AddWirelessProfileResponse(struct soap *soap, const char *tag, int id, const _wcxs__AddWirelessProfileResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__AddWirelessProfileResponse), type); + soap_element_result(soap, "wcxs:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "wcxs:Status", -1, &(((_wcxs__AddWirelessProfileResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__AddWirelessProfileResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__AddWirelessProfileResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse * SOAP_FMAC4 soap_get__wcxs__AddWirelessProfileResponse(struct soap *soap, _wcxs__AddWirelessProfileResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__AddWirelessProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__AddWirelessProfileResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__AddWirelessProfileResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse * SOAP_FMAC4 soap_in__wcxs__AddWirelessProfileResponse(struct soap *soap, const char *tag, _wcxs__AddWirelessProfileResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__AddWirelessProfileResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__AddWirelessProfileResponse, sizeof(_wcxs__AddWirelessProfileResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__AddWirelessProfileResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__AddWirelessProfileResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "wcxs:Status", &(((_wcxs__AddWirelessProfileResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "wcxs:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__AddWirelessProfileResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__AddWirelessProfileResponse, 0, sizeof(_wcxs__AddWirelessProfileResponse), 0, soap_copy__wcxs__AddWirelessProfileResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__AddWirelessProfileResponse * SOAP_FMAC6 soap_new__wcxs__AddWirelessProfileResponse(struct soap *soap, int n) +{ return soap_instantiate__wcxs__AddWirelessProfileResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__AddWirelessProfileResponse(struct soap *soap, _wcxs__AddWirelessProfileResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse * SOAP_FMAC4 soap_instantiate__wcxs__AddWirelessProfileResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__AddWirelessProfileResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__AddWirelessProfileResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__AddWirelessProfileResponse; + if (size) + *size = sizeof(_wcxs__AddWirelessProfileResponse); + ((_wcxs__AddWirelessProfileResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__AddWirelessProfileResponse[n]; + if (size) + *size = n * sizeof(_wcxs__AddWirelessProfileResponse); + for (int i = 0; i < n; i++) + ((_wcxs__AddWirelessProfileResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__AddWirelessProfileResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__AddWirelessProfileResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__AddWirelessProfileResponse %p -> %p\n", q, p)); + *(_wcxs__AddWirelessProfileResponse*)p = *(_wcxs__AddWirelessProfileResponse*)q; +} + +void _wcxs__AddWirelessProfileRequest::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTowcxs__ProfileType(soap, &((_wcxs__AddWirelessProfileRequest*)this)->Profile); + /* transient soap skipped */ +} + +void _wcxs__AddWirelessProfileRequest::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_wcxs__AddWirelessProfileRequest*)this)->Profile = NULL; + /* transient soap skipped */ +} + +int _wcxs__AddWirelessProfileRequest::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__wcxs__AddWirelessProfileRequest); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _wcxs__AddWirelessProfileRequest::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__wcxs__AddWirelessProfileRequest(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__AddWirelessProfileRequest(struct soap *soap, const char *tag, int id, const _wcxs__AddWirelessProfileRequest *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__wcxs__AddWirelessProfileRequest), type); + soap_out_PointerTowcxs__ProfileType(soap, "wcxs:Profile", -1, &(((_wcxs__AddWirelessProfileRequest*)a)->Profile), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_wcxs__AddWirelessProfileRequest::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__wcxs__AddWirelessProfileRequest(soap, this, tag, type); +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest * SOAP_FMAC4 soap_get__wcxs__AddWirelessProfileRequest(struct soap *soap, _wcxs__AddWirelessProfileRequest *p, const char *tag, const char *type) +{ + if ((p = soap_in__wcxs__AddWirelessProfileRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_wcxs__AddWirelessProfileRequest::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__wcxs__AddWirelessProfileRequest(soap, tag, this, type); +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest * SOAP_FMAC4 soap_in__wcxs__AddWirelessProfileRequest(struct soap *soap, const char *tag, _wcxs__AddWirelessProfileRequest *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_wcxs__AddWirelessProfileRequest *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__wcxs__AddWirelessProfileRequest, sizeof(_wcxs__AddWirelessProfileRequest), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__wcxs__AddWirelessProfileRequest) + { soap_revert(soap); + *soap->id = '\0'; + return (_wcxs__AddWirelessProfileRequest *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Profile1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Profile1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTowcxs__ProfileType(soap, "wcxs:Profile", &(((_wcxs__AddWirelessProfileRequest*)a)->Profile), "wcxs:ProfileType")) + { soap_flag_Profile1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Profile1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_wcxs__AddWirelessProfileRequest *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__wcxs__AddWirelessProfileRequest, 0, sizeof(_wcxs__AddWirelessProfileRequest), 0, soap_copy__wcxs__AddWirelessProfileRequest); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _wcxs__AddWirelessProfileRequest * SOAP_FMAC6 soap_new__wcxs__AddWirelessProfileRequest(struct soap *soap, int n) +{ return soap_instantiate__wcxs__AddWirelessProfileRequest(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__wcxs__AddWirelessProfileRequest(struct soap *soap, _wcxs__AddWirelessProfileRequest *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest * SOAP_FMAC4 soap_instantiate__wcxs__AddWirelessProfileRequest(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__wcxs__AddWirelessProfileRequest(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__wcxs__AddWirelessProfileRequest, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _wcxs__AddWirelessProfileRequest; + if (size) + *size = sizeof(_wcxs__AddWirelessProfileRequest); + ((_wcxs__AddWirelessProfileRequest*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _wcxs__AddWirelessProfileRequest[n]; + if (size) + *size = n * sizeof(_wcxs__AddWirelessProfileRequest); + for (int i = 0; i < n; i++) + ((_wcxs__AddWirelessProfileRequest*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_wcxs__AddWirelessProfileRequest*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__wcxs__AddWirelessProfileRequest(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _wcxs__AddWirelessProfileRequest %p -> %p\n", q, p)); + *(_wcxs__AddWirelessProfileRequest*)p = *(_wcxs__AddWirelessProfileRequest*)q; +} + +void wcxs__WirelessSettingsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((wcxs__WirelessSettingsType*)this)->RadioOn, SOAP_TYPE_bool); + soap_serialize_PointerTostd__string(soap, &((wcxs__WirelessSettingsType*)this)->ActiveProfile); + /* transient soap skipped */ +} + +void wcxs__WirelessSettingsType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((wcxs__WirelessSettingsType*)this)->RadioOn); + ((wcxs__WirelessSettingsType*)this)->ActiveProfile = NULL; + /* transient soap skipped */ +} + +int wcxs__WirelessSettingsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__WirelessSettingsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__WirelessSettingsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__WirelessSettingsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__WirelessSettingsType(struct soap *soap, const char *tag, int id, const wcxs__WirelessSettingsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__WirelessSettingsType), type); + soap_out_bool(soap, "wcxs:RadioOn", -1, &(((wcxs__WirelessSettingsType*)a)->RadioOn), ""); + soap_out_PointerTostd__string(soap, "wcxs:ActiveProfile", -1, &(((wcxs__WirelessSettingsType*)a)->ActiveProfile), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__WirelessSettingsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__WirelessSettingsType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__WirelessSettingsType * SOAP_FMAC4 soap_get_wcxs__WirelessSettingsType(struct soap *soap, wcxs__WirelessSettingsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__WirelessSettingsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__WirelessSettingsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__WirelessSettingsType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__WirelessSettingsType * SOAP_FMAC4 soap_in_wcxs__WirelessSettingsType(struct soap *soap, const char *tag, wcxs__WirelessSettingsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__WirelessSettingsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__WirelessSettingsType, sizeof(wcxs__WirelessSettingsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__WirelessSettingsType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__WirelessSettingsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_RadioOn1 = 1, soap_flag_ActiveProfile1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_RadioOn1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "wcxs:RadioOn", &(((wcxs__WirelessSettingsType*)a)->RadioOn), "xsd:boolean")) + { soap_flag_RadioOn1--; + continue; + } + if (soap_flag_ActiveProfile1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "wcxs:ActiveProfile", &(((wcxs__WirelessSettingsType*)a)->ActiveProfile), "xsd:string")) + { soap_flag_ActiveProfile1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_RadioOn1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__WirelessSettingsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__WirelessSettingsType, 0, sizeof(wcxs__WirelessSettingsType), 0, soap_copy_wcxs__WirelessSettingsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__WirelessSettingsType * SOAP_FMAC6 soap_new_wcxs__WirelessSettingsType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__WirelessSettingsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__WirelessSettingsType(struct soap *soap, wcxs__WirelessSettingsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__WirelessSettingsType * SOAP_FMAC4 soap_instantiate_wcxs__WirelessSettingsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__WirelessSettingsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__WirelessSettingsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__WirelessSettingsType; + if (size) + *size = sizeof(wcxs__WirelessSettingsType); + ((wcxs__WirelessSettingsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__WirelessSettingsType[n]; + if (size) + *size = n * sizeof(wcxs__WirelessSettingsType); + for (int i = 0; i < n; i++) + ((wcxs__WirelessSettingsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__WirelessSettingsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__WirelessSettingsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__WirelessSettingsType %p -> %p\n", q, p)); + *(wcxs__WirelessSettingsType*)p = *(wcxs__WirelessSettingsType*)q; +} + +void wcxs__WirelessCapabilitiesType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfwcxs__FeatureType(soap, &((wcxs__WirelessCapabilitiesType*)this)->SupportedFeatures); + /* transient soap skipped */ +} + +void wcxs__WirelessCapabilitiesType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfwcxs__FeatureType(soap, &((wcxs__WirelessCapabilitiesType*)this)->SupportedFeatures); + /* transient soap skipped */ +} + +int wcxs__WirelessCapabilitiesType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__WirelessCapabilitiesType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__WirelessCapabilitiesType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__WirelessCapabilitiesType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__WirelessCapabilitiesType(struct soap *soap, const char *tag, int id, const wcxs__WirelessCapabilitiesType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__WirelessCapabilitiesType), type); + soap_out_std__vectorTemplateOfwcxs__FeatureType(soap, "wcxs:SupportedFeatures", -1, &(((wcxs__WirelessCapabilitiesType*)a)->SupportedFeatures), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__WirelessCapabilitiesType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__WirelessCapabilitiesType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__WirelessCapabilitiesType * SOAP_FMAC4 soap_get_wcxs__WirelessCapabilitiesType(struct soap *soap, wcxs__WirelessCapabilitiesType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__WirelessCapabilitiesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__WirelessCapabilitiesType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__WirelessCapabilitiesType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__WirelessCapabilitiesType * SOAP_FMAC4 soap_in_wcxs__WirelessCapabilitiesType(struct soap *soap, const char *tag, wcxs__WirelessCapabilitiesType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__WirelessCapabilitiesType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__WirelessCapabilitiesType, sizeof(wcxs__WirelessCapabilitiesType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__WirelessCapabilitiesType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__WirelessCapabilitiesType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfwcxs__FeatureType(soap, "wcxs:SupportedFeatures", &(((wcxs__WirelessCapabilitiesType*)a)->SupportedFeatures), "wcxs:FeatureType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((wcxs__WirelessCapabilitiesType*)a)->SupportedFeatures.size() > 4)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__WirelessCapabilitiesType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__WirelessCapabilitiesType, 0, sizeof(wcxs__WirelessCapabilitiesType), 0, soap_copy_wcxs__WirelessCapabilitiesType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__WirelessCapabilitiesType * SOAP_FMAC6 soap_new_wcxs__WirelessCapabilitiesType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__WirelessCapabilitiesType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__WirelessCapabilitiesType(struct soap *soap, wcxs__WirelessCapabilitiesType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__WirelessCapabilitiesType * SOAP_FMAC4 soap_instantiate_wcxs__WirelessCapabilitiesType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__WirelessCapabilitiesType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__WirelessCapabilitiesType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__WirelessCapabilitiesType; + if (size) + *size = sizeof(wcxs__WirelessCapabilitiesType); + ((wcxs__WirelessCapabilitiesType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__WirelessCapabilitiesType[n]; + if (size) + *size = n * sizeof(wcxs__WirelessCapabilitiesType); + for (int i = 0; i < n; i++) + ((wcxs__WirelessCapabilitiesType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__WirelessCapabilitiesType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__WirelessCapabilitiesType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__WirelessCapabilitiesType %p -> %p\n", q, p)); + *(wcxs__WirelessCapabilitiesType*)p = *(wcxs__WirelessCapabilitiesType*)q; +} + +void wcxs__ProfileType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_wcxs__ProfileNameType(soap, &((wcxs__ProfileType*)this)->ProfileName); + soap_serialize_PointerToxsd__base64Binary(soap, &((wcxs__ProfileType*)this)->SSID); + soap_serialize_PointerTowcxs__ProfileSecuritySettingsType(soap, &((wcxs__ProfileType*)this)->Security); + /* transient soap skipped */ +} + +void wcxs__ProfileType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_wcxs__ProfileNameType(soap, &((wcxs__ProfileType*)this)->ProfileName); + soap_default_wcxs__ProfilePriorityType(soap, &((wcxs__ProfileType*)this)->Priority); + ((wcxs__ProfileType*)this)->SSID = NULL; + ((wcxs__ProfileType*)this)->Security = NULL; + /* transient soap skipped */ +} + +int wcxs__ProfileType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__ProfileType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__ProfileType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__ProfileType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileType(struct soap *soap, const char *tag, int id, const wcxs__ProfileType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__ProfileType), type); + soap_out_wcxs__ProfileNameType(soap, "wcxs:ProfileName", -1, &(((wcxs__ProfileType*)a)->ProfileName), ""); + soap_out_wcxs__ProfilePriorityType(soap, "wcxs:Priority", -1, &(((wcxs__ProfileType*)a)->Priority), ""); + soap_out_PointerToxsd__base64Binary(soap, "wcxs:SSID", -1, &(((wcxs__ProfileType*)a)->SSID), ""); + soap_out_PointerTowcxs__ProfileSecuritySettingsType(soap, "wcxs:Security", -1, &(((wcxs__ProfileType*)a)->Security), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__ProfileType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__ProfileType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__ProfileType * SOAP_FMAC4 soap_get_wcxs__ProfileType(struct soap *soap, wcxs__ProfileType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__ProfileType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__ProfileType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__ProfileType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__ProfileType * SOAP_FMAC4 soap_in_wcxs__ProfileType(struct soap *soap, const char *tag, wcxs__ProfileType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__ProfileType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__ProfileType, sizeof(wcxs__ProfileType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__ProfileType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__ProfileType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ProfileName1 = 1, soap_flag_Priority1 = 1, soap_flag_SSID1 = 1, soap_flag_Security1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ProfileName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_wcxs__ProfileNameType(soap, "wcxs:ProfileName", &(((wcxs__ProfileType*)a)->ProfileName), "wcxs:ProfileNameType")) + { soap_flag_ProfileName1--; + continue; + } + if (soap_flag_Priority1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_wcxs__ProfilePriorityType(soap, "wcxs:Priority", &(((wcxs__ProfileType*)a)->Priority), "wcxs:ProfilePriorityType")) + { soap_flag_Priority1--; + continue; + } + if (soap_flag_SSID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxsd__base64Binary(soap, "wcxs:SSID", &(((wcxs__ProfileType*)a)->SSID), "xsd:base64Binary")) + { soap_flag_SSID1--; + continue; + } + if (soap_flag_Security1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTowcxs__ProfileSecuritySettingsType(soap, "wcxs:Security", &(((wcxs__ProfileType*)a)->Security), "wcxs:ProfileSecuritySettingsType")) + { soap_flag_Security1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ProfileName1 > 0 || soap_flag_Priority1 > 0 || soap_flag_Security1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__ProfileType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__ProfileType, 0, sizeof(wcxs__ProfileType), 0, soap_copy_wcxs__ProfileType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__ProfileType * SOAP_FMAC6 soap_new_wcxs__ProfileType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__ProfileType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileType(struct soap *soap, wcxs__ProfileType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__ProfileType * SOAP_FMAC4 soap_instantiate_wcxs__ProfileType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__ProfileType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__ProfileType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__ProfileType; + if (size) + *size = sizeof(wcxs__ProfileType); + ((wcxs__ProfileType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__ProfileType[n]; + if (size) + *size = n * sizeof(wcxs__ProfileType); + for (int i = 0; i < n; i++) + ((wcxs__ProfileType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__ProfileType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__ProfileType %p -> %p\n", q, p)); + *(wcxs__ProfileType*)p = *(wcxs__ProfileType*)q; +} + +void wcxs__ProfileSecuritySettingsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__wcxs__union_ProfileSecuritySettingsType(soap, ((wcxs__ProfileSecuritySettingsType*)this)->__union_ProfileSecuritySettingsType, &((wcxs__ProfileSecuritySettingsType*)this)->union_ProfileSecuritySettingsType); + /* transient soap skipped */ +} + +void wcxs__ProfileSecuritySettingsType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((wcxs__ProfileSecuritySettingsType*)this)->__union_ProfileSecuritySettingsType = 0; + /* transient soap skipped */ +} + +int wcxs__ProfileSecuritySettingsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__ProfileSecuritySettingsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__ProfileSecuritySettingsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__ProfileSecuritySettingsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileSecuritySettingsType(struct soap *soap, const char *tag, int id, const wcxs__ProfileSecuritySettingsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__ProfileSecuritySettingsType), type); + soap_out__wcxs__union_ProfileSecuritySettingsType(soap, ((wcxs__ProfileSecuritySettingsType*)a)->__union_ProfileSecuritySettingsType, &((wcxs__ProfileSecuritySettingsType*)a)->union_ProfileSecuritySettingsType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__ProfileSecuritySettingsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__ProfileSecuritySettingsType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType * SOAP_FMAC4 soap_get_wcxs__ProfileSecuritySettingsType(struct soap *soap, wcxs__ProfileSecuritySettingsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__ProfileSecuritySettingsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__ProfileSecuritySettingsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__ProfileSecuritySettingsType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType * SOAP_FMAC4 soap_in_wcxs__ProfileSecuritySettingsType(struct soap *soap, const char *tag, wcxs__ProfileSecuritySettingsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__ProfileSecuritySettingsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__ProfileSecuritySettingsType, sizeof(wcxs__ProfileSecuritySettingsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__ProfileSecuritySettingsType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__ProfileSecuritySettingsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_ProfileSecuritySettingsType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_ProfileSecuritySettingsType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__wcxs__union_ProfileSecuritySettingsType(soap, &((wcxs__ProfileSecuritySettingsType*)a)->__union_ProfileSecuritySettingsType, &((wcxs__ProfileSecuritySettingsType*)a)->union_ProfileSecuritySettingsType)) + { soap_flag_union_ProfileSecuritySettingsType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_ProfileSecuritySettingsType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__ProfileSecuritySettingsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__ProfileSecuritySettingsType, 0, sizeof(wcxs__ProfileSecuritySettingsType), 0, soap_copy_wcxs__ProfileSecuritySettingsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__ProfileSecuritySettingsType * SOAP_FMAC6 soap_new_wcxs__ProfileSecuritySettingsType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__ProfileSecuritySettingsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileSecuritySettingsType(struct soap *soap, wcxs__ProfileSecuritySettingsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType * SOAP_FMAC4 soap_instantiate_wcxs__ProfileSecuritySettingsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__ProfileSecuritySettingsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__ProfileSecuritySettingsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__ProfileSecuritySettingsType; + if (size) + *size = sizeof(wcxs__ProfileSecuritySettingsType); + ((wcxs__ProfileSecuritySettingsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__ProfileSecuritySettingsType[n]; + if (size) + *size = n * sizeof(wcxs__ProfileSecuritySettingsType); + for (int i = 0; i < n; i++) + ((wcxs__ProfileSecuritySettingsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__ProfileSecuritySettingsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileSecuritySettingsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__ProfileSecuritySettingsType %p -> %p\n", q, p)); + *(wcxs__ProfileSecuritySettingsType*)p = *(wcxs__ProfileSecuritySettingsType*)q; +} + +void wcxs__ProfileSecuritySettingRSNType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__wcxs__union_ProfileSecuritySettingRSNType(soap, ((wcxs__ProfileSecuritySettingRSNType*)this)->__union_ProfileSecuritySettingRSNType, &((wcxs__ProfileSecuritySettingRSNType*)this)->union_ProfileSecuritySettingRSNType); + /* transient soap skipped */ +} + +void wcxs__ProfileSecuritySettingRSNType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((wcxs__ProfileSecuritySettingRSNType*)this)->__union_ProfileSecuritySettingRSNType = 0; + /* transient soap skipped */ +} + +int wcxs__ProfileSecuritySettingRSNType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__ProfileSecuritySettingRSNType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__ProfileSecuritySettingRSNType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileSecuritySettingRSNType(struct soap *soap, const char *tag, int id, const wcxs__ProfileSecuritySettingRSNType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType), type); + soap_out__wcxs__union_ProfileSecuritySettingRSNType(soap, ((wcxs__ProfileSecuritySettingRSNType*)a)->__union_ProfileSecuritySettingRSNType, &((wcxs__ProfileSecuritySettingRSNType*)a)->union_ProfileSecuritySettingRSNType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__ProfileSecuritySettingRSNType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__ProfileSecuritySettingRSNType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType * SOAP_FMAC4 soap_get_wcxs__ProfileSecuritySettingRSNType(struct soap *soap, wcxs__ProfileSecuritySettingRSNType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__ProfileSecuritySettingRSNType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__ProfileSecuritySettingRSNType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__ProfileSecuritySettingRSNType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType * SOAP_FMAC4 soap_in_wcxs__ProfileSecuritySettingRSNType(struct soap *soap, const char *tag, wcxs__ProfileSecuritySettingRSNType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__ProfileSecuritySettingRSNType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType, sizeof(wcxs__ProfileSecuritySettingRSNType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__ProfileSecuritySettingRSNType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_ProfileSecuritySettingRSNType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_ProfileSecuritySettingRSNType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__wcxs__union_ProfileSecuritySettingRSNType(soap, &((wcxs__ProfileSecuritySettingRSNType*)a)->__union_ProfileSecuritySettingRSNType, &((wcxs__ProfileSecuritySettingRSNType*)a)->union_ProfileSecuritySettingRSNType)) + { soap_flag_union_ProfileSecuritySettingRSNType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_ProfileSecuritySettingRSNType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__ProfileSecuritySettingRSNType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType, 0, sizeof(wcxs__ProfileSecuritySettingRSNType), 0, soap_copy_wcxs__ProfileSecuritySettingRSNType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__ProfileSecuritySettingRSNType * SOAP_FMAC6 soap_new_wcxs__ProfileSecuritySettingRSNType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__ProfileSecuritySettingRSNType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileSecuritySettingRSNType(struct soap *soap, wcxs__ProfileSecuritySettingRSNType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType * SOAP_FMAC4 soap_instantiate_wcxs__ProfileSecuritySettingRSNType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__ProfileSecuritySettingRSNType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__ProfileSecuritySettingRSNType; + if (size) + *size = sizeof(wcxs__ProfileSecuritySettingRSNType); + ((wcxs__ProfileSecuritySettingRSNType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__ProfileSecuritySettingRSNType[n]; + if (size) + *size = n * sizeof(wcxs__ProfileSecuritySettingRSNType); + for (int i = 0; i < n; i++) + ((wcxs__ProfileSecuritySettingRSNType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__ProfileSecuritySettingRSNType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileSecuritySettingRSNType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__ProfileSecuritySettingRSNType %p -> %p\n", q, p)); + *(wcxs__ProfileSecuritySettingRSNType*)p = *(wcxs__ProfileSecuritySettingRSNType*)q; +} + +void wcxs__ProfileSecuritySettingWPAType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__wcxs__union_ProfileSecuritySettingWPAType(soap, ((wcxs__ProfileSecuritySettingWPAType*)this)->__union_ProfileSecuritySettingWPAType, &((wcxs__ProfileSecuritySettingWPAType*)this)->union_ProfileSecuritySettingWPAType); + /* transient soap skipped */ +} + +void wcxs__ProfileSecuritySettingWPAType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((wcxs__ProfileSecuritySettingWPAType*)this)->__union_ProfileSecuritySettingWPAType = 0; + /* transient soap skipped */ +} + +int wcxs__ProfileSecuritySettingWPAType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__ProfileSecuritySettingWPAType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__ProfileSecuritySettingWPAType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__ProfileSecuritySettingWPAType(struct soap *soap, const char *tag, int id, const wcxs__ProfileSecuritySettingWPAType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType), type); + soap_out__wcxs__union_ProfileSecuritySettingWPAType(soap, ((wcxs__ProfileSecuritySettingWPAType*)a)->__union_ProfileSecuritySettingWPAType, &((wcxs__ProfileSecuritySettingWPAType*)a)->union_ProfileSecuritySettingWPAType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__ProfileSecuritySettingWPAType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__ProfileSecuritySettingWPAType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType * SOAP_FMAC4 soap_get_wcxs__ProfileSecuritySettingWPAType(struct soap *soap, wcxs__ProfileSecuritySettingWPAType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__ProfileSecuritySettingWPAType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__ProfileSecuritySettingWPAType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__ProfileSecuritySettingWPAType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType * SOAP_FMAC4 soap_in_wcxs__ProfileSecuritySettingWPAType(struct soap *soap, const char *tag, wcxs__ProfileSecuritySettingWPAType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__ProfileSecuritySettingWPAType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType, sizeof(wcxs__ProfileSecuritySettingWPAType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__ProfileSecuritySettingWPAType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_ProfileSecuritySettingWPAType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_ProfileSecuritySettingWPAType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__wcxs__union_ProfileSecuritySettingWPAType(soap, &((wcxs__ProfileSecuritySettingWPAType*)a)->__union_ProfileSecuritySettingWPAType, &((wcxs__ProfileSecuritySettingWPAType*)a)->union_ProfileSecuritySettingWPAType)) + { soap_flag_union_ProfileSecuritySettingWPAType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_ProfileSecuritySettingWPAType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__ProfileSecuritySettingWPAType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType, 0, sizeof(wcxs__ProfileSecuritySettingWPAType), 0, soap_copy_wcxs__ProfileSecuritySettingWPAType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__ProfileSecuritySettingWPAType * SOAP_FMAC6 soap_new_wcxs__ProfileSecuritySettingWPAType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__ProfileSecuritySettingWPAType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__ProfileSecuritySettingWPAType(struct soap *soap, wcxs__ProfileSecuritySettingWPAType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType * SOAP_FMAC4 soap_instantiate_wcxs__ProfileSecuritySettingWPAType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__ProfileSecuritySettingWPAType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__ProfileSecuritySettingWPAType; + if (size) + *size = sizeof(wcxs__ProfileSecuritySettingWPAType); + ((wcxs__ProfileSecuritySettingWPAType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__ProfileSecuritySettingWPAType[n]; + if (size) + *size = n * sizeof(wcxs__ProfileSecuritySettingWPAType); + for (int i = 0; i < n; i++) + ((wcxs__ProfileSecuritySettingWPAType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__ProfileSecuritySettingWPAType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__ProfileSecuritySettingWPAType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__ProfileSecuritySettingWPAType %p -> %p\n", q, p)); + *(wcxs__ProfileSecuritySettingWPAType*)p = *(wcxs__ProfileSecuritySettingWPAType*)q; +} + +void wcxs__DataEncryptionCCMPType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__wcxs__union_DataEncryptionCCMPType(soap, ((wcxs__DataEncryptionCCMPType*)this)->__union_DataEncryptionCCMPType, &((wcxs__DataEncryptionCCMPType*)this)->union_DataEncryptionCCMPType); + /* transient soap skipped */ +} + +void wcxs__DataEncryptionCCMPType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((wcxs__DataEncryptionCCMPType*)this)->__union_DataEncryptionCCMPType = 0; + /* transient soap skipped */ +} + +int wcxs__DataEncryptionCCMPType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__DataEncryptionCCMPType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__DataEncryptionCCMPType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__DataEncryptionCCMPType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__DataEncryptionCCMPType(struct soap *soap, const char *tag, int id, const wcxs__DataEncryptionCCMPType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__DataEncryptionCCMPType), type); + soap_out__wcxs__union_DataEncryptionCCMPType(soap, ((wcxs__DataEncryptionCCMPType*)a)->__union_DataEncryptionCCMPType, &((wcxs__DataEncryptionCCMPType*)a)->union_DataEncryptionCCMPType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__DataEncryptionCCMPType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__DataEncryptionCCMPType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionCCMPType * SOAP_FMAC4 soap_get_wcxs__DataEncryptionCCMPType(struct soap *soap, wcxs__DataEncryptionCCMPType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__DataEncryptionCCMPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__DataEncryptionCCMPType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__DataEncryptionCCMPType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionCCMPType * SOAP_FMAC4 soap_in_wcxs__DataEncryptionCCMPType(struct soap *soap, const char *tag, wcxs__DataEncryptionCCMPType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__DataEncryptionCCMPType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__DataEncryptionCCMPType, sizeof(wcxs__DataEncryptionCCMPType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__DataEncryptionCCMPType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__DataEncryptionCCMPType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_DataEncryptionCCMPType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_DataEncryptionCCMPType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__wcxs__union_DataEncryptionCCMPType(soap, &((wcxs__DataEncryptionCCMPType*)a)->__union_DataEncryptionCCMPType, &((wcxs__DataEncryptionCCMPType*)a)->union_DataEncryptionCCMPType)) + { soap_flag_union_DataEncryptionCCMPType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_DataEncryptionCCMPType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__DataEncryptionCCMPType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__DataEncryptionCCMPType, 0, sizeof(wcxs__DataEncryptionCCMPType), 0, soap_copy_wcxs__DataEncryptionCCMPType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__DataEncryptionCCMPType * SOAP_FMAC6 soap_new_wcxs__DataEncryptionCCMPType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__DataEncryptionCCMPType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__DataEncryptionCCMPType(struct soap *soap, wcxs__DataEncryptionCCMPType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__DataEncryptionCCMPType * SOAP_FMAC4 soap_instantiate_wcxs__DataEncryptionCCMPType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__DataEncryptionCCMPType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__DataEncryptionCCMPType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__DataEncryptionCCMPType; + if (size) + *size = sizeof(wcxs__DataEncryptionCCMPType); + ((wcxs__DataEncryptionCCMPType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__DataEncryptionCCMPType[n]; + if (size) + *size = n * sizeof(wcxs__DataEncryptionCCMPType); + for (int i = 0; i < n; i++) + ((wcxs__DataEncryptionCCMPType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__DataEncryptionCCMPType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__DataEncryptionCCMPType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__DataEncryptionCCMPType %p -> %p\n", q, p)); + *(wcxs__DataEncryptionCCMPType*)p = *(wcxs__DataEncryptionCCMPType*)q; +} + +void wcxs__DataEncryptionTKIPType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__wcxs__union_DataEncryptionTKIPType(soap, ((wcxs__DataEncryptionTKIPType*)this)->__union_DataEncryptionTKIPType, &((wcxs__DataEncryptionTKIPType*)this)->union_DataEncryptionTKIPType); + /* transient soap skipped */ +} + +void wcxs__DataEncryptionTKIPType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((wcxs__DataEncryptionTKIPType*)this)->__union_DataEncryptionTKIPType = 0; + /* transient soap skipped */ +} + +int wcxs__DataEncryptionTKIPType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__DataEncryptionTKIPType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__DataEncryptionTKIPType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__DataEncryptionTKIPType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__DataEncryptionTKIPType(struct soap *soap, const char *tag, int id, const wcxs__DataEncryptionTKIPType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__DataEncryptionTKIPType), type); + soap_out__wcxs__union_DataEncryptionTKIPType(soap, ((wcxs__DataEncryptionTKIPType*)a)->__union_DataEncryptionTKIPType, &((wcxs__DataEncryptionTKIPType*)a)->union_DataEncryptionTKIPType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__DataEncryptionTKIPType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__DataEncryptionTKIPType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionTKIPType * SOAP_FMAC4 soap_get_wcxs__DataEncryptionTKIPType(struct soap *soap, wcxs__DataEncryptionTKIPType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__DataEncryptionTKIPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__DataEncryptionTKIPType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__DataEncryptionTKIPType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionTKIPType * SOAP_FMAC4 soap_in_wcxs__DataEncryptionTKIPType(struct soap *soap, const char *tag, wcxs__DataEncryptionTKIPType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__DataEncryptionTKIPType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__DataEncryptionTKIPType, sizeof(wcxs__DataEncryptionTKIPType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__DataEncryptionTKIPType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__DataEncryptionTKIPType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_DataEncryptionTKIPType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_DataEncryptionTKIPType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__wcxs__union_DataEncryptionTKIPType(soap, &((wcxs__DataEncryptionTKIPType*)a)->__union_DataEncryptionTKIPType, &((wcxs__DataEncryptionTKIPType*)a)->union_DataEncryptionTKIPType)) + { soap_flag_union_DataEncryptionTKIPType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_DataEncryptionTKIPType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__DataEncryptionTKIPType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__DataEncryptionTKIPType, 0, sizeof(wcxs__DataEncryptionTKIPType), 0, soap_copy_wcxs__DataEncryptionTKIPType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__DataEncryptionTKIPType * SOAP_FMAC6 soap_new_wcxs__DataEncryptionTKIPType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__DataEncryptionTKIPType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__DataEncryptionTKIPType(struct soap *soap, wcxs__DataEncryptionTKIPType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__DataEncryptionTKIPType * SOAP_FMAC4 soap_instantiate_wcxs__DataEncryptionTKIPType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__DataEncryptionTKIPType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__DataEncryptionTKIPType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__DataEncryptionTKIPType; + if (size) + *size = sizeof(wcxs__DataEncryptionTKIPType); + ((wcxs__DataEncryptionTKIPType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__DataEncryptionTKIPType[n]; + if (size) + *size = n * sizeof(wcxs__DataEncryptionTKIPType); + for (int i = 0; i < n; i++) + ((wcxs__DataEncryptionTKIPType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__DataEncryptionTKIPType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__DataEncryptionTKIPType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__DataEncryptionTKIPType %p -> %p\n", q, p)); + *(wcxs__DataEncryptionTKIPType*)p = *(wcxs__DataEncryptionTKIPType*)q; +} + +void wcxs__DataEncryptionWEPType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__wcxs__union_DataEncryptionWEPType(soap, ((wcxs__DataEncryptionWEPType*)this)->__union_DataEncryptionWEPType, &((wcxs__DataEncryptionWEPType*)this)->union_DataEncryptionWEPType); + /* transient soap skipped */ +} + +void wcxs__DataEncryptionWEPType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((wcxs__DataEncryptionWEPType*)this)->__union_DataEncryptionWEPType = 0; + /* transient soap skipped */ +} + +int wcxs__DataEncryptionWEPType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__DataEncryptionWEPType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__DataEncryptionWEPType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__DataEncryptionWEPType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__DataEncryptionWEPType(struct soap *soap, const char *tag, int id, const wcxs__DataEncryptionWEPType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__DataEncryptionWEPType), type); + soap_out__wcxs__union_DataEncryptionWEPType(soap, ((wcxs__DataEncryptionWEPType*)a)->__union_DataEncryptionWEPType, &((wcxs__DataEncryptionWEPType*)a)->union_DataEncryptionWEPType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__DataEncryptionWEPType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__DataEncryptionWEPType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionWEPType * SOAP_FMAC4 soap_get_wcxs__DataEncryptionWEPType(struct soap *soap, wcxs__DataEncryptionWEPType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__DataEncryptionWEPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__DataEncryptionWEPType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__DataEncryptionWEPType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionWEPType * SOAP_FMAC4 soap_in_wcxs__DataEncryptionWEPType(struct soap *soap, const char *tag, wcxs__DataEncryptionWEPType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__DataEncryptionWEPType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__DataEncryptionWEPType, sizeof(wcxs__DataEncryptionWEPType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__DataEncryptionWEPType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__DataEncryptionWEPType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_DataEncryptionWEPType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_DataEncryptionWEPType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__wcxs__union_DataEncryptionWEPType(soap, &((wcxs__DataEncryptionWEPType*)a)->__union_DataEncryptionWEPType, &((wcxs__DataEncryptionWEPType*)a)->union_DataEncryptionWEPType)) + { soap_flag_union_DataEncryptionWEPType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_DataEncryptionWEPType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__DataEncryptionWEPType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__DataEncryptionWEPType, 0, sizeof(wcxs__DataEncryptionWEPType), 0, soap_copy_wcxs__DataEncryptionWEPType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__DataEncryptionWEPType * SOAP_FMAC6 soap_new_wcxs__DataEncryptionWEPType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__DataEncryptionWEPType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__DataEncryptionWEPType(struct soap *soap, wcxs__DataEncryptionWEPType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__DataEncryptionWEPType * SOAP_FMAC4 soap_instantiate_wcxs__DataEncryptionWEPType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__DataEncryptionWEPType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__DataEncryptionWEPType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__DataEncryptionWEPType; + if (size) + *size = sizeof(wcxs__DataEncryptionWEPType); + ((wcxs__DataEncryptionWEPType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__DataEncryptionWEPType[n]; + if (size) + *size = n * sizeof(wcxs__DataEncryptionWEPType); + for (int i = 0; i < n; i++) + ((wcxs__DataEncryptionWEPType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__DataEncryptionWEPType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__DataEncryptionWEPType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__DataEncryptionWEPType %p -> %p\n", q, p)); + *(wcxs__DataEncryptionWEPType*)p = *(wcxs__DataEncryptionWEPType*)q; +} + +void wcxs__DataEncryptionWEPXType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__wcxs__union_DataEncryptionWEPXType(soap, ((wcxs__DataEncryptionWEPXType*)this)->__union_DataEncryptionWEPXType, &((wcxs__DataEncryptionWEPXType*)this)->union_DataEncryptionWEPXType); + /* transient soap skipped */ +} + +void wcxs__DataEncryptionWEPXType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_wcxs__KeyIndexType(soap, &((wcxs__DataEncryptionWEPXType*)this)->KeyIndex); + ((wcxs__DataEncryptionWEPXType*)this)->__union_DataEncryptionWEPXType = 0; + /* transient soap skipped */ +} + +int wcxs__DataEncryptionWEPXType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__DataEncryptionWEPXType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__DataEncryptionWEPXType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__DataEncryptionWEPXType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__DataEncryptionWEPXType(struct soap *soap, const char *tag, int id, const wcxs__DataEncryptionWEPXType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__DataEncryptionWEPXType), type); + soap_out_wcxs__KeyIndexType(soap, "wcxs:KeyIndex", -1, &(((wcxs__DataEncryptionWEPXType*)a)->KeyIndex), ""); + soap_out__wcxs__union_DataEncryptionWEPXType(soap, ((wcxs__DataEncryptionWEPXType*)a)->__union_DataEncryptionWEPXType, &((wcxs__DataEncryptionWEPXType*)a)->union_DataEncryptionWEPXType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__DataEncryptionWEPXType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__DataEncryptionWEPXType(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionWEPXType * SOAP_FMAC4 soap_get_wcxs__DataEncryptionWEPXType(struct soap *soap, wcxs__DataEncryptionWEPXType *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__DataEncryptionWEPXType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__DataEncryptionWEPXType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__DataEncryptionWEPXType(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionWEPXType * SOAP_FMAC4 soap_in_wcxs__DataEncryptionWEPXType(struct soap *soap, const char *tag, wcxs__DataEncryptionWEPXType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__DataEncryptionWEPXType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__DataEncryptionWEPXType, sizeof(wcxs__DataEncryptionWEPXType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__DataEncryptionWEPXType) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__DataEncryptionWEPXType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_KeyIndex1 = 1, soap_flag_union_DataEncryptionWEPXType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_KeyIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_wcxs__KeyIndexType(soap, "wcxs:KeyIndex", &(((wcxs__DataEncryptionWEPXType*)a)->KeyIndex), "wcxs:KeyIndexType")) + { soap_flag_KeyIndex1--; + continue; + } + if (soap_flag_union_DataEncryptionWEPXType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__wcxs__union_DataEncryptionWEPXType(soap, &((wcxs__DataEncryptionWEPXType*)a)->__union_DataEncryptionWEPXType, &((wcxs__DataEncryptionWEPXType*)a)->union_DataEncryptionWEPXType)) + { soap_flag_union_DataEncryptionWEPXType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_KeyIndex1 > 0 || soap_flag_union_DataEncryptionWEPXType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__DataEncryptionWEPXType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__DataEncryptionWEPXType, 0, sizeof(wcxs__DataEncryptionWEPXType), 0, soap_copy_wcxs__DataEncryptionWEPXType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__DataEncryptionWEPXType * SOAP_FMAC6 soap_new_wcxs__DataEncryptionWEPXType(struct soap *soap, int n) +{ return soap_instantiate_wcxs__DataEncryptionWEPXType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__DataEncryptionWEPXType(struct soap *soap, wcxs__DataEncryptionWEPXType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__DataEncryptionWEPXType * SOAP_FMAC4 soap_instantiate_wcxs__DataEncryptionWEPXType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__DataEncryptionWEPXType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__DataEncryptionWEPXType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__DataEncryptionWEPXType; + if (size) + *size = sizeof(wcxs__DataEncryptionWEPXType); + ((wcxs__DataEncryptionWEPXType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__DataEncryptionWEPXType[n]; + if (size) + *size = n * sizeof(wcxs__DataEncryptionWEPXType); + for (int i = 0; i < n; i++) + ((wcxs__DataEncryptionWEPXType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__DataEncryptionWEPXType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__DataEncryptionWEPXType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__DataEncryptionWEPXType %p -> %p\n", q, p)); + *(wcxs__DataEncryptionWEPXType*)p = *(wcxs__DataEncryptionWEPXType*)q; +} + +void wcxs__WEP128Type::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__wcxs__union_WEP128Type(soap, ((wcxs__WEP128Type*)this)->__union_WEP128Type, &((wcxs__WEP128Type*)this)->union_WEP128Type); + /* transient soap skipped */ +} + +void wcxs__WEP128Type::soap_default(struct soap *soap) +{ + this->soap = soap; + ((wcxs__WEP128Type*)this)->__union_WEP128Type = 0; + /* transient soap skipped */ +} + +int wcxs__WEP128Type::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__WEP128Type); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__WEP128Type::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__WEP128Type(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__WEP128Type(struct soap *soap, const char *tag, int id, const wcxs__WEP128Type *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__WEP128Type), type); + soap_out__wcxs__union_WEP128Type(soap, ((wcxs__WEP128Type*)a)->__union_WEP128Type, &((wcxs__WEP128Type*)a)->union_WEP128Type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__WEP128Type::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__WEP128Type(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__WEP128Type * SOAP_FMAC4 soap_get_wcxs__WEP128Type(struct soap *soap, wcxs__WEP128Type *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__WEP128Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__WEP128Type::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__WEP128Type(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__WEP128Type * SOAP_FMAC4 soap_in_wcxs__WEP128Type(struct soap *soap, const char *tag, wcxs__WEP128Type *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__WEP128Type *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__WEP128Type, sizeof(wcxs__WEP128Type), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__WEP128Type) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__WEP128Type *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_WEP128Type1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_WEP128Type1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__wcxs__union_WEP128Type(soap, &((wcxs__WEP128Type*)a)->__union_WEP128Type, &((wcxs__WEP128Type*)a)->union_WEP128Type)) + { soap_flag_union_WEP128Type1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_WEP128Type1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__WEP128Type *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__WEP128Type, 0, sizeof(wcxs__WEP128Type), 0, soap_copy_wcxs__WEP128Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__WEP128Type * SOAP_FMAC6 soap_new_wcxs__WEP128Type(struct soap *soap, int n) +{ return soap_instantiate_wcxs__WEP128Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__WEP128Type(struct soap *soap, wcxs__WEP128Type *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__WEP128Type * SOAP_FMAC4 soap_instantiate_wcxs__WEP128Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__WEP128Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__WEP128Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__WEP128Type; + if (size) + *size = sizeof(wcxs__WEP128Type); + ((wcxs__WEP128Type*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__WEP128Type[n]; + if (size) + *size = n * sizeof(wcxs__WEP128Type); + for (int i = 0; i < n; i++) + ((wcxs__WEP128Type*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__WEP128Type*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__WEP128Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__WEP128Type %p -> %p\n", q, p)); + *(wcxs__WEP128Type*)p = *(wcxs__WEP128Type*)q; +} + +void wcxs__WEP64Type::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__wcxs__union_WEP64Type(soap, ((wcxs__WEP64Type*)this)->__union_WEP64Type, &((wcxs__WEP64Type*)this)->union_WEP64Type); + /* transient soap skipped */ +} + +void wcxs__WEP64Type::soap_default(struct soap *soap) +{ + this->soap = soap; + ((wcxs__WEP64Type*)this)->__union_WEP64Type = 0; + /* transient soap skipped */ +} + +int wcxs__WEP64Type::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_wcxs__WEP64Type); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int wcxs__WEP64Type::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_wcxs__WEP64Type(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_wcxs__WEP64Type(struct soap *soap, const char *tag, int id, const wcxs__WEP64Type *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_wcxs__WEP64Type), type); + soap_out__wcxs__union_WEP64Type(soap, ((wcxs__WEP64Type*)a)->__union_WEP64Type, &((wcxs__WEP64Type*)a)->union_WEP64Type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *wcxs__WEP64Type::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_wcxs__WEP64Type(soap, this, tag, type); +} + +SOAP_FMAC3 wcxs__WEP64Type * SOAP_FMAC4 soap_get_wcxs__WEP64Type(struct soap *soap, wcxs__WEP64Type *p, const char *tag, const char *type) +{ + if ((p = soap_in_wcxs__WEP64Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *wcxs__WEP64Type::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_wcxs__WEP64Type(soap, tag, this, type); +} + +SOAP_FMAC3 wcxs__WEP64Type * SOAP_FMAC4 soap_in_wcxs__WEP64Type(struct soap *soap, const char *tag, wcxs__WEP64Type *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (wcxs__WEP64Type *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_wcxs__WEP64Type, sizeof(wcxs__WEP64Type), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_wcxs__WEP64Type) + { soap_revert(soap); + *soap->id = '\0'; + return (wcxs__WEP64Type *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_WEP64Type1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_WEP64Type1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__wcxs__union_WEP64Type(soap, &((wcxs__WEP64Type*)a)->__union_WEP64Type, &((wcxs__WEP64Type*)a)->union_WEP64Type)) + { soap_flag_union_WEP64Type1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_WEP64Type1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (wcxs__WEP64Type *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_wcxs__WEP64Type, 0, sizeof(wcxs__WEP64Type), 0, soap_copy_wcxs__WEP64Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 wcxs__WEP64Type * SOAP_FMAC6 soap_new_wcxs__WEP64Type(struct soap *soap, int n) +{ return soap_instantiate_wcxs__WEP64Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_wcxs__WEP64Type(struct soap *soap, wcxs__WEP64Type *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 wcxs__WEP64Type * SOAP_FMAC4 soap_instantiate_wcxs__WEP64Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_wcxs__WEP64Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_wcxs__WEP64Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new wcxs__WEP64Type; + if (size) + *size = sizeof(wcxs__WEP64Type); + ((wcxs__WEP64Type*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new wcxs__WEP64Type[n]; + if (size) + *size = n * sizeof(wcxs__WEP64Type); + for (int i = 0; i < n; i++) + ((wcxs__WEP64Type*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (wcxs__WEP64Type*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_wcxs__WEP64Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying wcxs__WEP64Type %p -> %p\n", q, p)); + *(wcxs__WEP64Type*)p = *(wcxs__WEP64Type*)q; +} + +void _rci__GetSystemPowerStateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _rci__GetSystemPowerStateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_rci__PT_USCORESTATUS(soap, &((_rci__GetSystemPowerStateResponse*)this)->Status); + soap_default_rci__SystemPowerStateType(soap, &((_rci__GetSystemPowerStateResponse*)this)->SystemPowerState); + /* transient soap skipped */ +} + +int _rci__GetSystemPowerStateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__rci__GetSystemPowerStateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _rci__GetSystemPowerStateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__rci__GetSystemPowerStateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__GetSystemPowerStateResponse(struct soap *soap, const char *tag, int id, const _rci__GetSystemPowerStateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__rci__GetSystemPowerStateResponse), type); + soap_element_result(soap, "rci:Status"); + soap_out_rci__PT_USCORESTATUS(soap, "rci:Status", -1, &(((_rci__GetSystemPowerStateResponse*)a)->Status), ""); + soap_out_rci__SystemPowerStateType(soap, "rci:SystemPowerState", -1, &(((_rci__GetSystemPowerStateResponse*)a)->SystemPowerState), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_rci__GetSystemPowerStateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__rci__GetSystemPowerStateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _rci__GetSystemPowerStateResponse * SOAP_FMAC4 soap_get__rci__GetSystemPowerStateResponse(struct soap *soap, _rci__GetSystemPowerStateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__rci__GetSystemPowerStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_rci__GetSystemPowerStateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__rci__GetSystemPowerStateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _rci__GetSystemPowerStateResponse * SOAP_FMAC4 soap_in__rci__GetSystemPowerStateResponse(struct soap *soap, const char *tag, _rci__GetSystemPowerStateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_rci__GetSystemPowerStateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__rci__GetSystemPowerStateResponse, sizeof(_rci__GetSystemPowerStateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__rci__GetSystemPowerStateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_rci__GetSystemPowerStateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_SystemPowerState1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_rci__PT_USCORESTATUS(soap, "rci:Status", &(((_rci__GetSystemPowerStateResponse*)a)->Status), "rci:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_SystemPowerState1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_rci__SystemPowerStateType(soap, "rci:SystemPowerState", &(((_rci__GetSystemPowerStateResponse*)a)->SystemPowerState), "rci:SystemPowerStateType")) + { soap_flag_SystemPowerState1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "rci:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_SystemPowerState1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_rci__GetSystemPowerStateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__rci__GetSystemPowerStateResponse, 0, sizeof(_rci__GetSystemPowerStateResponse), 0, soap_copy__rci__GetSystemPowerStateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _rci__GetSystemPowerStateResponse * SOAP_FMAC6 soap_new__rci__GetSystemPowerStateResponse(struct soap *soap, int n) +{ return soap_instantiate__rci__GetSystemPowerStateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__GetSystemPowerStateResponse(struct soap *soap, _rci__GetSystemPowerStateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _rci__GetSystemPowerStateResponse * SOAP_FMAC4 soap_instantiate__rci__GetSystemPowerStateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__rci__GetSystemPowerStateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__rci__GetSystemPowerStateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _rci__GetSystemPowerStateResponse; + if (size) + *size = sizeof(_rci__GetSystemPowerStateResponse); + ((_rci__GetSystemPowerStateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _rci__GetSystemPowerStateResponse[n]; + if (size) + *size = n * sizeof(_rci__GetSystemPowerStateResponse); + for (int i = 0; i < n; i++) + ((_rci__GetSystemPowerStateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_rci__GetSystemPowerStateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__GetSystemPowerStateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _rci__GetSystemPowerStateResponse %p -> %p\n", q, p)); + *(_rci__GetSystemPowerStateResponse*)p = *(_rci__GetSystemPowerStateResponse*)q; +} + +void _rci__GetSystemPowerState::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _rci__GetSystemPowerState::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _rci__GetSystemPowerState::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__rci__GetSystemPowerState); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _rci__GetSystemPowerState::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__rci__GetSystemPowerState(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__GetSystemPowerState(struct soap *soap, const char *tag, int id, const _rci__GetSystemPowerState *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__rci__GetSystemPowerState), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_rci__GetSystemPowerState::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__rci__GetSystemPowerState(soap, this, tag, type); +} + +SOAP_FMAC3 _rci__GetSystemPowerState * SOAP_FMAC4 soap_get__rci__GetSystemPowerState(struct soap *soap, _rci__GetSystemPowerState *p, const char *tag, const char *type) +{ + if ((p = soap_in__rci__GetSystemPowerState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_rci__GetSystemPowerState::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__rci__GetSystemPowerState(soap, tag, this, type); +} + +SOAP_FMAC3 _rci__GetSystemPowerState * SOAP_FMAC4 soap_in__rci__GetSystemPowerState(struct soap *soap, const char *tag, _rci__GetSystemPowerState *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_rci__GetSystemPowerState *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__rci__GetSystemPowerState, sizeof(_rci__GetSystemPowerState), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__rci__GetSystemPowerState) + { soap_revert(soap); + *soap->id = '\0'; + return (_rci__GetSystemPowerState *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_rci__GetSystemPowerState *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__rci__GetSystemPowerState, 0, sizeof(_rci__GetSystemPowerState), 0, soap_copy__rci__GetSystemPowerState); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _rci__GetSystemPowerState * SOAP_FMAC6 soap_new__rci__GetSystemPowerState(struct soap *soap, int n) +{ return soap_instantiate__rci__GetSystemPowerState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__GetSystemPowerState(struct soap *soap, _rci__GetSystemPowerState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _rci__GetSystemPowerState * SOAP_FMAC4 soap_instantiate__rci__GetSystemPowerState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__rci__GetSystemPowerState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__rci__GetSystemPowerState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _rci__GetSystemPowerState; + if (size) + *size = sizeof(_rci__GetSystemPowerState); + ((_rci__GetSystemPowerState*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _rci__GetSystemPowerState[n]; + if (size) + *size = n * sizeof(_rci__GetSystemPowerState); + for (int i = 0; i < n; i++) + ((_rci__GetSystemPowerState*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_rci__GetSystemPowerState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__GetSystemPowerState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _rci__GetSystemPowerState %p -> %p\n", q, p)); + *(_rci__GetSystemPowerState*)p = *(_rci__GetSystemPowerState*)q; +} + +void _rci__RemoteControlResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _rci__RemoteControlResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_rci__PT_USCORESTATUS(soap, &((_rci__RemoteControlResponse*)this)->Status); + /* transient soap skipped */ +} + +int _rci__RemoteControlResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__rci__RemoteControlResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _rci__RemoteControlResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__rci__RemoteControlResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__RemoteControlResponse(struct soap *soap, const char *tag, int id, const _rci__RemoteControlResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__rci__RemoteControlResponse), type); + soap_element_result(soap, "rci:Status"); + soap_out_rci__PT_USCORESTATUS(soap, "rci:Status", -1, &(((_rci__RemoteControlResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_rci__RemoteControlResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__rci__RemoteControlResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _rci__RemoteControlResponse * SOAP_FMAC4 soap_get__rci__RemoteControlResponse(struct soap *soap, _rci__RemoteControlResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__rci__RemoteControlResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_rci__RemoteControlResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__rci__RemoteControlResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _rci__RemoteControlResponse * SOAP_FMAC4 soap_in__rci__RemoteControlResponse(struct soap *soap, const char *tag, _rci__RemoteControlResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_rci__RemoteControlResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__rci__RemoteControlResponse, sizeof(_rci__RemoteControlResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__rci__RemoteControlResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_rci__RemoteControlResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_rci__PT_USCORESTATUS(soap, "rci:Status", &(((_rci__RemoteControlResponse*)a)->Status), "rci:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "rci:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_rci__RemoteControlResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__rci__RemoteControlResponse, 0, sizeof(_rci__RemoteControlResponse), 0, soap_copy__rci__RemoteControlResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _rci__RemoteControlResponse * SOAP_FMAC6 soap_new__rci__RemoteControlResponse(struct soap *soap, int n) +{ return soap_instantiate__rci__RemoteControlResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__RemoteControlResponse(struct soap *soap, _rci__RemoteControlResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _rci__RemoteControlResponse * SOAP_FMAC4 soap_instantiate__rci__RemoteControlResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__rci__RemoteControlResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__rci__RemoteControlResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _rci__RemoteControlResponse; + if (size) + *size = sizeof(_rci__RemoteControlResponse); + ((_rci__RemoteControlResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _rci__RemoteControlResponse[n]; + if (size) + *size = n * sizeof(_rci__RemoteControlResponse); + for (int i = 0; i < n; i++) + ((_rci__RemoteControlResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_rci__RemoteControlResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__RemoteControlResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _rci__RemoteControlResponse %p -> %p\n", q, p)); + *(_rci__RemoteControlResponse*)p = *(_rci__RemoteControlResponse*)q; +} + +void _rci__RemoteControl::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_rci__RemoteControl*)this)->IanaOemNumber, SOAP_TYPE_unsignedInt); + soap_serialize_PointerTorci__SpecialCommandType(soap, &((_rci__RemoteControl*)this)->SpecialCommand); + soap_serialize_PointerTorci__SpecialCommandParameterType(soap, &((_rci__RemoteControl*)this)->SpecialCommandParameter); + soap_serialize_PointerTorci__BootOptionsType(soap, &((_rci__RemoteControl*)this)->BootOptions); + soap_serialize_PointerTorci__OemParametersType(soap, &((_rci__RemoteControl*)this)->OEMparameters); + /* transient soap skipped */ +} + +void _rci__RemoteControl::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_rci__RemoteControlCommandType(soap, &((_rci__RemoteControl*)this)->Command); + soap_default_unsignedInt(soap, &((_rci__RemoteControl*)this)->IanaOemNumber); + ((_rci__RemoteControl*)this)->SpecialCommand = NULL; + ((_rci__RemoteControl*)this)->SpecialCommandParameter = NULL; + ((_rci__RemoteControl*)this)->BootOptions = NULL; + ((_rci__RemoteControl*)this)->OEMparameters = NULL; + /* transient soap skipped */ +} + +int _rci__RemoteControl::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__rci__RemoteControl); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _rci__RemoteControl::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__rci__RemoteControl(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__RemoteControl(struct soap *soap, const char *tag, int id, const _rci__RemoteControl *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__rci__RemoteControl), type); + soap_out_rci__RemoteControlCommandType(soap, "rci:Command", -1, &(((_rci__RemoteControl*)a)->Command), ""); + soap_out_unsignedInt(soap, "rci:IanaOemNumber", -1, &(((_rci__RemoteControl*)a)->IanaOemNumber), ""); + soap_out_PointerTorci__SpecialCommandType(soap, "rci:SpecialCommand", -1, &(((_rci__RemoteControl*)a)->SpecialCommand), ""); + soap_out_PointerTorci__SpecialCommandParameterType(soap, "rci:SpecialCommandParameter", -1, &(((_rci__RemoteControl*)a)->SpecialCommandParameter), ""); + soap_out_PointerTorci__BootOptionsType(soap, "rci:BootOptions", -1, &(((_rci__RemoteControl*)a)->BootOptions), ""); + soap_out_PointerTorci__OemParametersType(soap, "rci:OEMparameters", -1, &(((_rci__RemoteControl*)a)->OEMparameters), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_rci__RemoteControl::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__rci__RemoteControl(soap, this, tag, type); +} + +SOAP_FMAC3 _rci__RemoteControl * SOAP_FMAC4 soap_get__rci__RemoteControl(struct soap *soap, _rci__RemoteControl *p, const char *tag, const char *type) +{ + if ((p = soap_in__rci__RemoteControl(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_rci__RemoteControl::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__rci__RemoteControl(soap, tag, this, type); +} + +SOAP_FMAC3 _rci__RemoteControl * SOAP_FMAC4 soap_in__rci__RemoteControl(struct soap *soap, const char *tag, _rci__RemoteControl *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_rci__RemoteControl *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__rci__RemoteControl, sizeof(_rci__RemoteControl), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__rci__RemoteControl) + { soap_revert(soap); + *soap->id = '\0'; + return (_rci__RemoteControl *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Command1 = 1, soap_flag_IanaOemNumber1 = 1, soap_flag_SpecialCommand1 = 1, soap_flag_SpecialCommandParameter1 = 1, soap_flag_BootOptions1 = 1, soap_flag_OEMparameters1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Command1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_rci__RemoteControlCommandType(soap, "rci:Command", &(((_rci__RemoteControl*)a)->Command), "rci:RemoteControlCommandType")) + { soap_flag_Command1--; + continue; + } + if (soap_flag_IanaOemNumber1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "rci:IanaOemNumber", &(((_rci__RemoteControl*)a)->IanaOemNumber), "xsd:unsignedInt")) + { soap_flag_IanaOemNumber1--; + continue; + } + if (soap_flag_SpecialCommand1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTorci__SpecialCommandType(soap, "rci:SpecialCommand", &(((_rci__RemoteControl*)a)->SpecialCommand), "rci:SpecialCommandType")) + { soap_flag_SpecialCommand1--; + continue; + } + if (soap_flag_SpecialCommandParameter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTorci__SpecialCommandParameterType(soap, "rci:SpecialCommandParameter", &(((_rci__RemoteControl*)a)->SpecialCommandParameter), "rci:SpecialCommandParameterType")) + { soap_flag_SpecialCommandParameter1--; + continue; + } + if (soap_flag_BootOptions1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTorci__BootOptionsType(soap, "rci:BootOptions", &(((_rci__RemoteControl*)a)->BootOptions), "rci:BootOptionsType")) + { soap_flag_BootOptions1--; + continue; + } + if (soap_flag_OEMparameters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTorci__OemParametersType(soap, "rci:OEMparameters", &(((_rci__RemoteControl*)a)->OEMparameters), "rci:OemParametersType")) + { soap_flag_OEMparameters1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Command1 > 0 || soap_flag_IanaOemNumber1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_rci__RemoteControl *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__rci__RemoteControl, 0, sizeof(_rci__RemoteControl), 0, soap_copy__rci__RemoteControl); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _rci__RemoteControl * SOAP_FMAC6 soap_new__rci__RemoteControl(struct soap *soap, int n) +{ return soap_instantiate__rci__RemoteControl(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__RemoteControl(struct soap *soap, _rci__RemoteControl *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _rci__RemoteControl * SOAP_FMAC4 soap_instantiate__rci__RemoteControl(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__rci__RemoteControl(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__rci__RemoteControl, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _rci__RemoteControl; + if (size) + *size = sizeof(_rci__RemoteControl); + ((_rci__RemoteControl*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _rci__RemoteControl[n]; + if (size) + *size = n * sizeof(_rci__RemoteControl); + for (int i = 0; i < n; i++) + ((_rci__RemoteControl*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_rci__RemoteControl*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__RemoteControl(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _rci__RemoteControl %p -> %p\n", q, p)); + *(_rci__RemoteControl*)p = *(_rci__RemoteControl*)q; +} + +void _rci__GetRemoteControlCapabilitiesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_rci__GetRemoteControlCapabilitiesResponse*)this)->IanaOemNumber, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _rci__GetRemoteControlCapabilitiesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_rci__PT_USCORESTATUS(soap, &((_rci__GetRemoteControlCapabilitiesResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_rci__GetRemoteControlCapabilitiesResponse*)this)->IanaOemNumber); + soap_default_rci__OemDefinedCapabilitiesType(soap, &((_rci__GetRemoteControlCapabilitiesResponse*)this)->OemDefinedCapabilities); + soap_default_rci__SpecialCommandsSupportedType(soap, &((_rci__GetRemoteControlCapabilitiesResponse*)this)->SpecialCommandsSupported); + soap_default_rci__SystemCapabilitiesSupportedType(soap, &((_rci__GetRemoteControlCapabilitiesResponse*)this)->SystemCapabilitiesSupported); + soap_default_rci__SystemFirmwareCapabilitiesType(soap, &((_rci__GetRemoteControlCapabilitiesResponse*)this)->SystemFirmwareCapabilities); + /* transient soap skipped */ +} + +int _rci__GetRemoteControlCapabilitiesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _rci__GetRemoteControlCapabilitiesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__rci__GetRemoteControlCapabilitiesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, const char *tag, int id, const _rci__GetRemoteControlCapabilitiesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse), type); + soap_element_result(soap, "rci:Status"); + soap_out_rci__PT_USCORESTATUS(soap, "rci:Status", -1, &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "rci:IanaOemNumber", -1, &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->IanaOemNumber), ""); + soap_out_rci__OemDefinedCapabilitiesType(soap, "rci:OemDefinedCapabilities", -1, &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->OemDefinedCapabilities), ""); + soap_out_rci__SpecialCommandsSupportedType(soap, "rci:SpecialCommandsSupported", -1, &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->SpecialCommandsSupported), ""); + soap_out_rci__SystemCapabilitiesSupportedType(soap, "rci:SystemCapabilitiesSupported", -1, &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->SystemCapabilitiesSupported), ""); + soap_out_rci__SystemFirmwareCapabilitiesType(soap, "rci:SystemFirmwareCapabilities", -1, &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->SystemFirmwareCapabilities), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_rci__GetRemoteControlCapabilitiesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__rci__GetRemoteControlCapabilitiesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse * SOAP_FMAC4 soap_get__rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, _rci__GetRemoteControlCapabilitiesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__rci__GetRemoteControlCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_rci__GetRemoteControlCapabilitiesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__rci__GetRemoteControlCapabilitiesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse * SOAP_FMAC4 soap_in__rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, const char *tag, _rci__GetRemoteControlCapabilitiesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_rci__GetRemoteControlCapabilitiesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse, sizeof(_rci__GetRemoteControlCapabilitiesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_rci__GetRemoteControlCapabilitiesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_IanaOemNumber1 = 1, soap_flag_OemDefinedCapabilities1 = 1, soap_flag_SpecialCommandsSupported1 = 1, soap_flag_SystemCapabilitiesSupported1 = 1, soap_flag_SystemFirmwareCapabilities1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_rci__PT_USCORESTATUS(soap, "rci:Status", &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->Status), "rci:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_IanaOemNumber1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "rci:IanaOemNumber", &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->IanaOemNumber), "xsd:unsignedInt")) + { soap_flag_IanaOemNumber1--; + continue; + } + if (soap_flag_OemDefinedCapabilities1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_rci__OemDefinedCapabilitiesType(soap, "rci:OemDefinedCapabilities", &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->OemDefinedCapabilities), "rci:OemDefinedCapabilitiesType")) + { soap_flag_OemDefinedCapabilities1--; + continue; + } + if (soap_flag_SpecialCommandsSupported1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_rci__SpecialCommandsSupportedType(soap, "rci:SpecialCommandsSupported", &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->SpecialCommandsSupported), "rci:SpecialCommandsSupportedType")) + { soap_flag_SpecialCommandsSupported1--; + continue; + } + if (soap_flag_SystemCapabilitiesSupported1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_rci__SystemCapabilitiesSupportedType(soap, "rci:SystemCapabilitiesSupported", &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->SystemCapabilitiesSupported), "rci:SystemCapabilitiesSupportedType")) + { soap_flag_SystemCapabilitiesSupported1--; + continue; + } + if (soap_flag_SystemFirmwareCapabilities1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_rci__SystemFirmwareCapabilitiesType(soap, "rci:SystemFirmwareCapabilities", &(((_rci__GetRemoteControlCapabilitiesResponse*)a)->SystemFirmwareCapabilities), "rci:SystemFirmwareCapabilitiesType")) + { soap_flag_SystemFirmwareCapabilities1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "rci:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_IanaOemNumber1 > 0 || soap_flag_OemDefinedCapabilities1 > 0 || soap_flag_SpecialCommandsSupported1 > 0 || soap_flag_SystemCapabilitiesSupported1 > 0 || soap_flag_SystemFirmwareCapabilities1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_rci__GetRemoteControlCapabilitiesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse, 0, sizeof(_rci__GetRemoteControlCapabilitiesResponse), 0, soap_copy__rci__GetRemoteControlCapabilitiesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _rci__GetRemoteControlCapabilitiesResponse * SOAP_FMAC6 soap_new__rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, int n) +{ return soap_instantiate__rci__GetRemoteControlCapabilitiesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, _rci__GetRemoteControlCapabilitiesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__rci__GetRemoteControlCapabilitiesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _rci__GetRemoteControlCapabilitiesResponse; + if (size) + *size = sizeof(_rci__GetRemoteControlCapabilitiesResponse); + ((_rci__GetRemoteControlCapabilitiesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _rci__GetRemoteControlCapabilitiesResponse[n]; + if (size) + *size = n * sizeof(_rci__GetRemoteControlCapabilitiesResponse); + for (int i = 0; i < n; i++) + ((_rci__GetRemoteControlCapabilitiesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_rci__GetRemoteControlCapabilitiesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _rci__GetRemoteControlCapabilitiesResponse %p -> %p\n", q, p)); + *(_rci__GetRemoteControlCapabilitiesResponse*)p = *(_rci__GetRemoteControlCapabilitiesResponse*)q; +} + +void _rci__GetRemoteControlCapabilities::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _rci__GetRemoteControlCapabilities::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _rci__GetRemoteControlCapabilities::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__rci__GetRemoteControlCapabilities); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _rci__GetRemoteControlCapabilities::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__rci__GetRemoteControlCapabilities(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__rci__GetRemoteControlCapabilities(struct soap *soap, const char *tag, int id, const _rci__GetRemoteControlCapabilities *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__rci__GetRemoteControlCapabilities), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_rci__GetRemoteControlCapabilities::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__rci__GetRemoteControlCapabilities(soap, this, tag, type); +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_get__rci__GetRemoteControlCapabilities(struct soap *soap, _rci__GetRemoteControlCapabilities *p, const char *tag, const char *type) +{ + if ((p = soap_in__rci__GetRemoteControlCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_rci__GetRemoteControlCapabilities::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__rci__GetRemoteControlCapabilities(soap, tag, this, type); +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_in__rci__GetRemoteControlCapabilities(struct soap *soap, const char *tag, _rci__GetRemoteControlCapabilities *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_rci__GetRemoteControlCapabilities *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__rci__GetRemoteControlCapabilities, sizeof(_rci__GetRemoteControlCapabilities), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__rci__GetRemoteControlCapabilities) + { soap_revert(soap); + *soap->id = '\0'; + return (_rci__GetRemoteControlCapabilities *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_rci__GetRemoteControlCapabilities *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__rci__GetRemoteControlCapabilities, 0, sizeof(_rci__GetRemoteControlCapabilities), 0, soap_copy__rci__GetRemoteControlCapabilities); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _rci__GetRemoteControlCapabilities * SOAP_FMAC6 soap_new__rci__GetRemoteControlCapabilities(struct soap *soap, int n) +{ return soap_instantiate__rci__GetRemoteControlCapabilities(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__rci__GetRemoteControlCapabilities(struct soap *soap, _rci__GetRemoteControlCapabilities *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_instantiate__rci__GetRemoteControlCapabilities(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__rci__GetRemoteControlCapabilities(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__rci__GetRemoteControlCapabilities, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _rci__GetRemoteControlCapabilities; + if (size) + *size = sizeof(_rci__GetRemoteControlCapabilities); + ((_rci__GetRemoteControlCapabilities*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _rci__GetRemoteControlCapabilities[n]; + if (size) + *size = n * sizeof(_rci__GetRemoteControlCapabilities); + for (int i = 0; i < n; i++) + ((_rci__GetRemoteControlCapabilities*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_rci__GetRemoteControlCapabilities*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__rci__GetRemoteControlCapabilities(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _rci__GetRemoteControlCapabilities %p -> %p\n", q, p)); + *(_rci__GetRemoteControlCapabilities*)p = *(_rci__GetRemoteControlCapabilities*)q; +} + +void _inf__GetIderSessionLogResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(soap, &((_inf__GetIderSessionLogResponse*)this)->LogData); + /* transient soap skipped */ +} + +void _inf__GetIderSessionLogResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetIderSessionLogResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(soap, &((_inf__GetIderSessionLogResponse*)this)->LogData); + /* transient soap skipped */ +} + +int _inf__GetIderSessionLogResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetIderSessionLogResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetIderSessionLogResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetIderSessionLogResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetIderSessionLogResponse(struct soap *soap, const char *tag, int id, const _inf__GetIderSessionLogResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetIderSessionLogResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetIderSessionLogResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(soap, "inf:LogData", -1, &(((_inf__GetIderSessionLogResponse*)a)->LogData), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetIderSessionLogResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetIderSessionLogResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetIderSessionLogResponse * SOAP_FMAC4 soap_get__inf__GetIderSessionLogResponse(struct soap *soap, _inf__GetIderSessionLogResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetIderSessionLogResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetIderSessionLogResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetIderSessionLogResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetIderSessionLogResponse * SOAP_FMAC4 soap_in__inf__GetIderSessionLogResponse(struct soap *soap, const char *tag, _inf__GetIderSessionLogResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetIderSessionLogResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetIderSessionLogResponse, sizeof(_inf__GetIderSessionLogResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetIderSessionLogResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetIderSessionLogResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetIderSessionLogResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(soap, "inf:LogData", &(((_inf__GetIderSessionLogResponse*)a)->LogData), "inf:IderSessionLogEntryType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetIderSessionLogResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetIderSessionLogResponse, 0, sizeof(_inf__GetIderSessionLogResponse), 0, soap_copy__inf__GetIderSessionLogResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetIderSessionLogResponse * SOAP_FMAC6 soap_new__inf__GetIderSessionLogResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetIderSessionLogResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetIderSessionLogResponse(struct soap *soap, _inf__GetIderSessionLogResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetIderSessionLogResponse * SOAP_FMAC4 soap_instantiate__inf__GetIderSessionLogResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetIderSessionLogResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetIderSessionLogResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetIderSessionLogResponse; + if (size) + *size = sizeof(_inf__GetIderSessionLogResponse); + ((_inf__GetIderSessionLogResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetIderSessionLogResponse[n]; + if (size) + *size = n * sizeof(_inf__GetIderSessionLogResponse); + for (int i = 0; i < n; i++) + ((_inf__GetIderSessionLogResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetIderSessionLogResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetIderSessionLogResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetIderSessionLogResponse %p -> %p\n", q, p)); + *(_inf__GetIderSessionLogResponse*)p = *(_inf__GetIderSessionLogResponse*)q; +} + +void _inf__GetIderSessionLog::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetIderSessionLog::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetIderSessionLog::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetIderSessionLog); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetIderSessionLog::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetIderSessionLog(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetIderSessionLog(struct soap *soap, const char *tag, int id, const _inf__GetIderSessionLog *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetIderSessionLog), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetIderSessionLog::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetIderSessionLog(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetIderSessionLog * SOAP_FMAC4 soap_get__inf__GetIderSessionLog(struct soap *soap, _inf__GetIderSessionLog *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetIderSessionLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetIderSessionLog::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetIderSessionLog(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetIderSessionLog * SOAP_FMAC4 soap_in__inf__GetIderSessionLog(struct soap *soap, const char *tag, _inf__GetIderSessionLog *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetIderSessionLog *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetIderSessionLog, sizeof(_inf__GetIderSessionLog), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetIderSessionLog) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetIderSessionLog *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetIderSessionLog *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetIderSessionLog, 0, sizeof(_inf__GetIderSessionLog), 0, soap_copy__inf__GetIderSessionLog); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetIderSessionLog * SOAP_FMAC6 soap_new__inf__GetIderSessionLog(struct soap *soap, int n) +{ return soap_instantiate__inf__GetIderSessionLog(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetIderSessionLog(struct soap *soap, _inf__GetIderSessionLog *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetIderSessionLog * SOAP_FMAC4 soap_instantiate__inf__GetIderSessionLog(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetIderSessionLog(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetIderSessionLog, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetIderSessionLog; + if (size) + *size = sizeof(_inf__GetIderSessionLog); + ((_inf__GetIderSessionLog*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetIderSessionLog[n]; + if (size) + *size = n * sizeof(_inf__GetIderSessionLog); + for (int i = 0; i < n; i++) + ((_inf__GetIderSessionLog*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetIderSessionLog*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetIderSessionLog(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetIderSessionLog %p -> %p\n", q, p)); + *(_inf__GetIderSessionLog*)p = *(_inf__GetIderSessionLog*)q; +} + +void _inf__GetSecurityParametersResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_inf__GetSecurityParametersResponse*)this)->EnterpriseMode, SOAP_TYPE_bool); + soap_embedded(soap, &((_inf__GetSecurityParametersResponse*)this)->TlsEnabled, SOAP_TYPE_bool); + soap_embedded(soap, &((_inf__GetSecurityParametersResponse*)this)->HwCryptoEnabled, SOAP_TYPE_bool); + soap_embedded(soap, &((_inf__GetSecurityParametersResponse*)this)->NetworkInterfaceEnabled, SOAP_TYPE_bool); + soap_embedded(soap, &((_inf__GetSecurityParametersResponse*)this)->SOLEnabled, SOAP_TYPE_bool); + soap_embedded(soap, &((_inf__GetSecurityParametersResponse*)this)->IDEREnabled, SOAP_TYPE_bool); + soap_embedded(soap, &((_inf__GetSecurityParametersResponse*)this)->FWUpdateEnabled, SOAP_TYPE_bool); + soap_embedded(soap, &((_inf__GetSecurityParametersResponse*)this)->LinkIsUp, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _inf__GetSecurityParametersResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetSecurityParametersResponse*)this)->StatusCode); + soap_default_bool(soap, &((_inf__GetSecurityParametersResponse*)this)->EnterpriseMode); + soap_default_bool(soap, &((_inf__GetSecurityParametersResponse*)this)->TlsEnabled); + soap_default_bool(soap, &((_inf__GetSecurityParametersResponse*)this)->HwCryptoEnabled); + soap_default_inf__ProvisioningStateType(soap, &((_inf__GetSecurityParametersResponse*)this)->ProvisioningState); + soap_default_bool(soap, &((_inf__GetSecurityParametersResponse*)this)->NetworkInterfaceEnabled); + soap_default_bool(soap, &((_inf__GetSecurityParametersResponse*)this)->SOLEnabled); + soap_default_bool(soap, &((_inf__GetSecurityParametersResponse*)this)->IDEREnabled); + soap_default_bool(soap, &((_inf__GetSecurityParametersResponse*)this)->FWUpdateEnabled); + soap_default_bool(soap, &((_inf__GetSecurityParametersResponse*)this)->LinkIsUp); + /* transient soap skipped */ +} + +int _inf__GetSecurityParametersResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetSecurityParametersResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetSecurityParametersResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetSecurityParametersResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetSecurityParametersResponse(struct soap *soap, const char *tag, int id, const _inf__GetSecurityParametersResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetSecurityParametersResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetSecurityParametersResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "inf:EnterpriseMode", -1, &(((_inf__GetSecurityParametersResponse*)a)->EnterpriseMode), ""); + soap_out_bool(soap, "inf:TlsEnabled", -1, &(((_inf__GetSecurityParametersResponse*)a)->TlsEnabled), ""); + soap_out_bool(soap, "inf:HwCryptoEnabled", -1, &(((_inf__GetSecurityParametersResponse*)a)->HwCryptoEnabled), ""); + soap_out_inf__ProvisioningStateType(soap, "inf:ProvisioningState", -1, &(((_inf__GetSecurityParametersResponse*)a)->ProvisioningState), ""); + soap_out_bool(soap, "inf:NetworkInterfaceEnabled", -1, &(((_inf__GetSecurityParametersResponse*)a)->NetworkInterfaceEnabled), ""); + soap_out_bool(soap, "inf:SOLEnabled", -1, &(((_inf__GetSecurityParametersResponse*)a)->SOLEnabled), ""); + soap_out_bool(soap, "inf:IDEREnabled", -1, &(((_inf__GetSecurityParametersResponse*)a)->IDEREnabled), ""); + soap_out_bool(soap, "inf:FWUpdateEnabled", -1, &(((_inf__GetSecurityParametersResponse*)a)->FWUpdateEnabled), ""); + soap_out_bool(soap, "inf:LinkIsUp", -1, &(((_inf__GetSecurityParametersResponse*)a)->LinkIsUp), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetSecurityParametersResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetSecurityParametersResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetSecurityParametersResponse * SOAP_FMAC4 soap_get__inf__GetSecurityParametersResponse(struct soap *soap, _inf__GetSecurityParametersResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetSecurityParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetSecurityParametersResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetSecurityParametersResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetSecurityParametersResponse * SOAP_FMAC4 soap_in__inf__GetSecurityParametersResponse(struct soap *soap, const char *tag, _inf__GetSecurityParametersResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetSecurityParametersResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetSecurityParametersResponse, sizeof(_inf__GetSecurityParametersResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetSecurityParametersResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetSecurityParametersResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_EnterpriseMode1 = 1, soap_flag_TlsEnabled1 = 1, soap_flag_HwCryptoEnabled1 = 1, soap_flag_ProvisioningState1 = 1, soap_flag_NetworkInterfaceEnabled1 = 1, soap_flag_SOLEnabled1 = 1, soap_flag_IDEREnabled1 = 1, soap_flag_FWUpdateEnabled1 = 1, soap_flag_LinkIsUp1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetSecurityParametersResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_EnterpriseMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:EnterpriseMode", &(((_inf__GetSecurityParametersResponse*)a)->EnterpriseMode), "xsd:boolean")) + { soap_flag_EnterpriseMode1--; + continue; + } + if (soap_flag_TlsEnabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:TlsEnabled", &(((_inf__GetSecurityParametersResponse*)a)->TlsEnabled), "xsd:boolean")) + { soap_flag_TlsEnabled1--; + continue; + } + if (soap_flag_HwCryptoEnabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:HwCryptoEnabled", &(((_inf__GetSecurityParametersResponse*)a)->HwCryptoEnabled), "xsd:boolean")) + { soap_flag_HwCryptoEnabled1--; + continue; + } + if (soap_flag_ProvisioningState1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__ProvisioningStateType(soap, "inf:ProvisioningState", &(((_inf__GetSecurityParametersResponse*)a)->ProvisioningState), "inf:ProvisioningStateType")) + { soap_flag_ProvisioningState1--; + continue; + } + if (soap_flag_NetworkInterfaceEnabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:NetworkInterfaceEnabled", &(((_inf__GetSecurityParametersResponse*)a)->NetworkInterfaceEnabled), "xsd:boolean")) + { soap_flag_NetworkInterfaceEnabled1--; + continue; + } + if (soap_flag_SOLEnabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:SOLEnabled", &(((_inf__GetSecurityParametersResponse*)a)->SOLEnabled), "xsd:boolean")) + { soap_flag_SOLEnabled1--; + continue; + } + if (soap_flag_IDEREnabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:IDEREnabled", &(((_inf__GetSecurityParametersResponse*)a)->IDEREnabled), "xsd:boolean")) + { soap_flag_IDEREnabled1--; + continue; + } + if (soap_flag_FWUpdateEnabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:FWUpdateEnabled", &(((_inf__GetSecurityParametersResponse*)a)->FWUpdateEnabled), "xsd:boolean")) + { soap_flag_FWUpdateEnabled1--; + continue; + } + if (soap_flag_LinkIsUp1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:LinkIsUp", &(((_inf__GetSecurityParametersResponse*)a)->LinkIsUp), "xsd:boolean")) + { soap_flag_LinkIsUp1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_EnterpriseMode1 > 0 || soap_flag_TlsEnabled1 > 0 || soap_flag_HwCryptoEnabled1 > 0 || soap_flag_ProvisioningState1 > 0 || soap_flag_NetworkInterfaceEnabled1 > 0 || soap_flag_SOLEnabled1 > 0 || soap_flag_IDEREnabled1 > 0 || soap_flag_FWUpdateEnabled1 > 0 || soap_flag_LinkIsUp1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetSecurityParametersResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetSecurityParametersResponse, 0, sizeof(_inf__GetSecurityParametersResponse), 0, soap_copy__inf__GetSecurityParametersResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetSecurityParametersResponse * SOAP_FMAC6 soap_new__inf__GetSecurityParametersResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetSecurityParametersResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetSecurityParametersResponse(struct soap *soap, _inf__GetSecurityParametersResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetSecurityParametersResponse * SOAP_FMAC4 soap_instantiate__inf__GetSecurityParametersResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetSecurityParametersResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetSecurityParametersResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetSecurityParametersResponse; + if (size) + *size = sizeof(_inf__GetSecurityParametersResponse); + ((_inf__GetSecurityParametersResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetSecurityParametersResponse[n]; + if (size) + *size = n * sizeof(_inf__GetSecurityParametersResponse); + for (int i = 0; i < n; i++) + ((_inf__GetSecurityParametersResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetSecurityParametersResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetSecurityParametersResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetSecurityParametersResponse %p -> %p\n", q, p)); + *(_inf__GetSecurityParametersResponse*)p = *(_inf__GetSecurityParametersResponse*)q; +} + +void _inf__GetSecurityParameters::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetSecurityParameters::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetSecurityParameters::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetSecurityParameters); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetSecurityParameters::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetSecurityParameters(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetSecurityParameters(struct soap *soap, const char *tag, int id, const _inf__GetSecurityParameters *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetSecurityParameters), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetSecurityParameters::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetSecurityParameters(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetSecurityParameters * SOAP_FMAC4 soap_get__inf__GetSecurityParameters(struct soap *soap, _inf__GetSecurityParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetSecurityParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetSecurityParameters::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetSecurityParameters(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetSecurityParameters * SOAP_FMAC4 soap_in__inf__GetSecurityParameters(struct soap *soap, const char *tag, _inf__GetSecurityParameters *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetSecurityParameters *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetSecurityParameters, sizeof(_inf__GetSecurityParameters), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetSecurityParameters) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetSecurityParameters *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetSecurityParameters *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetSecurityParameters, 0, sizeof(_inf__GetSecurityParameters), 0, soap_copy__inf__GetSecurityParameters); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetSecurityParameters * SOAP_FMAC6 soap_new__inf__GetSecurityParameters(struct soap *soap, int n) +{ return soap_instantiate__inf__GetSecurityParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetSecurityParameters(struct soap *soap, _inf__GetSecurityParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetSecurityParameters * SOAP_FMAC4 soap_instantiate__inf__GetSecurityParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetSecurityParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetSecurityParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetSecurityParameters; + if (size) + *size = sizeof(_inf__GetSecurityParameters); + ((_inf__GetSecurityParameters*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetSecurityParameters[n]; + if (size) + *size = n * sizeof(_inf__GetSecurityParameters); + for (int i = 0; i < n; i++) + ((_inf__GetSecurityParameters*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetSecurityParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetSecurityParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetSecurityParameters %p -> %p\n", q, p)); + *(_inf__GetSecurityParameters*)p = *(_inf__GetSecurityParameters*)q; +} + +void _inf__GetNetworkStateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_inf__GetNetworkStateResponse*)this)->IsEnabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _inf__GetNetworkStateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetNetworkStateResponse*)this)->StatusCode); + soap_default_bool(soap, &((_inf__GetNetworkStateResponse*)this)->IsEnabled); + /* transient soap skipped */ +} + +int _inf__GetNetworkStateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetNetworkStateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetNetworkStateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetNetworkStateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetNetworkStateResponse(struct soap *soap, const char *tag, int id, const _inf__GetNetworkStateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetNetworkStateResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetNetworkStateResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "inf:IsEnabled", -1, &(((_inf__GetNetworkStateResponse*)a)->IsEnabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetNetworkStateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetNetworkStateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetNetworkStateResponse * SOAP_FMAC4 soap_get__inf__GetNetworkStateResponse(struct soap *soap, _inf__GetNetworkStateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetNetworkStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetNetworkStateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetNetworkStateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetNetworkStateResponse * SOAP_FMAC4 soap_in__inf__GetNetworkStateResponse(struct soap *soap, const char *tag, _inf__GetNetworkStateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetNetworkStateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetNetworkStateResponse, sizeof(_inf__GetNetworkStateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetNetworkStateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetNetworkStateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_IsEnabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetNetworkStateResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_IsEnabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:IsEnabled", &(((_inf__GetNetworkStateResponse*)a)->IsEnabled), "xsd:boolean")) + { soap_flag_IsEnabled1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_IsEnabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetNetworkStateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetNetworkStateResponse, 0, sizeof(_inf__GetNetworkStateResponse), 0, soap_copy__inf__GetNetworkStateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetNetworkStateResponse * SOAP_FMAC6 soap_new__inf__GetNetworkStateResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetNetworkStateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetNetworkStateResponse(struct soap *soap, _inf__GetNetworkStateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetNetworkStateResponse * SOAP_FMAC4 soap_instantiate__inf__GetNetworkStateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetNetworkStateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetNetworkStateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetNetworkStateResponse; + if (size) + *size = sizeof(_inf__GetNetworkStateResponse); + ((_inf__GetNetworkStateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetNetworkStateResponse[n]; + if (size) + *size = n * sizeof(_inf__GetNetworkStateResponse); + for (int i = 0; i < n; i++) + ((_inf__GetNetworkStateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetNetworkStateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetNetworkStateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetNetworkStateResponse %p -> %p\n", q, p)); + *(_inf__GetNetworkStateResponse*)p = *(_inf__GetNetworkStateResponse*)q; +} + +void _inf__GetNetworkState::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetNetworkState::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetNetworkState::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetNetworkState); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetNetworkState::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetNetworkState(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetNetworkState(struct soap *soap, const char *tag, int id, const _inf__GetNetworkState *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetNetworkState), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetNetworkState::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetNetworkState(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetNetworkState * SOAP_FMAC4 soap_get__inf__GetNetworkState(struct soap *soap, _inf__GetNetworkState *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetNetworkState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetNetworkState::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetNetworkState(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetNetworkState * SOAP_FMAC4 soap_in__inf__GetNetworkState(struct soap *soap, const char *tag, _inf__GetNetworkState *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetNetworkState *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetNetworkState, sizeof(_inf__GetNetworkState), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetNetworkState) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetNetworkState *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetNetworkState *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetNetworkState, 0, sizeof(_inf__GetNetworkState), 0, soap_copy__inf__GetNetworkState); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetNetworkState * SOAP_FMAC6 soap_new__inf__GetNetworkState(struct soap *soap, int n) +{ return soap_instantiate__inf__GetNetworkState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetNetworkState(struct soap *soap, _inf__GetNetworkState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetNetworkState * SOAP_FMAC4 soap_instantiate__inf__GetNetworkState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetNetworkState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetNetworkState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetNetworkState; + if (size) + *size = sizeof(_inf__GetNetworkState); + ((_inf__GetNetworkState*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetNetworkState[n]; + if (size) + *size = n * sizeof(_inf__GetNetworkState); + for (int i = 0; i < n; i++) + ((_inf__GetNetworkState*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetNetworkState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetNetworkState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetNetworkState %p -> %p\n", q, p)); + *(_inf__GetNetworkState*)p = *(_inf__GetNetworkState*)q; +} + +void _inf__GetEnabledInterfacesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfinf__EnabledInterfacesType(soap, &((_inf__GetEnabledInterfacesResponse*)this)->EnabledInterfaces); + /* transient soap skipped */ +} + +void _inf__GetEnabledInterfacesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetEnabledInterfacesResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfinf__EnabledInterfacesType(soap, &((_inf__GetEnabledInterfacesResponse*)this)->EnabledInterfaces); + /* transient soap skipped */ +} + +int _inf__GetEnabledInterfacesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetEnabledInterfacesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetEnabledInterfacesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetEnabledInterfacesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetEnabledInterfacesResponse(struct soap *soap, const char *tag, int id, const _inf__GetEnabledInterfacesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetEnabledInterfacesResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetEnabledInterfacesResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfinf__EnabledInterfacesType(soap, "inf:EnabledInterfaces", -1, &(((_inf__GetEnabledInterfacesResponse*)a)->EnabledInterfaces), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetEnabledInterfacesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetEnabledInterfacesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_get__inf__GetEnabledInterfacesResponse(struct soap *soap, _inf__GetEnabledInterfacesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetEnabledInterfacesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetEnabledInterfacesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetEnabledInterfacesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_in__inf__GetEnabledInterfacesResponse(struct soap *soap, const char *tag, _inf__GetEnabledInterfacesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetEnabledInterfacesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetEnabledInterfacesResponse, sizeof(_inf__GetEnabledInterfacesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetEnabledInterfacesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetEnabledInterfacesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetEnabledInterfacesResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfinf__EnabledInterfacesType(soap, "inf:EnabledInterfaces", &(((_inf__GetEnabledInterfacesResponse*)a)->EnabledInterfaces), "inf:EnabledInterfacesType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetEnabledInterfacesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetEnabledInterfacesResponse, 0, sizeof(_inf__GetEnabledInterfacesResponse), 0, soap_copy__inf__GetEnabledInterfacesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetEnabledInterfacesResponse * SOAP_FMAC6 soap_new__inf__GetEnabledInterfacesResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetEnabledInterfacesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetEnabledInterfacesResponse(struct soap *soap, _inf__GetEnabledInterfacesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_instantiate__inf__GetEnabledInterfacesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetEnabledInterfacesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetEnabledInterfacesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetEnabledInterfacesResponse; + if (size) + *size = sizeof(_inf__GetEnabledInterfacesResponse); + ((_inf__GetEnabledInterfacesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetEnabledInterfacesResponse[n]; + if (size) + *size = n * sizeof(_inf__GetEnabledInterfacesResponse); + for (int i = 0; i < n; i++) + ((_inf__GetEnabledInterfacesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetEnabledInterfacesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetEnabledInterfacesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetEnabledInterfacesResponse %p -> %p\n", q, p)); + *(_inf__GetEnabledInterfacesResponse*)p = *(_inf__GetEnabledInterfacesResponse*)q; +} + +void _inf__GetEnabledInterfaces::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetEnabledInterfaces::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetEnabledInterfaces::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetEnabledInterfaces); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetEnabledInterfaces::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetEnabledInterfaces(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetEnabledInterfaces(struct soap *soap, const char *tag, int id, const _inf__GetEnabledInterfaces *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetEnabledInterfaces), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetEnabledInterfaces::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetEnabledInterfaces(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetEnabledInterfaces * SOAP_FMAC4 soap_get__inf__GetEnabledInterfaces(struct soap *soap, _inf__GetEnabledInterfaces *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetEnabledInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetEnabledInterfaces::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetEnabledInterfaces(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetEnabledInterfaces * SOAP_FMAC4 soap_in__inf__GetEnabledInterfaces(struct soap *soap, const char *tag, _inf__GetEnabledInterfaces *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetEnabledInterfaces *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetEnabledInterfaces, sizeof(_inf__GetEnabledInterfaces), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetEnabledInterfaces) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetEnabledInterfaces *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetEnabledInterfaces *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetEnabledInterfaces, 0, sizeof(_inf__GetEnabledInterfaces), 0, soap_copy__inf__GetEnabledInterfaces); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetEnabledInterfaces * SOAP_FMAC6 soap_new__inf__GetEnabledInterfaces(struct soap *soap, int n) +{ return soap_instantiate__inf__GetEnabledInterfaces(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetEnabledInterfaces(struct soap *soap, _inf__GetEnabledInterfaces *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetEnabledInterfaces * SOAP_FMAC4 soap_instantiate__inf__GetEnabledInterfaces(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetEnabledInterfaces(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetEnabledInterfaces, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetEnabledInterfaces; + if (size) + *size = sizeof(_inf__GetEnabledInterfaces); + ((_inf__GetEnabledInterfaces*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetEnabledInterfaces[n]; + if (size) + *size = n * sizeof(_inf__GetEnabledInterfaces); + for (int i = 0; i < n; i++) + ((_inf__GetEnabledInterfaces*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetEnabledInterfaces*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetEnabledInterfaces(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetEnabledInterfaces %p -> %p\n", q, p)); + *(_inf__GetEnabledInterfaces*)p = *(_inf__GetEnabledInterfaces*)q; +} + +void _inf__GetPasswordModelResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetPasswordModelResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetPasswordModelResponse*)this)->StatusCode); + soap_default_inf__PasswordModelType(soap, &((_inf__GetPasswordModelResponse*)this)->PasswordModel); + /* transient soap skipped */ +} + +int _inf__GetPasswordModelResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetPasswordModelResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetPasswordModelResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetPasswordModelResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetPasswordModelResponse(struct soap *soap, const char *tag, int id, const _inf__GetPasswordModelResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetPasswordModelResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetPasswordModelResponse*)a)->StatusCode), ""); + soap_out_inf__PasswordModelType(soap, "inf:PasswordModel", -1, &(((_inf__GetPasswordModelResponse*)a)->PasswordModel), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetPasswordModelResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetPasswordModelResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetPasswordModelResponse * SOAP_FMAC4 soap_get__inf__GetPasswordModelResponse(struct soap *soap, _inf__GetPasswordModelResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetPasswordModelResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetPasswordModelResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetPasswordModelResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetPasswordModelResponse * SOAP_FMAC4 soap_in__inf__GetPasswordModelResponse(struct soap *soap, const char *tag, _inf__GetPasswordModelResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetPasswordModelResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetPasswordModelResponse, sizeof(_inf__GetPasswordModelResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetPasswordModelResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetPasswordModelResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_PasswordModel1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetPasswordModelResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_PasswordModel1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PasswordModelType(soap, "inf:PasswordModel", &(((_inf__GetPasswordModelResponse*)a)->PasswordModel), "inf:PasswordModelType")) + { soap_flag_PasswordModel1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_PasswordModel1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetPasswordModelResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetPasswordModelResponse, 0, sizeof(_inf__GetPasswordModelResponse), 0, soap_copy__inf__GetPasswordModelResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetPasswordModelResponse * SOAP_FMAC6 soap_new__inf__GetPasswordModelResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetPasswordModelResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetPasswordModelResponse(struct soap *soap, _inf__GetPasswordModelResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetPasswordModelResponse * SOAP_FMAC4 soap_instantiate__inf__GetPasswordModelResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetPasswordModelResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetPasswordModelResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetPasswordModelResponse; + if (size) + *size = sizeof(_inf__GetPasswordModelResponse); + ((_inf__GetPasswordModelResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetPasswordModelResponse[n]; + if (size) + *size = n * sizeof(_inf__GetPasswordModelResponse); + for (int i = 0; i < n; i++) + ((_inf__GetPasswordModelResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetPasswordModelResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetPasswordModelResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetPasswordModelResponse %p -> %p\n", q, p)); + *(_inf__GetPasswordModelResponse*)p = *(_inf__GetPasswordModelResponse*)q; +} + +void _inf__GetPasswordModel::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetPasswordModel::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetPasswordModel::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetPasswordModel); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetPasswordModel::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetPasswordModel(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetPasswordModel(struct soap *soap, const char *tag, int id, const _inf__GetPasswordModel *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetPasswordModel), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetPasswordModel::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetPasswordModel(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetPasswordModel * SOAP_FMAC4 soap_get__inf__GetPasswordModel(struct soap *soap, _inf__GetPasswordModel *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetPasswordModel(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetPasswordModel::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetPasswordModel(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetPasswordModel * SOAP_FMAC4 soap_in__inf__GetPasswordModel(struct soap *soap, const char *tag, _inf__GetPasswordModel *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetPasswordModel *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetPasswordModel, sizeof(_inf__GetPasswordModel), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetPasswordModel) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetPasswordModel *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetPasswordModel *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetPasswordModel, 0, sizeof(_inf__GetPasswordModel), 0, soap_copy__inf__GetPasswordModel); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetPasswordModel * SOAP_FMAC6 soap_new__inf__GetPasswordModel(struct soap *soap, int n) +{ return soap_instantiate__inf__GetPasswordModel(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetPasswordModel(struct soap *soap, _inf__GetPasswordModel *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetPasswordModel * SOAP_FMAC4 soap_instantiate__inf__GetPasswordModel(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetPasswordModel(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetPasswordModel, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetPasswordModel; + if (size) + *size = sizeof(_inf__GetPasswordModel); + ((_inf__GetPasswordModel*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetPasswordModel[n]; + if (size) + *size = n * sizeof(_inf__GetPasswordModel); + for (int i = 0; i < n; i++) + ((_inf__GetPasswordModel*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetPasswordModel*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetPasswordModel(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetPasswordModel %p -> %p\n", q, p)); + *(_inf__GetPasswordModel*)p = *(_inf__GetPasswordModel*)q; +} + +void _inf__GetAdminNetAclEntryStatusResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_inf__GetAdminNetAclEntryStatusResponse*)this)->IsDefault, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _inf__GetAdminNetAclEntryStatusResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetAdminNetAclEntryStatusResponse*)this)->StatusCode); + soap_default_bool(soap, &((_inf__GetAdminNetAclEntryStatusResponse*)this)->IsDefault); + /* transient soap skipped */ +} + +int _inf__GetAdminNetAclEntryStatusResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetAdminNetAclEntryStatusResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetAdminNetAclEntryStatusResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, const char *tag, int id, const _inf__GetAdminNetAclEntryStatusResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetAdminNetAclEntryStatusResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "inf:IsDefault", -1, &(((_inf__GetAdminNetAclEntryStatusResponse*)a)->IsDefault), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetAdminNetAclEntryStatusResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetAdminNetAclEntryStatusResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse * SOAP_FMAC4 soap_get__inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, _inf__GetAdminNetAclEntryStatusResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetAdminNetAclEntryStatusResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetAdminNetAclEntryStatusResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetAdminNetAclEntryStatusResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse * SOAP_FMAC4 soap_in__inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, const char *tag, _inf__GetAdminNetAclEntryStatusResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetAdminNetAclEntryStatusResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse, sizeof(_inf__GetAdminNetAclEntryStatusResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetAdminNetAclEntryStatusResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_IsDefault1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetAdminNetAclEntryStatusResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_IsDefault1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:IsDefault", &(((_inf__GetAdminNetAclEntryStatusResponse*)a)->IsDefault), "xsd:boolean")) + { soap_flag_IsDefault1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_IsDefault1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetAdminNetAclEntryStatusResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse, 0, sizeof(_inf__GetAdminNetAclEntryStatusResponse), 0, soap_copy__inf__GetAdminNetAclEntryStatusResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetAdminNetAclEntryStatusResponse * SOAP_FMAC6 soap_new__inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetAdminNetAclEntryStatusResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, _inf__GetAdminNetAclEntryStatusResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse * SOAP_FMAC4 soap_instantiate__inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetAdminNetAclEntryStatusResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetAdminNetAclEntryStatusResponse; + if (size) + *size = sizeof(_inf__GetAdminNetAclEntryStatusResponse); + ((_inf__GetAdminNetAclEntryStatusResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetAdminNetAclEntryStatusResponse[n]; + if (size) + *size = n * sizeof(_inf__GetAdminNetAclEntryStatusResponse); + for (int i = 0; i < n; i++) + ((_inf__GetAdminNetAclEntryStatusResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetAdminNetAclEntryStatusResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetAdminNetAclEntryStatusResponse %p -> %p\n", q, p)); + *(_inf__GetAdminNetAclEntryStatusResponse*)p = *(_inf__GetAdminNetAclEntryStatusResponse*)q; +} + +void _inf__GetAdminNetAclEntryStatus::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetAdminNetAclEntryStatus::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetAdminNetAclEntryStatus::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetAdminNetAclEntryStatus); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetAdminNetAclEntryStatus::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetAdminNetAclEntryStatus(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetAdminNetAclEntryStatus(struct soap *soap, const char *tag, int id, const _inf__GetAdminNetAclEntryStatus *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetAdminNetAclEntryStatus), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetAdminNetAclEntryStatus::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetAdminNetAclEntryStatus(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_get__inf__GetAdminNetAclEntryStatus(struct soap *soap, _inf__GetAdminNetAclEntryStatus *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetAdminNetAclEntryStatus(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetAdminNetAclEntryStatus::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetAdminNetAclEntryStatus(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_in__inf__GetAdminNetAclEntryStatus(struct soap *soap, const char *tag, _inf__GetAdminNetAclEntryStatus *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetAdminNetAclEntryStatus *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetAdminNetAclEntryStatus, sizeof(_inf__GetAdminNetAclEntryStatus), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetAdminNetAclEntryStatus) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetAdminNetAclEntryStatus *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetAdminNetAclEntryStatus *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetAdminNetAclEntryStatus, 0, sizeof(_inf__GetAdminNetAclEntryStatus), 0, soap_copy__inf__GetAdminNetAclEntryStatus); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetAdminNetAclEntryStatus * SOAP_FMAC6 soap_new__inf__GetAdminNetAclEntryStatus(struct soap *soap, int n) +{ return soap_instantiate__inf__GetAdminNetAclEntryStatus(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetAdminNetAclEntryStatus(struct soap *soap, _inf__GetAdminNetAclEntryStatus *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_instantiate__inf__GetAdminNetAclEntryStatus(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetAdminNetAclEntryStatus(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetAdminNetAclEntryStatus, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetAdminNetAclEntryStatus; + if (size) + *size = sizeof(_inf__GetAdminNetAclEntryStatus); + ((_inf__GetAdminNetAclEntryStatus*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetAdminNetAclEntryStatus[n]; + if (size) + *size = n * sizeof(_inf__GetAdminNetAclEntryStatus); + for (int i = 0; i < n; i++) + ((_inf__GetAdminNetAclEntryStatus*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetAdminNetAclEntryStatus*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetAdminNetAclEntryStatus(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetAdminNetAclEntryStatus %p -> %p\n", q, p)); + *(_inf__GetAdminNetAclEntryStatus*)p = *(_inf__GetAdminNetAclEntryStatus*)q; +} + +void _inf__GetAdminAclEntryStatusResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_inf__GetAdminAclEntryStatusResponse*)this)->IsDefault, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _inf__GetAdminAclEntryStatusResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetAdminAclEntryStatusResponse*)this)->StatusCode); + soap_default_bool(soap, &((_inf__GetAdminAclEntryStatusResponse*)this)->IsDefault); + /* transient soap skipped */ +} + +int _inf__GetAdminAclEntryStatusResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetAdminAclEntryStatusResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetAdminAclEntryStatusResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetAdminAclEntryStatusResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetAdminAclEntryStatusResponse(struct soap *soap, const char *tag, int id, const _inf__GetAdminAclEntryStatusResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetAdminAclEntryStatusResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetAdminAclEntryStatusResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "inf:IsDefault", -1, &(((_inf__GetAdminAclEntryStatusResponse*)a)->IsDefault), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetAdminAclEntryStatusResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetAdminAclEntryStatusResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse * SOAP_FMAC4 soap_get__inf__GetAdminAclEntryStatusResponse(struct soap *soap, _inf__GetAdminAclEntryStatusResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetAdminAclEntryStatusResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetAdminAclEntryStatusResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetAdminAclEntryStatusResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse * SOAP_FMAC4 soap_in__inf__GetAdminAclEntryStatusResponse(struct soap *soap, const char *tag, _inf__GetAdminAclEntryStatusResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetAdminAclEntryStatusResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetAdminAclEntryStatusResponse, sizeof(_inf__GetAdminAclEntryStatusResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetAdminAclEntryStatusResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetAdminAclEntryStatusResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_IsDefault1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetAdminAclEntryStatusResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_IsDefault1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:IsDefault", &(((_inf__GetAdminAclEntryStatusResponse*)a)->IsDefault), "xsd:boolean")) + { soap_flag_IsDefault1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_IsDefault1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetAdminAclEntryStatusResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetAdminAclEntryStatusResponse, 0, sizeof(_inf__GetAdminAclEntryStatusResponse), 0, soap_copy__inf__GetAdminAclEntryStatusResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetAdminAclEntryStatusResponse * SOAP_FMAC6 soap_new__inf__GetAdminAclEntryStatusResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetAdminAclEntryStatusResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetAdminAclEntryStatusResponse(struct soap *soap, _inf__GetAdminAclEntryStatusResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse * SOAP_FMAC4 soap_instantiate__inf__GetAdminAclEntryStatusResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetAdminAclEntryStatusResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetAdminAclEntryStatusResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetAdminAclEntryStatusResponse; + if (size) + *size = sizeof(_inf__GetAdminAclEntryStatusResponse); + ((_inf__GetAdminAclEntryStatusResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetAdminAclEntryStatusResponse[n]; + if (size) + *size = n * sizeof(_inf__GetAdminAclEntryStatusResponse); + for (int i = 0; i < n; i++) + ((_inf__GetAdminAclEntryStatusResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetAdminAclEntryStatusResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetAdminAclEntryStatusResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetAdminAclEntryStatusResponse %p -> %p\n", q, p)); + *(_inf__GetAdminAclEntryStatusResponse*)p = *(_inf__GetAdminAclEntryStatusResponse*)q; +} + +void _inf__GetAdminAclEntryStatus::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetAdminAclEntryStatus::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetAdminAclEntryStatus::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetAdminAclEntryStatus); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetAdminAclEntryStatus::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetAdminAclEntryStatus(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetAdminAclEntryStatus(struct soap *soap, const char *tag, int id, const _inf__GetAdminAclEntryStatus *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetAdminAclEntryStatus), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetAdminAclEntryStatus::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetAdminAclEntryStatus(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_get__inf__GetAdminAclEntryStatus(struct soap *soap, _inf__GetAdminAclEntryStatus *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetAdminAclEntryStatus(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetAdminAclEntryStatus::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetAdminAclEntryStatus(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_in__inf__GetAdminAclEntryStatus(struct soap *soap, const char *tag, _inf__GetAdminAclEntryStatus *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetAdminAclEntryStatus *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetAdminAclEntryStatus, sizeof(_inf__GetAdminAclEntryStatus), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetAdminAclEntryStatus) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetAdminAclEntryStatus *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetAdminAclEntryStatus *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetAdminAclEntryStatus, 0, sizeof(_inf__GetAdminAclEntryStatus), 0, soap_copy__inf__GetAdminAclEntryStatus); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetAdminAclEntryStatus * SOAP_FMAC6 soap_new__inf__GetAdminAclEntryStatus(struct soap *soap, int n) +{ return soap_instantiate__inf__GetAdminAclEntryStatus(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetAdminAclEntryStatus(struct soap *soap, _inf__GetAdminAclEntryStatus *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_instantiate__inf__GetAdminAclEntryStatus(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetAdminAclEntryStatus(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetAdminAclEntryStatus, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetAdminAclEntryStatus; + if (size) + *size = sizeof(_inf__GetAdminAclEntryStatus); + ((_inf__GetAdminAclEntryStatus*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetAdminAclEntryStatus[n]; + if (size) + *size = n * sizeof(_inf__GetAdminAclEntryStatus); + for (int i = 0; i < n; i++) + ((_inf__GetAdminAclEntryStatus*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetAdminAclEntryStatus*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetAdminAclEntryStatus(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetAdminAclEntryStatus %p -> %p\n", q, p)); + *(_inf__GetAdminAclEntryStatus*)p = *(_inf__GetAdminAclEntryStatus*)q; +} + +void _inf__GetConfigServerInfoResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_inf__GetConfigServerInfoResponse*)this)->Port, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void _inf__GetConfigServerInfoResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetConfigServerInfoResponse*)this)->StatusCode); + soap_default_inf__IPv4AddressType(soap, &((_inf__GetConfigServerInfoResponse*)this)->Ip); + soap_default_unsignedShort(soap, &((_inf__GetConfigServerInfoResponse*)this)->Port); + /* transient soap skipped */ +} + +int _inf__GetConfigServerInfoResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetConfigServerInfoResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetConfigServerInfoResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetConfigServerInfoResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetConfigServerInfoResponse(struct soap *soap, const char *tag, int id, const _inf__GetConfigServerInfoResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetConfigServerInfoResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetConfigServerInfoResponse*)a)->StatusCode), ""); + soap_out_inf__IPv4AddressType(soap, "inf:Ip", -1, &(((_inf__GetConfigServerInfoResponse*)a)->Ip), ""); + soap_out_unsignedShort(soap, "inf:Port", -1, &(((_inf__GetConfigServerInfoResponse*)a)->Port), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetConfigServerInfoResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetConfigServerInfoResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetConfigServerInfoResponse * SOAP_FMAC4 soap_get__inf__GetConfigServerInfoResponse(struct soap *soap, _inf__GetConfigServerInfoResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetConfigServerInfoResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetConfigServerInfoResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetConfigServerInfoResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetConfigServerInfoResponse * SOAP_FMAC4 soap_in__inf__GetConfigServerInfoResponse(struct soap *soap, const char *tag, _inf__GetConfigServerInfoResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetConfigServerInfoResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetConfigServerInfoResponse, sizeof(_inf__GetConfigServerInfoResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetConfigServerInfoResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetConfigServerInfoResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Ip1 = 1, soap_flag_Port1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetConfigServerInfoResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Ip1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__IPv4AddressType(soap, "inf:Ip", &(((_inf__GetConfigServerInfoResponse*)a)->Ip), "inf:IPv4AddressType")) + { soap_flag_Ip1--; + continue; + } + if (soap_flag_Port1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "inf:Port", &(((_inf__GetConfigServerInfoResponse*)a)->Port), "xsd:unsignedShort")) + { soap_flag_Port1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Ip1 > 0 || soap_flag_Port1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetConfigServerInfoResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetConfigServerInfoResponse, 0, sizeof(_inf__GetConfigServerInfoResponse), 0, soap_copy__inf__GetConfigServerInfoResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetConfigServerInfoResponse * SOAP_FMAC6 soap_new__inf__GetConfigServerInfoResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetConfigServerInfoResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetConfigServerInfoResponse(struct soap *soap, _inf__GetConfigServerInfoResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetConfigServerInfoResponse * SOAP_FMAC4 soap_instantiate__inf__GetConfigServerInfoResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetConfigServerInfoResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetConfigServerInfoResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetConfigServerInfoResponse; + if (size) + *size = sizeof(_inf__GetConfigServerInfoResponse); + ((_inf__GetConfigServerInfoResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetConfigServerInfoResponse[n]; + if (size) + *size = n * sizeof(_inf__GetConfigServerInfoResponse); + for (int i = 0; i < n; i++) + ((_inf__GetConfigServerInfoResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetConfigServerInfoResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetConfigServerInfoResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetConfigServerInfoResponse %p -> %p\n", q, p)); + *(_inf__GetConfigServerInfoResponse*)p = *(_inf__GetConfigServerInfoResponse*)q; +} + +void _inf__GetConfigServerInfo::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetConfigServerInfo::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetConfigServerInfo::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetConfigServerInfo); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetConfigServerInfo::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetConfigServerInfo(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetConfigServerInfo(struct soap *soap, const char *tag, int id, const _inf__GetConfigServerInfo *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetConfigServerInfo), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetConfigServerInfo::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetConfigServerInfo(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetConfigServerInfo * SOAP_FMAC4 soap_get__inf__GetConfigServerInfo(struct soap *soap, _inf__GetConfigServerInfo *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetConfigServerInfo(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetConfigServerInfo::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetConfigServerInfo(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetConfigServerInfo * SOAP_FMAC4 soap_in__inf__GetConfigServerInfo(struct soap *soap, const char *tag, _inf__GetConfigServerInfo *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetConfigServerInfo *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetConfigServerInfo, sizeof(_inf__GetConfigServerInfo), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetConfigServerInfo) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetConfigServerInfo *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetConfigServerInfo *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetConfigServerInfo, 0, sizeof(_inf__GetConfigServerInfo), 0, soap_copy__inf__GetConfigServerInfo); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetConfigServerInfo * SOAP_FMAC6 soap_new__inf__GetConfigServerInfo(struct soap *soap, int n) +{ return soap_instantiate__inf__GetConfigServerInfo(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetConfigServerInfo(struct soap *soap, _inf__GetConfigServerInfo *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetConfigServerInfo * SOAP_FMAC4 soap_instantiate__inf__GetConfigServerInfo(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetConfigServerInfo(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetConfigServerInfo, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetConfigServerInfo; + if (size) + *size = sizeof(_inf__GetConfigServerInfo); + ((_inf__GetConfigServerInfo*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetConfigServerInfo[n]; + if (size) + *size = n * sizeof(_inf__GetConfigServerInfo); + for (int i = 0; i < n; i++) + ((_inf__GetConfigServerInfo*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetConfigServerInfo*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetConfigServerInfo(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetConfigServerInfo %p -> %p\n", q, p)); + *(_inf__GetConfigServerInfo*)p = *(_inf__GetConfigServerInfo*)q; +} + +void _inf__GetHostNameResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_inf__GetHostNameResponse*)this)->HostName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_inf__GetHostNameResponse*)this)->HostName); + /* transient soap skipped */ +} + +void _inf__GetHostNameResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetHostNameResponse*)this)->StatusCode); + soap_default_std__string(soap, &((_inf__GetHostNameResponse*)this)->HostName); + /* transient soap skipped */ +} + +int _inf__GetHostNameResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetHostNameResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetHostNameResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetHostNameResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetHostNameResponse(struct soap *soap, const char *tag, int id, const _inf__GetHostNameResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetHostNameResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetHostNameResponse*)a)->StatusCode), ""); + soap_out_std__string(soap, "inf:HostName", -1, &(((_inf__GetHostNameResponse*)a)->HostName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetHostNameResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetHostNameResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetHostNameResponse * SOAP_FMAC4 soap_get__inf__GetHostNameResponse(struct soap *soap, _inf__GetHostNameResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetHostNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetHostNameResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetHostNameResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetHostNameResponse * SOAP_FMAC4 soap_in__inf__GetHostNameResponse(struct soap *soap, const char *tag, _inf__GetHostNameResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetHostNameResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetHostNameResponse, sizeof(_inf__GetHostNameResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetHostNameResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetHostNameResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_HostName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetHostNameResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_HostName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "inf:HostName", &(((_inf__GetHostNameResponse*)a)->HostName), "xsd:string")) + { soap_flag_HostName1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_HostName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetHostNameResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetHostNameResponse, 0, sizeof(_inf__GetHostNameResponse), 0, soap_copy__inf__GetHostNameResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetHostNameResponse * SOAP_FMAC6 soap_new__inf__GetHostNameResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetHostNameResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetHostNameResponse(struct soap *soap, _inf__GetHostNameResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetHostNameResponse * SOAP_FMAC4 soap_instantiate__inf__GetHostNameResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetHostNameResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetHostNameResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetHostNameResponse; + if (size) + *size = sizeof(_inf__GetHostNameResponse); + ((_inf__GetHostNameResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetHostNameResponse[n]; + if (size) + *size = n * sizeof(_inf__GetHostNameResponse); + for (int i = 0; i < n; i++) + ((_inf__GetHostNameResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetHostNameResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetHostNameResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetHostNameResponse %p -> %p\n", q, p)); + *(_inf__GetHostNameResponse*)p = *(_inf__GetHostNameResponse*)q; +} + +void _inf__GetHostName::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetHostName::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetHostName::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetHostName); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetHostName::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetHostName(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetHostName(struct soap *soap, const char *tag, int id, const _inf__GetHostName *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetHostName), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetHostName::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetHostName(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetHostName * SOAP_FMAC4 soap_get__inf__GetHostName(struct soap *soap, _inf__GetHostName *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetHostName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetHostName::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetHostName(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetHostName * SOAP_FMAC4 soap_in__inf__GetHostName(struct soap *soap, const char *tag, _inf__GetHostName *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetHostName *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetHostName, sizeof(_inf__GetHostName), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetHostName) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetHostName *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetHostName *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetHostName, 0, sizeof(_inf__GetHostName), 0, soap_copy__inf__GetHostName); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetHostName * SOAP_FMAC6 soap_new__inf__GetHostName(struct soap *soap, int n) +{ return soap_instantiate__inf__GetHostName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetHostName(struct soap *soap, _inf__GetHostName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetHostName * SOAP_FMAC4 soap_instantiate__inf__GetHostName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetHostName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetHostName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetHostName; + if (size) + *size = sizeof(_inf__GetHostName); + ((_inf__GetHostName*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetHostName[n]; + if (size) + *size = n * sizeof(_inf__GetHostName); + for (int i = 0; i < n; i++) + ((_inf__GetHostName*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetHostName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetHostName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetHostName %p -> %p\n", q, p)); + *(_inf__GetHostName*)p = *(_inf__GetHostName*)q; +} + +void _inf__GetVlanParametersResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_inf__GetVlanParametersResponse*)this)->VlanMode, SOAP_TYPE_bool); + soap_embedded(soap, &((_inf__GetVlanParametersResponse*)this)->VlanTag, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void _inf__GetVlanParametersResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetVlanParametersResponse*)this)->StatusCode); + soap_default_bool(soap, &((_inf__GetVlanParametersResponse*)this)->VlanMode); + soap_default_unsignedShort(soap, &((_inf__GetVlanParametersResponse*)this)->VlanTag); + /* transient soap skipped */ +} + +int _inf__GetVlanParametersResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetVlanParametersResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetVlanParametersResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetVlanParametersResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetVlanParametersResponse(struct soap *soap, const char *tag, int id, const _inf__GetVlanParametersResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetVlanParametersResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetVlanParametersResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "inf:VlanMode", -1, &(((_inf__GetVlanParametersResponse*)a)->VlanMode), ""); + soap_out_unsignedShort(soap, "inf:VlanTag", -1, &(((_inf__GetVlanParametersResponse*)a)->VlanTag), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetVlanParametersResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetVlanParametersResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetVlanParametersResponse * SOAP_FMAC4 soap_get__inf__GetVlanParametersResponse(struct soap *soap, _inf__GetVlanParametersResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetVlanParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetVlanParametersResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetVlanParametersResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetVlanParametersResponse * SOAP_FMAC4 soap_in__inf__GetVlanParametersResponse(struct soap *soap, const char *tag, _inf__GetVlanParametersResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetVlanParametersResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetVlanParametersResponse, sizeof(_inf__GetVlanParametersResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetVlanParametersResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetVlanParametersResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_VlanMode1 = 1, soap_flag_VlanTag1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetVlanParametersResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_VlanMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "inf:VlanMode", &(((_inf__GetVlanParametersResponse*)a)->VlanMode), "xsd:boolean")) + { soap_flag_VlanMode1--; + continue; + } + if (soap_flag_VlanTag1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "inf:VlanTag", &(((_inf__GetVlanParametersResponse*)a)->VlanTag), "xsd:unsignedShort")) + { soap_flag_VlanTag1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_VlanMode1 > 0 || soap_flag_VlanTag1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetVlanParametersResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetVlanParametersResponse, 0, sizeof(_inf__GetVlanParametersResponse), 0, soap_copy__inf__GetVlanParametersResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetVlanParametersResponse * SOAP_FMAC6 soap_new__inf__GetVlanParametersResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetVlanParametersResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetVlanParametersResponse(struct soap *soap, _inf__GetVlanParametersResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetVlanParametersResponse * SOAP_FMAC4 soap_instantiate__inf__GetVlanParametersResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetVlanParametersResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetVlanParametersResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetVlanParametersResponse; + if (size) + *size = sizeof(_inf__GetVlanParametersResponse); + ((_inf__GetVlanParametersResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetVlanParametersResponse[n]; + if (size) + *size = n * sizeof(_inf__GetVlanParametersResponse); + for (int i = 0; i < n; i++) + ((_inf__GetVlanParametersResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetVlanParametersResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetVlanParametersResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetVlanParametersResponse %p -> %p\n", q, p)); + *(_inf__GetVlanParametersResponse*)p = *(_inf__GetVlanParametersResponse*)q; +} + +void _inf__GetVlanParameters::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocmn__InterfaceHandleType(soap, &((_inf__GetVlanParameters*)this)->InterfaceHandle); + /* transient soap skipped */ +} + +void _inf__GetVlanParameters::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_inf__GetVlanParameters*)this)->InterfaceHandle = NULL; + /* transient soap skipped */ +} + +int _inf__GetVlanParameters::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetVlanParameters); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetVlanParameters::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetVlanParameters(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetVlanParameters(struct soap *soap, const char *tag, int id, const _inf__GetVlanParameters *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetVlanParameters), type); + soap_out_PointerTocmn__InterfaceHandleType(soap, "inf:InterfaceHandle", -1, &(((_inf__GetVlanParameters*)a)->InterfaceHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetVlanParameters::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetVlanParameters(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetVlanParameters * SOAP_FMAC4 soap_get__inf__GetVlanParameters(struct soap *soap, _inf__GetVlanParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetVlanParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetVlanParameters::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetVlanParameters(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetVlanParameters * SOAP_FMAC4 soap_in__inf__GetVlanParameters(struct soap *soap, const char *tag, _inf__GetVlanParameters *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetVlanParameters *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetVlanParameters, sizeof(_inf__GetVlanParameters), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetVlanParameters) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetVlanParameters *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocmn__InterfaceHandleType(soap, "inf:InterfaceHandle", &(((_inf__GetVlanParameters*)a)->InterfaceHandle), "cmn:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetVlanParameters *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetVlanParameters, 0, sizeof(_inf__GetVlanParameters), 0, soap_copy__inf__GetVlanParameters); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetVlanParameters * SOAP_FMAC6 soap_new__inf__GetVlanParameters(struct soap *soap, int n) +{ return soap_instantiate__inf__GetVlanParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetVlanParameters(struct soap *soap, _inf__GetVlanParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetVlanParameters * SOAP_FMAC4 soap_instantiate__inf__GetVlanParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetVlanParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetVlanParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetVlanParameters; + if (size) + *size = sizeof(_inf__GetVlanParameters); + ((_inf__GetVlanParameters*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetVlanParameters[n]; + if (size) + *size = n * sizeof(_inf__GetVlanParameters); + for (int i = 0; i < n; i++) + ((_inf__GetVlanParameters*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetVlanParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetVlanParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetVlanParameters %p -> %p\n", q, p)); + *(_inf__GetVlanParameters*)p = *(_inf__GetVlanParameters*)q; +} + +void _inf__GetProvisioningStateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetProvisioningStateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetProvisioningStateResponse*)this)->StatusCode); + soap_default_inf__ProvisioningStateType(soap, &((_inf__GetProvisioningStateResponse*)this)->ProvisioningState); + /* transient soap skipped */ +} + +int _inf__GetProvisioningStateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetProvisioningStateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetProvisioningStateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetProvisioningStateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetProvisioningStateResponse(struct soap *soap, const char *tag, int id, const _inf__GetProvisioningStateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetProvisioningStateResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetProvisioningStateResponse*)a)->StatusCode), ""); + soap_out_inf__ProvisioningStateType(soap, "inf:ProvisioningState", -1, &(((_inf__GetProvisioningStateResponse*)a)->ProvisioningState), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetProvisioningStateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetProvisioningStateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetProvisioningStateResponse * SOAP_FMAC4 soap_get__inf__GetProvisioningStateResponse(struct soap *soap, _inf__GetProvisioningStateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetProvisioningStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetProvisioningStateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetProvisioningStateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetProvisioningStateResponse * SOAP_FMAC4 soap_in__inf__GetProvisioningStateResponse(struct soap *soap, const char *tag, _inf__GetProvisioningStateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetProvisioningStateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetProvisioningStateResponse, sizeof(_inf__GetProvisioningStateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetProvisioningStateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetProvisioningStateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_ProvisioningState1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetProvisioningStateResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_ProvisioningState1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__ProvisioningStateType(soap, "inf:ProvisioningState", &(((_inf__GetProvisioningStateResponse*)a)->ProvisioningState), "inf:ProvisioningStateType")) + { soap_flag_ProvisioningState1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_ProvisioningState1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetProvisioningStateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetProvisioningStateResponse, 0, sizeof(_inf__GetProvisioningStateResponse), 0, soap_copy__inf__GetProvisioningStateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetProvisioningStateResponse * SOAP_FMAC6 soap_new__inf__GetProvisioningStateResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetProvisioningStateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetProvisioningStateResponse(struct soap *soap, _inf__GetProvisioningStateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetProvisioningStateResponse * SOAP_FMAC4 soap_instantiate__inf__GetProvisioningStateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetProvisioningStateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetProvisioningStateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetProvisioningStateResponse; + if (size) + *size = sizeof(_inf__GetProvisioningStateResponse); + ((_inf__GetProvisioningStateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetProvisioningStateResponse[n]; + if (size) + *size = n * sizeof(_inf__GetProvisioningStateResponse); + for (int i = 0; i < n; i++) + ((_inf__GetProvisioningStateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetProvisioningStateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetProvisioningStateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetProvisioningStateResponse %p -> %p\n", q, p)); + *(_inf__GetProvisioningStateResponse*)p = *(_inf__GetProvisioningStateResponse*)q; +} + +void _inf__GetProvisioningState::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetProvisioningState::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetProvisioningState::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetProvisioningState); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetProvisioningState::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetProvisioningState(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetProvisioningState(struct soap *soap, const char *tag, int id, const _inf__GetProvisioningState *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetProvisioningState), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetProvisioningState::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetProvisioningState(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetProvisioningState * SOAP_FMAC4 soap_get__inf__GetProvisioningState(struct soap *soap, _inf__GetProvisioningState *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetProvisioningState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetProvisioningState::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetProvisioningState(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetProvisioningState * SOAP_FMAC4 soap_in__inf__GetProvisioningState(struct soap *soap, const char *tag, _inf__GetProvisioningState *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetProvisioningState *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetProvisioningState, sizeof(_inf__GetProvisioningState), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetProvisioningState) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetProvisioningState *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetProvisioningState *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetProvisioningState, 0, sizeof(_inf__GetProvisioningState), 0, soap_copy__inf__GetProvisioningState); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetProvisioningState * SOAP_FMAC6 soap_new__inf__GetProvisioningState(struct soap *soap, int n) +{ return soap_instantiate__inf__GetProvisioningState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetProvisioningState(struct soap *soap, _inf__GetProvisioningState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetProvisioningState * SOAP_FMAC4 soap_instantiate__inf__GetProvisioningState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetProvisioningState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetProvisioningState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetProvisioningState; + if (size) + *size = sizeof(_inf__GetProvisioningState); + ((_inf__GetProvisioningState*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetProvisioningState[n]; + if (size) + *size = n * sizeof(_inf__GetProvisioningState); + for (int i = 0; i < n; i++) + ((_inf__GetProvisioningState*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetProvisioningState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetProvisioningState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetProvisioningState %p -> %p\n", q, p)); + *(_inf__GetProvisioningState*)p = *(_inf__GetProvisioningState*)q; +} + +void _inf__GetProvisioningModeResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetProvisioningModeResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetProvisioningModeResponse*)this)->StatusCode); + soap_default_inf__ProvisioningModeType(soap, &((_inf__GetProvisioningModeResponse*)this)->ProvisioningMode); + /* transient soap skipped */ +} + +int _inf__GetProvisioningModeResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetProvisioningModeResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetProvisioningModeResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetProvisioningModeResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetProvisioningModeResponse(struct soap *soap, const char *tag, int id, const _inf__GetProvisioningModeResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetProvisioningModeResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetProvisioningModeResponse*)a)->StatusCode), ""); + soap_out_inf__ProvisioningModeType(soap, "inf:ProvisioningMode", -1, &(((_inf__GetProvisioningModeResponse*)a)->ProvisioningMode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetProvisioningModeResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetProvisioningModeResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetProvisioningModeResponse * SOAP_FMAC4 soap_get__inf__GetProvisioningModeResponse(struct soap *soap, _inf__GetProvisioningModeResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetProvisioningModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetProvisioningModeResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetProvisioningModeResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetProvisioningModeResponse * SOAP_FMAC4 soap_in__inf__GetProvisioningModeResponse(struct soap *soap, const char *tag, _inf__GetProvisioningModeResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetProvisioningModeResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetProvisioningModeResponse, sizeof(_inf__GetProvisioningModeResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetProvisioningModeResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetProvisioningModeResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_ProvisioningMode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetProvisioningModeResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_ProvisioningMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__ProvisioningModeType(soap, "inf:ProvisioningMode", &(((_inf__GetProvisioningModeResponse*)a)->ProvisioningMode), "inf:ProvisioningModeType")) + { soap_flag_ProvisioningMode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_ProvisioningMode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetProvisioningModeResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetProvisioningModeResponse, 0, sizeof(_inf__GetProvisioningModeResponse), 0, soap_copy__inf__GetProvisioningModeResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetProvisioningModeResponse * SOAP_FMAC6 soap_new__inf__GetProvisioningModeResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetProvisioningModeResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetProvisioningModeResponse(struct soap *soap, _inf__GetProvisioningModeResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetProvisioningModeResponse * SOAP_FMAC4 soap_instantiate__inf__GetProvisioningModeResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetProvisioningModeResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetProvisioningModeResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetProvisioningModeResponse; + if (size) + *size = sizeof(_inf__GetProvisioningModeResponse); + ((_inf__GetProvisioningModeResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetProvisioningModeResponse[n]; + if (size) + *size = n * sizeof(_inf__GetProvisioningModeResponse); + for (int i = 0; i < n; i++) + ((_inf__GetProvisioningModeResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetProvisioningModeResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetProvisioningModeResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetProvisioningModeResponse %p -> %p\n", q, p)); + *(_inf__GetProvisioningModeResponse*)p = *(_inf__GetProvisioningModeResponse*)q; +} + +void _inf__GetProvisioningMode::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetProvisioningMode::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetProvisioningMode::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetProvisioningMode); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetProvisioningMode::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetProvisioningMode(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetProvisioningMode(struct soap *soap, const char *tag, int id, const _inf__GetProvisioningMode *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetProvisioningMode), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetProvisioningMode::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetProvisioningMode(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetProvisioningMode * SOAP_FMAC4 soap_get__inf__GetProvisioningMode(struct soap *soap, _inf__GetProvisioningMode *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetProvisioningMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetProvisioningMode::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetProvisioningMode(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetProvisioningMode * SOAP_FMAC4 soap_in__inf__GetProvisioningMode(struct soap *soap, const char *tag, _inf__GetProvisioningMode *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetProvisioningMode *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetProvisioningMode, sizeof(_inf__GetProvisioningMode), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetProvisioningMode) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetProvisioningMode *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetProvisioningMode *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetProvisioningMode, 0, sizeof(_inf__GetProvisioningMode), 0, soap_copy__inf__GetProvisioningMode); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetProvisioningMode * SOAP_FMAC6 soap_new__inf__GetProvisioningMode(struct soap *soap, int n) +{ return soap_instantiate__inf__GetProvisioningMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetProvisioningMode(struct soap *soap, _inf__GetProvisioningMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetProvisioningMode * SOAP_FMAC4 soap_instantiate__inf__GetProvisioningMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetProvisioningMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetProvisioningMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetProvisioningMode; + if (size) + *size = sizeof(_inf__GetProvisioningMode); + ((_inf__GetProvisioningMode*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetProvisioningMode[n]; + if (size) + *size = n * sizeof(_inf__GetProvisioningMode); + for (int i = 0; i < n; i++) + ((_inf__GetProvisioningMode*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetProvisioningMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetProvisioningMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetProvisioningMode %p -> %p\n", q, p)); + *(_inf__GetProvisioningMode*)p = *(_inf__GetProvisioningMode*)q; +} + +void _inf__GetCodeVersionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_inf__GetCodeVersionsResponse*)this)->BiosVersion, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_inf__GetCodeVersionsResponse*)this)->BiosVersion); + soap_serialize_std__vectorTemplateOfPointerToinf__FirmwareVersionType(soap, &((_inf__GetCodeVersionsResponse*)this)->Versions); + /* transient soap skipped */ +} + +void _inf__GetCodeVersionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetCodeVersionsResponse*)this)->StatusCode); + soap_default_std__string(soap, &((_inf__GetCodeVersionsResponse*)this)->BiosVersion); + soap_default_std__vectorTemplateOfPointerToinf__FirmwareVersionType(soap, &((_inf__GetCodeVersionsResponse*)this)->Versions); + /* transient soap skipped */ +} + +int _inf__GetCodeVersionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetCodeVersionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetCodeVersionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetCodeVersionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetCodeVersionsResponse(struct soap *soap, const char *tag, int id, const _inf__GetCodeVersionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetCodeVersionsResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetCodeVersionsResponse*)a)->StatusCode), ""); + soap_out_std__string(soap, "inf:BiosVersion", -1, &(((_inf__GetCodeVersionsResponse*)a)->BiosVersion), ""); + soap_out_std__vectorTemplateOfPointerToinf__FirmwareVersionType(soap, "inf:Versions", -1, &(((_inf__GetCodeVersionsResponse*)a)->Versions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetCodeVersionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetCodeVersionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetCodeVersionsResponse * SOAP_FMAC4 soap_get__inf__GetCodeVersionsResponse(struct soap *soap, _inf__GetCodeVersionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetCodeVersionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetCodeVersionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetCodeVersionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetCodeVersionsResponse * SOAP_FMAC4 soap_in__inf__GetCodeVersionsResponse(struct soap *soap, const char *tag, _inf__GetCodeVersionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetCodeVersionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetCodeVersionsResponse, sizeof(_inf__GetCodeVersionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetCodeVersionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetCodeVersionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_BiosVersion1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetCodeVersionsResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_BiosVersion1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "inf:BiosVersion", &(((_inf__GetCodeVersionsResponse*)a)->BiosVersion), "xsd:string")) + { soap_flag_BiosVersion1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerToinf__FirmwareVersionType(soap, "inf:Versions", &(((_inf__GetCodeVersionsResponse*)a)->Versions), "inf:FirmwareVersionType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_BiosVersion1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetCodeVersionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetCodeVersionsResponse, 0, sizeof(_inf__GetCodeVersionsResponse), 0, soap_copy__inf__GetCodeVersionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetCodeVersionsResponse * SOAP_FMAC6 soap_new__inf__GetCodeVersionsResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetCodeVersionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetCodeVersionsResponse(struct soap *soap, _inf__GetCodeVersionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetCodeVersionsResponse * SOAP_FMAC4 soap_instantiate__inf__GetCodeVersionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetCodeVersionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetCodeVersionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetCodeVersionsResponse; + if (size) + *size = sizeof(_inf__GetCodeVersionsResponse); + ((_inf__GetCodeVersionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetCodeVersionsResponse[n]; + if (size) + *size = n * sizeof(_inf__GetCodeVersionsResponse); + for (int i = 0; i < n; i++) + ((_inf__GetCodeVersionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetCodeVersionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetCodeVersionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetCodeVersionsResponse %p -> %p\n", q, p)); + *(_inf__GetCodeVersionsResponse*)p = *(_inf__GetCodeVersionsResponse*)q; +} + +void _inf__GetCodeVersions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetCodeVersions::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetCodeVersions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetCodeVersions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetCodeVersions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetCodeVersions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetCodeVersions(struct soap *soap, const char *tag, int id, const _inf__GetCodeVersions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetCodeVersions), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetCodeVersions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetCodeVersions(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetCodeVersions * SOAP_FMAC4 soap_get__inf__GetCodeVersions(struct soap *soap, _inf__GetCodeVersions *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetCodeVersions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetCodeVersions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetCodeVersions(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetCodeVersions * SOAP_FMAC4 soap_in__inf__GetCodeVersions(struct soap *soap, const char *tag, _inf__GetCodeVersions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetCodeVersions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetCodeVersions, sizeof(_inf__GetCodeVersions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetCodeVersions) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetCodeVersions *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetCodeVersions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetCodeVersions, 0, sizeof(_inf__GetCodeVersions), 0, soap_copy__inf__GetCodeVersions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetCodeVersions * SOAP_FMAC6 soap_new__inf__GetCodeVersions(struct soap *soap, int n) +{ return soap_instantiate__inf__GetCodeVersions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetCodeVersions(struct soap *soap, _inf__GetCodeVersions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetCodeVersions * SOAP_FMAC4 soap_instantiate__inf__GetCodeVersions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetCodeVersions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetCodeVersions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetCodeVersions; + if (size) + *size = sizeof(_inf__GetCodeVersions); + ((_inf__GetCodeVersions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetCodeVersions[n]; + if (size) + *size = n * sizeof(_inf__GetCodeVersions); + for (int i = 0; i < n; i++) + ((_inf__GetCodeVersions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetCodeVersions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetCodeVersions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetCodeVersions %p -> %p\n", q, p)); + *(_inf__GetCodeVersions*)p = *(_inf__GetCodeVersions*)q; +} + +void _inf__GetCoreVersionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_inf__GetCoreVersionResponse*)this)->Version, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_inf__GetCoreVersionResponse*)this)->Version); + /* transient soap skipped */ +} + +void _inf__GetCoreVersionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__PT_USCORESTATUS(soap, &((_inf__GetCoreVersionResponse*)this)->StatusCode); + soap_default_std__string(soap, &((_inf__GetCoreVersionResponse*)this)->Version); + /* transient soap skipped */ +} + +int _inf__GetCoreVersionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetCoreVersionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetCoreVersionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetCoreVersionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetCoreVersionResponse(struct soap *soap, const char *tag, int id, const _inf__GetCoreVersionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetCoreVersionResponse), type); + soap_element_result(soap, "inf:StatusCode"); + soap_out_inf__PT_USCORESTATUS(soap, "inf:StatusCode", -1, &(((_inf__GetCoreVersionResponse*)a)->StatusCode), ""); + soap_out_std__string(soap, "inf:Version", -1, &(((_inf__GetCoreVersionResponse*)a)->Version), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetCoreVersionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetCoreVersionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetCoreVersionResponse * SOAP_FMAC4 soap_get__inf__GetCoreVersionResponse(struct soap *soap, _inf__GetCoreVersionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetCoreVersionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetCoreVersionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetCoreVersionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetCoreVersionResponse * SOAP_FMAC4 soap_in__inf__GetCoreVersionResponse(struct soap *soap, const char *tag, _inf__GetCoreVersionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetCoreVersionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetCoreVersionResponse, sizeof(_inf__GetCoreVersionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetCoreVersionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetCoreVersionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Version1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__PT_USCORESTATUS(soap, "inf:StatusCode", &(((_inf__GetCoreVersionResponse*)a)->StatusCode), "inf:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Version1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "inf:Version", &(((_inf__GetCoreVersionResponse*)a)->Version), "xsd:string")) + { soap_flag_Version1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "inf:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Version1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetCoreVersionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetCoreVersionResponse, 0, sizeof(_inf__GetCoreVersionResponse), 0, soap_copy__inf__GetCoreVersionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetCoreVersionResponse * SOAP_FMAC6 soap_new__inf__GetCoreVersionResponse(struct soap *soap, int n) +{ return soap_instantiate__inf__GetCoreVersionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetCoreVersionResponse(struct soap *soap, _inf__GetCoreVersionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetCoreVersionResponse * SOAP_FMAC4 soap_instantiate__inf__GetCoreVersionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetCoreVersionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetCoreVersionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetCoreVersionResponse; + if (size) + *size = sizeof(_inf__GetCoreVersionResponse); + ((_inf__GetCoreVersionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetCoreVersionResponse[n]; + if (size) + *size = n * sizeof(_inf__GetCoreVersionResponse); + for (int i = 0; i < n; i++) + ((_inf__GetCoreVersionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetCoreVersionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetCoreVersionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetCoreVersionResponse %p -> %p\n", q, p)); + *(_inf__GetCoreVersionResponse*)p = *(_inf__GetCoreVersionResponse*)q; +} + +void _inf__GetCoreVersion::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _inf__GetCoreVersion::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _inf__GetCoreVersion::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__inf__GetCoreVersion); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _inf__GetCoreVersion::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__inf__GetCoreVersion(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__inf__GetCoreVersion(struct soap *soap, const char *tag, int id, const _inf__GetCoreVersion *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__inf__GetCoreVersion), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_inf__GetCoreVersion::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__inf__GetCoreVersion(soap, this, tag, type); +} + +SOAP_FMAC3 _inf__GetCoreVersion * SOAP_FMAC4 soap_get__inf__GetCoreVersion(struct soap *soap, _inf__GetCoreVersion *p, const char *tag, const char *type) +{ + if ((p = soap_in__inf__GetCoreVersion(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_inf__GetCoreVersion::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__inf__GetCoreVersion(soap, tag, this, type); +} + +SOAP_FMAC3 _inf__GetCoreVersion * SOAP_FMAC4 soap_in__inf__GetCoreVersion(struct soap *soap, const char *tag, _inf__GetCoreVersion *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_inf__GetCoreVersion *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__inf__GetCoreVersion, sizeof(_inf__GetCoreVersion), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__inf__GetCoreVersion) + { soap_revert(soap); + *soap->id = '\0'; + return (_inf__GetCoreVersion *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_inf__GetCoreVersion *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__inf__GetCoreVersion, 0, sizeof(_inf__GetCoreVersion), 0, soap_copy__inf__GetCoreVersion); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _inf__GetCoreVersion * SOAP_FMAC6 soap_new__inf__GetCoreVersion(struct soap *soap, int n) +{ return soap_instantiate__inf__GetCoreVersion(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__inf__GetCoreVersion(struct soap *soap, _inf__GetCoreVersion *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _inf__GetCoreVersion * SOAP_FMAC4 soap_instantiate__inf__GetCoreVersion(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__inf__GetCoreVersion(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__inf__GetCoreVersion, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _inf__GetCoreVersion; + if (size) + *size = sizeof(_inf__GetCoreVersion); + ((_inf__GetCoreVersion*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _inf__GetCoreVersion[n]; + if (size) + *size = n * sizeof(_inf__GetCoreVersion); + for (int i = 0; i < n; i++) + ((_inf__GetCoreVersion*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_inf__GetCoreVersion*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__inf__GetCoreVersion(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _inf__GetCoreVersion %p -> %p\n", q, p)); + *(_inf__GetCoreVersion*)p = *(_inf__GetCoreVersion*)q; +} + +void inf__FirmwareVersionType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((inf__FirmwareVersionType*)this)->Description, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((inf__FirmwareVersionType*)this)->Description); + soap_embedded(soap, &((inf__FirmwareVersionType*)this)->Version, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((inf__FirmwareVersionType*)this)->Version); + /* transient soap skipped */ +} + +void inf__FirmwareVersionType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((inf__FirmwareVersionType*)this)->Description); + soap_default_std__string(soap, &((inf__FirmwareVersionType*)this)->Version); + /* transient soap skipped */ +} + +int inf__FirmwareVersionType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_inf__FirmwareVersionType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int inf__FirmwareVersionType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_inf__FirmwareVersionType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__FirmwareVersionType(struct soap *soap, const char *tag, int id, const inf__FirmwareVersionType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_inf__FirmwareVersionType), type); + soap_out_std__string(soap, "inf:Description", -1, &(((inf__FirmwareVersionType*)a)->Description), ""); + soap_out_std__string(soap, "inf:Version", -1, &(((inf__FirmwareVersionType*)a)->Version), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *inf__FirmwareVersionType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_inf__FirmwareVersionType(soap, this, tag, type); +} + +SOAP_FMAC3 inf__FirmwareVersionType * SOAP_FMAC4 soap_get_inf__FirmwareVersionType(struct soap *soap, inf__FirmwareVersionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_inf__FirmwareVersionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *inf__FirmwareVersionType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_inf__FirmwareVersionType(soap, tag, this, type); +} + +SOAP_FMAC3 inf__FirmwareVersionType * SOAP_FMAC4 soap_in_inf__FirmwareVersionType(struct soap *soap, const char *tag, inf__FirmwareVersionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (inf__FirmwareVersionType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_inf__FirmwareVersionType, sizeof(inf__FirmwareVersionType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_inf__FirmwareVersionType) + { soap_revert(soap); + *soap->id = '\0'; + return (inf__FirmwareVersionType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Description1 = 1, soap_flag_Version1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Description1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "inf:Description", &(((inf__FirmwareVersionType*)a)->Description), "xsd:string")) + { soap_flag_Description1--; + continue; + } + if (soap_flag_Version1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "inf:Version", &(((inf__FirmwareVersionType*)a)->Version), "xsd:string")) + { soap_flag_Version1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Description1 > 0 || soap_flag_Version1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (inf__FirmwareVersionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_inf__FirmwareVersionType, 0, sizeof(inf__FirmwareVersionType), 0, soap_copy_inf__FirmwareVersionType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 inf__FirmwareVersionType * SOAP_FMAC6 soap_new_inf__FirmwareVersionType(struct soap *soap, int n) +{ return soap_instantiate_inf__FirmwareVersionType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_inf__FirmwareVersionType(struct soap *soap, inf__FirmwareVersionType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 inf__FirmwareVersionType * SOAP_FMAC4 soap_instantiate_inf__FirmwareVersionType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_inf__FirmwareVersionType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_inf__FirmwareVersionType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new inf__FirmwareVersionType; + if (size) + *size = sizeof(inf__FirmwareVersionType); + ((inf__FirmwareVersionType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new inf__FirmwareVersionType[n]; + if (size) + *size = n * sizeof(inf__FirmwareVersionType); + for (int i = 0; i < n; i++) + ((inf__FirmwareVersionType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (inf__FirmwareVersionType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_inf__FirmwareVersionType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying inf__FirmwareVersionType %p -> %p\n", q, p)); + *(inf__FirmwareVersionType*)p = *(inf__FirmwareVersionType*)q; +} + +void inf__IderSessionLogEntryType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((inf__IderSessionLogEntryType*)this)->Port, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void inf__IderSessionLogEntryType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_inf__IPv4AddressType(soap, &((inf__IderSessionLogEntryType*)this)->ConsoleAddress); + soap_default_unsignedShort(soap, &((inf__IderSessionLogEntryType*)this)->Port); + soap_default_inf__TimeType(soap, &((inf__IderSessionLogEntryType*)this)->TimeStamp); + /* transient soap skipped */ +} + +int inf__IderSessionLogEntryType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_inf__IderSessionLogEntryType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int inf__IderSessionLogEntryType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_inf__IderSessionLogEntryType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_inf__IderSessionLogEntryType(struct soap *soap, const char *tag, int id, const inf__IderSessionLogEntryType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_inf__IderSessionLogEntryType), type); + soap_out_inf__IPv4AddressType(soap, "inf:ConsoleAddress", -1, &(((inf__IderSessionLogEntryType*)a)->ConsoleAddress), ""); + soap_out_unsignedShort(soap, "inf:Port", -1, &(((inf__IderSessionLogEntryType*)a)->Port), ""); + soap_out_inf__TimeType(soap, "inf:TimeStamp", -1, &(((inf__IderSessionLogEntryType*)a)->TimeStamp), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *inf__IderSessionLogEntryType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_inf__IderSessionLogEntryType(soap, this, tag, type); +} + +SOAP_FMAC3 inf__IderSessionLogEntryType * SOAP_FMAC4 soap_get_inf__IderSessionLogEntryType(struct soap *soap, inf__IderSessionLogEntryType *p, const char *tag, const char *type) +{ + if ((p = soap_in_inf__IderSessionLogEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *inf__IderSessionLogEntryType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_inf__IderSessionLogEntryType(soap, tag, this, type); +} + +SOAP_FMAC3 inf__IderSessionLogEntryType * SOAP_FMAC4 soap_in_inf__IderSessionLogEntryType(struct soap *soap, const char *tag, inf__IderSessionLogEntryType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (inf__IderSessionLogEntryType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_inf__IderSessionLogEntryType, sizeof(inf__IderSessionLogEntryType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_inf__IderSessionLogEntryType) + { soap_revert(soap); + *soap->id = '\0'; + return (inf__IderSessionLogEntryType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ConsoleAddress1 = 1, soap_flag_Port1 = 1, soap_flag_TimeStamp1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ConsoleAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__IPv4AddressType(soap, "inf:ConsoleAddress", &(((inf__IderSessionLogEntryType*)a)->ConsoleAddress), "inf:IPv4AddressType")) + { soap_flag_ConsoleAddress1--; + continue; + } + if (soap_flag_Port1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "inf:Port", &(((inf__IderSessionLogEntryType*)a)->Port), "xsd:unsignedShort")) + { soap_flag_Port1--; + continue; + } + if (soap_flag_TimeStamp1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_inf__TimeType(soap, "inf:TimeStamp", &(((inf__IderSessionLogEntryType*)a)->TimeStamp), "inf:TimeType")) + { soap_flag_TimeStamp1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ConsoleAddress1 > 0 || soap_flag_Port1 > 0 || soap_flag_TimeStamp1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (inf__IderSessionLogEntryType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_inf__IderSessionLogEntryType, 0, sizeof(inf__IderSessionLogEntryType), 0, soap_copy_inf__IderSessionLogEntryType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 inf__IderSessionLogEntryType * SOAP_FMAC6 soap_new_inf__IderSessionLogEntryType(struct soap *soap, int n) +{ return soap_instantiate_inf__IderSessionLogEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_inf__IderSessionLogEntryType(struct soap *soap, inf__IderSessionLogEntryType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 inf__IderSessionLogEntryType * SOAP_FMAC4 soap_instantiate_inf__IderSessionLogEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_inf__IderSessionLogEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_inf__IderSessionLogEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new inf__IderSessionLogEntryType; + if (size) + *size = sizeof(inf__IderSessionLogEntryType); + ((inf__IderSessionLogEntryType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new inf__IderSessionLogEntryType[n]; + if (size) + *size = n * sizeof(inf__IderSessionLogEntryType); + for (int i = 0; i < n; i++) + ((inf__IderSessionLogEntryType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (inf__IderSessionLogEntryType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_inf__IderSessionLogEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying inf__IderSessionLogEntryType %p -> %p\n", q, p)); + *(inf__IderSessionLogEntryType*)p = *(inf__IderSessionLogEntryType*)q; +} + +void _str__ExecuteStorageOperationResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_str__ExecuteStorageOperationResponse*)this)->Response, SOAP_TYPE_xsd__base64Binary); + ((_str__ExecuteStorageOperationResponse*)this)->Response.soap_serialize(soap); + /* transient soap skipped */ +} + +void _str__ExecuteStorageOperationResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_str__PT_USCORESTATUS(soap, &((_str__ExecuteStorageOperationResponse*)this)->Status); + ((_str__ExecuteStorageOperationResponse*)this)->Response.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int _str__ExecuteStorageOperationResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__str__ExecuteStorageOperationResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _str__ExecuteStorageOperationResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__str__ExecuteStorageOperationResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__str__ExecuteStorageOperationResponse(struct soap *soap, const char *tag, int id, const _str__ExecuteStorageOperationResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__str__ExecuteStorageOperationResponse), type); + soap_element_result(soap, "str:Status"); + soap_out_str__PT_USCORESTATUS(soap, "str:Status", -1, &(((_str__ExecuteStorageOperationResponse*)a)->Status), ""); + (((_str__ExecuteStorageOperationResponse*)a)->Response).soap_out(soap, "str:Response", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_str__ExecuteStorageOperationResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__str__ExecuteStorageOperationResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _str__ExecuteStorageOperationResponse * SOAP_FMAC4 soap_get__str__ExecuteStorageOperationResponse(struct soap *soap, _str__ExecuteStorageOperationResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__str__ExecuteStorageOperationResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_str__ExecuteStorageOperationResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__str__ExecuteStorageOperationResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _str__ExecuteStorageOperationResponse * SOAP_FMAC4 soap_in__str__ExecuteStorageOperationResponse(struct soap *soap, const char *tag, _str__ExecuteStorageOperationResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_str__ExecuteStorageOperationResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__str__ExecuteStorageOperationResponse, sizeof(_str__ExecuteStorageOperationResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__str__ExecuteStorageOperationResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_str__ExecuteStorageOperationResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Response1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_str__PT_USCORESTATUS(soap, "str:Status", &(((_str__ExecuteStorageOperationResponse*)a)->Status), "str:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Response1 && soap->error == SOAP_TAG_MISMATCH) + if ((((_str__ExecuteStorageOperationResponse*)a)->Response).soap_in(soap, "str:Response", "xsd:base64Binary")) + { soap_flag_Response1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "str:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Response1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_str__ExecuteStorageOperationResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__str__ExecuteStorageOperationResponse, 0, sizeof(_str__ExecuteStorageOperationResponse), 0, soap_copy__str__ExecuteStorageOperationResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _str__ExecuteStorageOperationResponse * SOAP_FMAC6 soap_new__str__ExecuteStorageOperationResponse(struct soap *soap, int n) +{ return soap_instantiate__str__ExecuteStorageOperationResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__str__ExecuteStorageOperationResponse(struct soap *soap, _str__ExecuteStorageOperationResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _str__ExecuteStorageOperationResponse * SOAP_FMAC4 soap_instantiate__str__ExecuteStorageOperationResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__str__ExecuteStorageOperationResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__str__ExecuteStorageOperationResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _str__ExecuteStorageOperationResponse; + if (size) + *size = sizeof(_str__ExecuteStorageOperationResponse); + ((_str__ExecuteStorageOperationResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _str__ExecuteStorageOperationResponse[n]; + if (size) + *size = n * sizeof(_str__ExecuteStorageOperationResponse); + for (int i = 0; i < n; i++) + ((_str__ExecuteStorageOperationResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_str__ExecuteStorageOperationResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__str__ExecuteStorageOperationResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _str__ExecuteStorageOperationResponse %p -> %p\n", q, p)); + *(_str__ExecuteStorageOperationResponse*)p = *(_str__ExecuteStorageOperationResponse*)q; +} + +void _str__ExecuteStorageOperation::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_str__ExecuteStorageOperation*)this)->Request, SOAP_TYPE_xsd__base64Binary); + ((_str__ExecuteStorageOperation*)this)->Request.soap_serialize(soap); + /* transient soap skipped */ +} + +void _str__ExecuteStorageOperation::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_str__ExecuteStorageOperation*)this)->Request.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int _str__ExecuteStorageOperation::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__str__ExecuteStorageOperation); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _str__ExecuteStorageOperation::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__str__ExecuteStorageOperation(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__str__ExecuteStorageOperation(struct soap *soap, const char *tag, int id, const _str__ExecuteStorageOperation *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__str__ExecuteStorageOperation), type); + (((_str__ExecuteStorageOperation*)a)->Request).soap_out(soap, "str:Request", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_str__ExecuteStorageOperation::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__str__ExecuteStorageOperation(soap, this, tag, type); +} + +SOAP_FMAC3 _str__ExecuteStorageOperation * SOAP_FMAC4 soap_get__str__ExecuteStorageOperation(struct soap *soap, _str__ExecuteStorageOperation *p, const char *tag, const char *type) +{ + if ((p = soap_in__str__ExecuteStorageOperation(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_str__ExecuteStorageOperation::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__str__ExecuteStorageOperation(soap, tag, this, type); +} + +SOAP_FMAC3 _str__ExecuteStorageOperation * SOAP_FMAC4 soap_in__str__ExecuteStorageOperation(struct soap *soap, const char *tag, _str__ExecuteStorageOperation *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_str__ExecuteStorageOperation *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__str__ExecuteStorageOperation, sizeof(_str__ExecuteStorageOperation), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__str__ExecuteStorageOperation) + { soap_revert(soap); + *soap->id = '\0'; + return (_str__ExecuteStorageOperation *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Request1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Request1 && soap->error == SOAP_TAG_MISMATCH) + if ((((_str__ExecuteStorageOperation*)a)->Request).soap_in(soap, "str:Request", "xsd:base64Binary")) + { soap_flag_Request1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Request1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_str__ExecuteStorageOperation *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__str__ExecuteStorageOperation, 0, sizeof(_str__ExecuteStorageOperation), 0, soap_copy__str__ExecuteStorageOperation); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _str__ExecuteStorageOperation * SOAP_FMAC6 soap_new__str__ExecuteStorageOperation(struct soap *soap, int n) +{ return soap_instantiate__str__ExecuteStorageOperation(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__str__ExecuteStorageOperation(struct soap *soap, _str__ExecuteStorageOperation *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _str__ExecuteStorageOperation * SOAP_FMAC4 soap_instantiate__str__ExecuteStorageOperation(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__str__ExecuteStorageOperation(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__str__ExecuteStorageOperation, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _str__ExecuteStorageOperation; + if (size) + *size = sizeof(_str__ExecuteStorageOperation); + ((_str__ExecuteStorageOperation*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _str__ExecuteStorageOperation[n]; + if (size) + *size = n * sizeof(_str__ExecuteStorageOperation); + for (int i = 0; i < n; i++) + ((_str__ExecuteStorageOperation*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_str__ExecuteStorageOperation*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__str__ExecuteStorageOperation(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _str__ExecuteStorageOperation %p -> %p\n", q, p)); + *(_str__ExecuteStorageOperation*)p = *(_str__ExecuteStorageOperation*)q; +} + +void _tim__SetHighAccuracyTimeSynchResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _tim__SetHighAccuracyTimeSynchResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_tim__PT_USCORESTATUS(soap, &((_tim__SetHighAccuracyTimeSynchResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _tim__SetHighAccuracyTimeSynchResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _tim__SetHighAccuracyTimeSynchResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__tim__SetHighAccuracyTimeSynchResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, const char *tag, int id, const _tim__SetHighAccuracyTimeSynchResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse), type); + soap_element_result(soap, "tim:StatusCode"); + soap_out_tim__PT_USCORESTATUS(soap, "tim:StatusCode", -1, &(((_tim__SetHighAccuracyTimeSynchResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_tim__SetHighAccuracyTimeSynchResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__tim__SetHighAccuracyTimeSynchResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse * SOAP_FMAC4 soap_get__tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, _tim__SetHighAccuracyTimeSynchResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__tim__SetHighAccuracyTimeSynchResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_tim__SetHighAccuracyTimeSynchResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__tim__SetHighAccuracyTimeSynchResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse * SOAP_FMAC4 soap_in__tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, const char *tag, _tim__SetHighAccuracyTimeSynchResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_tim__SetHighAccuracyTimeSynchResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse, sizeof(_tim__SetHighAccuracyTimeSynchResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_tim__SetHighAccuracyTimeSynchResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_tim__PT_USCORESTATUS(soap, "tim:StatusCode", &(((_tim__SetHighAccuracyTimeSynchResponse*)a)->StatusCode), "tim:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "tim:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_tim__SetHighAccuracyTimeSynchResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse, 0, sizeof(_tim__SetHighAccuracyTimeSynchResponse), 0, soap_copy__tim__SetHighAccuracyTimeSynchResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _tim__SetHighAccuracyTimeSynchResponse * SOAP_FMAC6 soap_new__tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, int n) +{ return soap_instantiate__tim__SetHighAccuracyTimeSynchResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, _tim__SetHighAccuracyTimeSynchResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse * SOAP_FMAC4 soap_instantiate__tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__tim__SetHighAccuracyTimeSynchResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _tim__SetHighAccuracyTimeSynchResponse; + if (size) + *size = sizeof(_tim__SetHighAccuracyTimeSynchResponse); + ((_tim__SetHighAccuracyTimeSynchResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _tim__SetHighAccuracyTimeSynchResponse[n]; + if (size) + *size = n * sizeof(_tim__SetHighAccuracyTimeSynchResponse); + for (int i = 0; i < n; i++) + ((_tim__SetHighAccuracyTimeSynchResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_tim__SetHighAccuracyTimeSynchResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _tim__SetHighAccuracyTimeSynchResponse %p -> %p\n", q, p)); + *(_tim__SetHighAccuracyTimeSynchResponse*)p = *(_tim__SetHighAccuracyTimeSynchResponse*)q; +} + +void _tim__SetHighAccuracyTimeSynch::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _tim__SetHighAccuracyTimeSynch::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_tim__TimeType(soap, &((_tim__SetHighAccuracyTimeSynch*)this)->Ta0); + soap_default_tim__TimeType(soap, &((_tim__SetHighAccuracyTimeSynch*)this)->Tm1); + soap_default_tim__TimeType(soap, &((_tim__SetHighAccuracyTimeSynch*)this)->Tm2); + /* transient soap skipped */ +} + +int _tim__SetHighAccuracyTimeSynch::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__tim__SetHighAccuracyTimeSynch); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _tim__SetHighAccuracyTimeSynch::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__tim__SetHighAccuracyTimeSynch(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__tim__SetHighAccuracyTimeSynch(struct soap *soap, const char *tag, int id, const _tim__SetHighAccuracyTimeSynch *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__tim__SetHighAccuracyTimeSynch), type); + soap_out_tim__TimeType(soap, "tim:Ta0", -1, &(((_tim__SetHighAccuracyTimeSynch*)a)->Ta0), ""); + soap_out_tim__TimeType(soap, "tim:Tm1", -1, &(((_tim__SetHighAccuracyTimeSynch*)a)->Tm1), ""); + soap_out_tim__TimeType(soap, "tim:Tm2", -1, &(((_tim__SetHighAccuracyTimeSynch*)a)->Tm2), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_tim__SetHighAccuracyTimeSynch::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__tim__SetHighAccuracyTimeSynch(soap, this, tag, type); +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_get__tim__SetHighAccuracyTimeSynch(struct soap *soap, _tim__SetHighAccuracyTimeSynch *p, const char *tag, const char *type) +{ + if ((p = soap_in__tim__SetHighAccuracyTimeSynch(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_tim__SetHighAccuracyTimeSynch::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__tim__SetHighAccuracyTimeSynch(soap, tag, this, type); +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_in__tim__SetHighAccuracyTimeSynch(struct soap *soap, const char *tag, _tim__SetHighAccuracyTimeSynch *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_tim__SetHighAccuracyTimeSynch *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__tim__SetHighAccuracyTimeSynch, sizeof(_tim__SetHighAccuracyTimeSynch), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__tim__SetHighAccuracyTimeSynch) + { soap_revert(soap); + *soap->id = '\0'; + return (_tim__SetHighAccuracyTimeSynch *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Ta01 = 1, soap_flag_Tm11 = 1, soap_flag_Tm21 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Ta01 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_tim__TimeType(soap, "tim:Ta0", &(((_tim__SetHighAccuracyTimeSynch*)a)->Ta0), "tim:TimeType")) + { soap_flag_Ta01--; + continue; + } + if (soap_flag_Tm11 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_tim__TimeType(soap, "tim:Tm1", &(((_tim__SetHighAccuracyTimeSynch*)a)->Tm1), "tim:TimeType")) + { soap_flag_Tm11--; + continue; + } + if (soap_flag_Tm21 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_tim__TimeType(soap, "tim:Tm2", &(((_tim__SetHighAccuracyTimeSynch*)a)->Tm2), "tim:TimeType")) + { soap_flag_Tm21--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Ta01 > 0 || soap_flag_Tm11 > 0 || soap_flag_Tm21 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_tim__SetHighAccuracyTimeSynch *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__tim__SetHighAccuracyTimeSynch, 0, sizeof(_tim__SetHighAccuracyTimeSynch), 0, soap_copy__tim__SetHighAccuracyTimeSynch); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _tim__SetHighAccuracyTimeSynch * SOAP_FMAC6 soap_new__tim__SetHighAccuracyTimeSynch(struct soap *soap, int n) +{ return soap_instantiate__tim__SetHighAccuracyTimeSynch(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__tim__SetHighAccuracyTimeSynch(struct soap *soap, _tim__SetHighAccuracyTimeSynch *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_instantiate__tim__SetHighAccuracyTimeSynch(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__tim__SetHighAccuracyTimeSynch(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__tim__SetHighAccuracyTimeSynch, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _tim__SetHighAccuracyTimeSynch; + if (size) + *size = sizeof(_tim__SetHighAccuracyTimeSynch); + ((_tim__SetHighAccuracyTimeSynch*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _tim__SetHighAccuracyTimeSynch[n]; + if (size) + *size = n * sizeof(_tim__SetHighAccuracyTimeSynch); + for (int i = 0; i < n; i++) + ((_tim__SetHighAccuracyTimeSynch*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_tim__SetHighAccuracyTimeSynch*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__tim__SetHighAccuracyTimeSynch(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _tim__SetHighAccuracyTimeSynch %p -> %p\n", q, p)); + *(_tim__SetHighAccuracyTimeSynch*)p = *(_tim__SetHighAccuracyTimeSynch*)q; +} + +void _tim__GetLowAccuracyTimeSynchResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _tim__GetLowAccuracyTimeSynchResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_tim__PT_USCORESTATUS(soap, &((_tim__GetLowAccuracyTimeSynchResponse*)this)->StatusCode); + soap_default_tim__TimeType(soap, &((_tim__GetLowAccuracyTimeSynchResponse*)this)->Ta0); + /* transient soap skipped */ +} + +int _tim__GetLowAccuracyTimeSynchResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _tim__GetLowAccuracyTimeSynchResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__tim__GetLowAccuracyTimeSynchResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, const char *tag, int id, const _tim__GetLowAccuracyTimeSynchResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse), type); + soap_element_result(soap, "tim:StatusCode"); + soap_out_tim__PT_USCORESTATUS(soap, "tim:StatusCode", -1, &(((_tim__GetLowAccuracyTimeSynchResponse*)a)->StatusCode), ""); + soap_out_tim__TimeType(soap, "tim:Ta0", -1, &(((_tim__GetLowAccuracyTimeSynchResponse*)a)->Ta0), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_tim__GetLowAccuracyTimeSynchResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__tim__GetLowAccuracyTimeSynchResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse * SOAP_FMAC4 soap_get__tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, _tim__GetLowAccuracyTimeSynchResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__tim__GetLowAccuracyTimeSynchResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_tim__GetLowAccuracyTimeSynchResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__tim__GetLowAccuracyTimeSynchResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse * SOAP_FMAC4 soap_in__tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, const char *tag, _tim__GetLowAccuracyTimeSynchResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_tim__GetLowAccuracyTimeSynchResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse, sizeof(_tim__GetLowAccuracyTimeSynchResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_tim__GetLowAccuracyTimeSynchResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Ta01 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_tim__PT_USCORESTATUS(soap, "tim:StatusCode", &(((_tim__GetLowAccuracyTimeSynchResponse*)a)->StatusCode), "tim:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Ta01 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_tim__TimeType(soap, "tim:Ta0", &(((_tim__GetLowAccuracyTimeSynchResponse*)a)->Ta0), "tim:TimeType")) + { soap_flag_Ta01--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "tim:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Ta01 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_tim__GetLowAccuracyTimeSynchResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse, 0, sizeof(_tim__GetLowAccuracyTimeSynchResponse), 0, soap_copy__tim__GetLowAccuracyTimeSynchResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _tim__GetLowAccuracyTimeSynchResponse * SOAP_FMAC6 soap_new__tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, int n) +{ return soap_instantiate__tim__GetLowAccuracyTimeSynchResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, _tim__GetLowAccuracyTimeSynchResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse * SOAP_FMAC4 soap_instantiate__tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__tim__GetLowAccuracyTimeSynchResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _tim__GetLowAccuracyTimeSynchResponse; + if (size) + *size = sizeof(_tim__GetLowAccuracyTimeSynchResponse); + ((_tim__GetLowAccuracyTimeSynchResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _tim__GetLowAccuracyTimeSynchResponse[n]; + if (size) + *size = n * sizeof(_tim__GetLowAccuracyTimeSynchResponse); + for (int i = 0; i < n; i++) + ((_tim__GetLowAccuracyTimeSynchResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_tim__GetLowAccuracyTimeSynchResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _tim__GetLowAccuracyTimeSynchResponse %p -> %p\n", q, p)); + *(_tim__GetLowAccuracyTimeSynchResponse*)p = *(_tim__GetLowAccuracyTimeSynchResponse*)q; +} + +void _tim__GetLowAccuracyTimeSynch::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _tim__GetLowAccuracyTimeSynch::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _tim__GetLowAccuracyTimeSynch::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__tim__GetLowAccuracyTimeSynch); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _tim__GetLowAccuracyTimeSynch::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__tim__GetLowAccuracyTimeSynch(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__tim__GetLowAccuracyTimeSynch(struct soap *soap, const char *tag, int id, const _tim__GetLowAccuracyTimeSynch *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__tim__GetLowAccuracyTimeSynch), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_tim__GetLowAccuracyTimeSynch::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__tim__GetLowAccuracyTimeSynch(soap, this, tag, type); +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_get__tim__GetLowAccuracyTimeSynch(struct soap *soap, _tim__GetLowAccuracyTimeSynch *p, const char *tag, const char *type) +{ + if ((p = soap_in__tim__GetLowAccuracyTimeSynch(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_tim__GetLowAccuracyTimeSynch::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__tim__GetLowAccuracyTimeSynch(soap, tag, this, type); +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_in__tim__GetLowAccuracyTimeSynch(struct soap *soap, const char *tag, _tim__GetLowAccuracyTimeSynch *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_tim__GetLowAccuracyTimeSynch *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__tim__GetLowAccuracyTimeSynch, sizeof(_tim__GetLowAccuracyTimeSynch), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__tim__GetLowAccuracyTimeSynch) + { soap_revert(soap); + *soap->id = '\0'; + return (_tim__GetLowAccuracyTimeSynch *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_tim__GetLowAccuracyTimeSynch *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__tim__GetLowAccuracyTimeSynch, 0, sizeof(_tim__GetLowAccuracyTimeSynch), 0, soap_copy__tim__GetLowAccuracyTimeSynch); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _tim__GetLowAccuracyTimeSynch * SOAP_FMAC6 soap_new__tim__GetLowAccuracyTimeSynch(struct soap *soap, int n) +{ return soap_instantiate__tim__GetLowAccuracyTimeSynch(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__tim__GetLowAccuracyTimeSynch(struct soap *soap, _tim__GetLowAccuracyTimeSynch *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_instantiate__tim__GetLowAccuracyTimeSynch(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__tim__GetLowAccuracyTimeSynch(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__tim__GetLowAccuracyTimeSynch, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _tim__GetLowAccuracyTimeSynch; + if (size) + *size = sizeof(_tim__GetLowAccuracyTimeSynch); + ((_tim__GetLowAccuracyTimeSynch*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _tim__GetLowAccuracyTimeSynch[n]; + if (size) + *size = n * sizeof(_tim__GetLowAccuracyTimeSynch); + for (int i = 0; i < n; i++) + ((_tim__GetLowAccuracyTimeSynch*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_tim__GetLowAccuracyTimeSynch*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__tim__GetLowAccuracyTimeSynch(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _tim__GetLowAccuracyTimeSynch %p -> %p\n", q, p)); + *(_tim__GetLowAccuracyTimeSynch*)p = *(_tim__GetLowAccuracyTimeSynch*)q; +} + +void _idr__GetIderSessionLogResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(soap, &((_idr__GetIderSessionLogResponse*)this)->LogData); + /* transient soap skipped */ +} + +void _idr__GetIderSessionLogResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_idr__PT_USCORESTATUS(soap, &((_idr__GetIderSessionLogResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(soap, &((_idr__GetIderSessionLogResponse*)this)->LogData); + /* transient soap skipped */ +} + +int _idr__GetIderSessionLogResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__idr__GetIderSessionLogResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _idr__GetIderSessionLogResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__idr__GetIderSessionLogResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__GetIderSessionLogResponse(struct soap *soap, const char *tag, int id, const _idr__GetIderSessionLogResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__idr__GetIderSessionLogResponse), type); + soap_element_result(soap, "idr:StatusCode"); + soap_out_idr__PT_USCORESTATUS(soap, "idr:StatusCode", -1, &(((_idr__GetIderSessionLogResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(soap, "idr:LogData", -1, &(((_idr__GetIderSessionLogResponse*)a)->LogData), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_idr__GetIderSessionLogResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__idr__GetIderSessionLogResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _idr__GetIderSessionLogResponse * SOAP_FMAC4 soap_get__idr__GetIderSessionLogResponse(struct soap *soap, _idr__GetIderSessionLogResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__idr__GetIderSessionLogResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_idr__GetIderSessionLogResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__idr__GetIderSessionLogResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _idr__GetIderSessionLogResponse * SOAP_FMAC4 soap_in__idr__GetIderSessionLogResponse(struct soap *soap, const char *tag, _idr__GetIderSessionLogResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_idr__GetIderSessionLogResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__idr__GetIderSessionLogResponse, sizeof(_idr__GetIderSessionLogResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__idr__GetIderSessionLogResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_idr__GetIderSessionLogResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_idr__PT_USCORESTATUS(soap, "idr:StatusCode", &(((_idr__GetIderSessionLogResponse*)a)->StatusCode), "idr:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(soap, "idr:LogData", &(((_idr__GetIderSessionLogResponse*)a)->LogData), "idr:IderSessionLogEntryType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "idr:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_idr__GetIderSessionLogResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__idr__GetIderSessionLogResponse, 0, sizeof(_idr__GetIderSessionLogResponse), 0, soap_copy__idr__GetIderSessionLogResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _idr__GetIderSessionLogResponse * SOAP_FMAC6 soap_new__idr__GetIderSessionLogResponse(struct soap *soap, int n) +{ return soap_instantiate__idr__GetIderSessionLogResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__GetIderSessionLogResponse(struct soap *soap, _idr__GetIderSessionLogResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _idr__GetIderSessionLogResponse * SOAP_FMAC4 soap_instantiate__idr__GetIderSessionLogResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__idr__GetIderSessionLogResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__idr__GetIderSessionLogResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _idr__GetIderSessionLogResponse; + if (size) + *size = sizeof(_idr__GetIderSessionLogResponse); + ((_idr__GetIderSessionLogResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _idr__GetIderSessionLogResponse[n]; + if (size) + *size = n * sizeof(_idr__GetIderSessionLogResponse); + for (int i = 0; i < n; i++) + ((_idr__GetIderSessionLogResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_idr__GetIderSessionLogResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__GetIderSessionLogResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _idr__GetIderSessionLogResponse %p -> %p\n", q, p)); + *(_idr__GetIderSessionLogResponse*)p = *(_idr__GetIderSessionLogResponse*)q; +} + +void _idr__GetIderSessionLog::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _idr__GetIderSessionLog::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _idr__GetIderSessionLog::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__idr__GetIderSessionLog); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _idr__GetIderSessionLog::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__idr__GetIderSessionLog(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__GetIderSessionLog(struct soap *soap, const char *tag, int id, const _idr__GetIderSessionLog *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__idr__GetIderSessionLog), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_idr__GetIderSessionLog::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__idr__GetIderSessionLog(soap, this, tag, type); +} + +SOAP_FMAC3 _idr__GetIderSessionLog * SOAP_FMAC4 soap_get__idr__GetIderSessionLog(struct soap *soap, _idr__GetIderSessionLog *p, const char *tag, const char *type) +{ + if ((p = soap_in__idr__GetIderSessionLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_idr__GetIderSessionLog::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__idr__GetIderSessionLog(soap, tag, this, type); +} + +SOAP_FMAC3 _idr__GetIderSessionLog * SOAP_FMAC4 soap_in__idr__GetIderSessionLog(struct soap *soap, const char *tag, _idr__GetIderSessionLog *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_idr__GetIderSessionLog *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__idr__GetIderSessionLog, sizeof(_idr__GetIderSessionLog), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__idr__GetIderSessionLog) + { soap_revert(soap); + *soap->id = '\0'; + return (_idr__GetIderSessionLog *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_idr__GetIderSessionLog *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__idr__GetIderSessionLog, 0, sizeof(_idr__GetIderSessionLog), 0, soap_copy__idr__GetIderSessionLog); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _idr__GetIderSessionLog * SOAP_FMAC6 soap_new__idr__GetIderSessionLog(struct soap *soap, int n) +{ return soap_instantiate__idr__GetIderSessionLog(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__GetIderSessionLog(struct soap *soap, _idr__GetIderSessionLog *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _idr__GetIderSessionLog * SOAP_FMAC4 soap_instantiate__idr__GetIderSessionLog(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__idr__GetIderSessionLog(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__idr__GetIderSessionLog, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _idr__GetIderSessionLog; + if (size) + *size = sizeof(_idr__GetIderSessionLog); + ((_idr__GetIderSessionLog*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _idr__GetIderSessionLog[n]; + if (size) + *size = n * sizeof(_idr__GetIderSessionLog); + for (int i = 0; i < n; i++) + ((_idr__GetIderSessionLog*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_idr__GetIderSessionLog*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__GetIderSessionLog(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _idr__GetIderSessionLog %p -> %p\n", q, p)); + *(_idr__GetIderSessionLog*)p = *(_idr__GetIderSessionLog*)q; +} + +void _idr__GetRedirectionListenerStateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_idr__GetRedirectionListenerStateResponse*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _idr__GetRedirectionListenerStateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_idr__PT_USCORESTATUS(soap, &((_idr__GetRedirectionListenerStateResponse*)this)->StatusCode); + soap_default_bool(soap, &((_idr__GetRedirectionListenerStateResponse*)this)->Enabled); + /* transient soap skipped */ +} + +int _idr__GetRedirectionListenerStateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__idr__GetRedirectionListenerStateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _idr__GetRedirectionListenerStateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__idr__GetRedirectionListenerStateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__GetRedirectionListenerStateResponse(struct soap *soap, const char *tag, int id, const _idr__GetRedirectionListenerStateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__idr__GetRedirectionListenerStateResponse), type); + soap_element_result(soap, "idr:StatusCode"); + soap_out_idr__PT_USCORESTATUS(soap, "idr:StatusCode", -1, &(((_idr__GetRedirectionListenerStateResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "idr:Enabled", -1, &(((_idr__GetRedirectionListenerStateResponse*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_idr__GetRedirectionListenerStateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__idr__GetRedirectionListenerStateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse * SOAP_FMAC4 soap_get__idr__GetRedirectionListenerStateResponse(struct soap *soap, _idr__GetRedirectionListenerStateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__idr__GetRedirectionListenerStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_idr__GetRedirectionListenerStateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__idr__GetRedirectionListenerStateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse * SOAP_FMAC4 soap_in__idr__GetRedirectionListenerStateResponse(struct soap *soap, const char *tag, _idr__GetRedirectionListenerStateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_idr__GetRedirectionListenerStateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__idr__GetRedirectionListenerStateResponse, sizeof(_idr__GetRedirectionListenerStateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__idr__GetRedirectionListenerStateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_idr__GetRedirectionListenerStateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_idr__PT_USCORESTATUS(soap, "idr:StatusCode", &(((_idr__GetRedirectionListenerStateResponse*)a)->StatusCode), "idr:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "idr:Enabled", &(((_idr__GetRedirectionListenerStateResponse*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "idr:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_idr__GetRedirectionListenerStateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__idr__GetRedirectionListenerStateResponse, 0, sizeof(_idr__GetRedirectionListenerStateResponse), 0, soap_copy__idr__GetRedirectionListenerStateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _idr__GetRedirectionListenerStateResponse * SOAP_FMAC6 soap_new__idr__GetRedirectionListenerStateResponse(struct soap *soap, int n) +{ return soap_instantiate__idr__GetRedirectionListenerStateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__GetRedirectionListenerStateResponse(struct soap *soap, _idr__GetRedirectionListenerStateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse * SOAP_FMAC4 soap_instantiate__idr__GetRedirectionListenerStateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__idr__GetRedirectionListenerStateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__idr__GetRedirectionListenerStateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _idr__GetRedirectionListenerStateResponse; + if (size) + *size = sizeof(_idr__GetRedirectionListenerStateResponse); + ((_idr__GetRedirectionListenerStateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _idr__GetRedirectionListenerStateResponse[n]; + if (size) + *size = n * sizeof(_idr__GetRedirectionListenerStateResponse); + for (int i = 0; i < n; i++) + ((_idr__GetRedirectionListenerStateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_idr__GetRedirectionListenerStateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__GetRedirectionListenerStateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _idr__GetRedirectionListenerStateResponse %p -> %p\n", q, p)); + *(_idr__GetRedirectionListenerStateResponse*)p = *(_idr__GetRedirectionListenerStateResponse*)q; +} + +void _idr__GetRedirectionListenerState::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _idr__GetRedirectionListenerState::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _idr__GetRedirectionListenerState::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__idr__GetRedirectionListenerState); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _idr__GetRedirectionListenerState::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__idr__GetRedirectionListenerState(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__GetRedirectionListenerState(struct soap *soap, const char *tag, int id, const _idr__GetRedirectionListenerState *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__idr__GetRedirectionListenerState), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_idr__GetRedirectionListenerState::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__idr__GetRedirectionListenerState(soap, this, tag, type); +} + +SOAP_FMAC3 _idr__GetRedirectionListenerState * SOAP_FMAC4 soap_get__idr__GetRedirectionListenerState(struct soap *soap, _idr__GetRedirectionListenerState *p, const char *tag, const char *type) +{ + if ((p = soap_in__idr__GetRedirectionListenerState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_idr__GetRedirectionListenerState::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__idr__GetRedirectionListenerState(soap, tag, this, type); +} + +SOAP_FMAC3 _idr__GetRedirectionListenerState * SOAP_FMAC4 soap_in__idr__GetRedirectionListenerState(struct soap *soap, const char *tag, _idr__GetRedirectionListenerState *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_idr__GetRedirectionListenerState *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__idr__GetRedirectionListenerState, sizeof(_idr__GetRedirectionListenerState), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__idr__GetRedirectionListenerState) + { soap_revert(soap); + *soap->id = '\0'; + return (_idr__GetRedirectionListenerState *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_idr__GetRedirectionListenerState *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__idr__GetRedirectionListenerState, 0, sizeof(_idr__GetRedirectionListenerState), 0, soap_copy__idr__GetRedirectionListenerState); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _idr__GetRedirectionListenerState * SOAP_FMAC6 soap_new__idr__GetRedirectionListenerState(struct soap *soap, int n) +{ return soap_instantiate__idr__GetRedirectionListenerState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__GetRedirectionListenerState(struct soap *soap, _idr__GetRedirectionListenerState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _idr__GetRedirectionListenerState * SOAP_FMAC4 soap_instantiate__idr__GetRedirectionListenerState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__idr__GetRedirectionListenerState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__idr__GetRedirectionListenerState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _idr__GetRedirectionListenerState; + if (size) + *size = sizeof(_idr__GetRedirectionListenerState); + ((_idr__GetRedirectionListenerState*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _idr__GetRedirectionListenerState[n]; + if (size) + *size = n * sizeof(_idr__GetRedirectionListenerState); + for (int i = 0; i < n; i++) + ((_idr__GetRedirectionListenerState*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_idr__GetRedirectionListenerState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__GetRedirectionListenerState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _idr__GetRedirectionListenerState %p -> %p\n", q, p)); + *(_idr__GetRedirectionListenerState*)p = *(_idr__GetRedirectionListenerState*)q; +} + +void _idr__SetRedirectionListenerStateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _idr__SetRedirectionListenerStateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_idr__PT_USCORESTATUS(soap, &((_idr__SetRedirectionListenerStateResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _idr__SetRedirectionListenerStateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__idr__SetRedirectionListenerStateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _idr__SetRedirectionListenerStateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__idr__SetRedirectionListenerStateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__SetRedirectionListenerStateResponse(struct soap *soap, const char *tag, int id, const _idr__SetRedirectionListenerStateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__idr__SetRedirectionListenerStateResponse), type); + soap_element_result(soap, "idr:StatusCode"); + soap_out_idr__PT_USCORESTATUS(soap, "idr:StatusCode", -1, &(((_idr__SetRedirectionListenerStateResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_idr__SetRedirectionListenerStateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__idr__SetRedirectionListenerStateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse * SOAP_FMAC4 soap_get__idr__SetRedirectionListenerStateResponse(struct soap *soap, _idr__SetRedirectionListenerStateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__idr__SetRedirectionListenerStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_idr__SetRedirectionListenerStateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__idr__SetRedirectionListenerStateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse * SOAP_FMAC4 soap_in__idr__SetRedirectionListenerStateResponse(struct soap *soap, const char *tag, _idr__SetRedirectionListenerStateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_idr__SetRedirectionListenerStateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__idr__SetRedirectionListenerStateResponse, sizeof(_idr__SetRedirectionListenerStateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__idr__SetRedirectionListenerStateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_idr__SetRedirectionListenerStateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_idr__PT_USCORESTATUS(soap, "idr:StatusCode", &(((_idr__SetRedirectionListenerStateResponse*)a)->StatusCode), "idr:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "idr:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_idr__SetRedirectionListenerStateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__idr__SetRedirectionListenerStateResponse, 0, sizeof(_idr__SetRedirectionListenerStateResponse), 0, soap_copy__idr__SetRedirectionListenerStateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _idr__SetRedirectionListenerStateResponse * SOAP_FMAC6 soap_new__idr__SetRedirectionListenerStateResponse(struct soap *soap, int n) +{ return soap_instantiate__idr__SetRedirectionListenerStateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__SetRedirectionListenerStateResponse(struct soap *soap, _idr__SetRedirectionListenerStateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse * SOAP_FMAC4 soap_instantiate__idr__SetRedirectionListenerStateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__idr__SetRedirectionListenerStateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__idr__SetRedirectionListenerStateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _idr__SetRedirectionListenerStateResponse; + if (size) + *size = sizeof(_idr__SetRedirectionListenerStateResponse); + ((_idr__SetRedirectionListenerStateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _idr__SetRedirectionListenerStateResponse[n]; + if (size) + *size = n * sizeof(_idr__SetRedirectionListenerStateResponse); + for (int i = 0; i < n; i++) + ((_idr__SetRedirectionListenerStateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_idr__SetRedirectionListenerStateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__SetRedirectionListenerStateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _idr__SetRedirectionListenerStateResponse %p -> %p\n", q, p)); + *(_idr__SetRedirectionListenerStateResponse*)p = *(_idr__SetRedirectionListenerStateResponse*)q; +} + +void _idr__SetRedirectionListenerState::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_idr__SetRedirectionListenerState*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _idr__SetRedirectionListenerState::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((_idr__SetRedirectionListenerState*)this)->Enabled); + /* transient soap skipped */ +} + +int _idr__SetRedirectionListenerState::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__idr__SetRedirectionListenerState); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _idr__SetRedirectionListenerState::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__idr__SetRedirectionListenerState(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__idr__SetRedirectionListenerState(struct soap *soap, const char *tag, int id, const _idr__SetRedirectionListenerState *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__idr__SetRedirectionListenerState), type); + soap_out_bool(soap, "idr:Enabled", -1, &(((_idr__SetRedirectionListenerState*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_idr__SetRedirectionListenerState::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__idr__SetRedirectionListenerState(soap, this, tag, type); +} + +SOAP_FMAC3 _idr__SetRedirectionListenerState * SOAP_FMAC4 soap_get__idr__SetRedirectionListenerState(struct soap *soap, _idr__SetRedirectionListenerState *p, const char *tag, const char *type) +{ + if ((p = soap_in__idr__SetRedirectionListenerState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_idr__SetRedirectionListenerState::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__idr__SetRedirectionListenerState(soap, tag, this, type); +} + +SOAP_FMAC3 _idr__SetRedirectionListenerState * SOAP_FMAC4 soap_in__idr__SetRedirectionListenerState(struct soap *soap, const char *tag, _idr__SetRedirectionListenerState *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_idr__SetRedirectionListenerState *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__idr__SetRedirectionListenerState, sizeof(_idr__SetRedirectionListenerState), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__idr__SetRedirectionListenerState) + { soap_revert(soap); + *soap->id = '\0'; + return (_idr__SetRedirectionListenerState *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "idr:Enabled", &(((_idr__SetRedirectionListenerState*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_idr__SetRedirectionListenerState *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__idr__SetRedirectionListenerState, 0, sizeof(_idr__SetRedirectionListenerState), 0, soap_copy__idr__SetRedirectionListenerState); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _idr__SetRedirectionListenerState * SOAP_FMAC6 soap_new__idr__SetRedirectionListenerState(struct soap *soap, int n) +{ return soap_instantiate__idr__SetRedirectionListenerState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__idr__SetRedirectionListenerState(struct soap *soap, _idr__SetRedirectionListenerState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _idr__SetRedirectionListenerState * SOAP_FMAC4 soap_instantiate__idr__SetRedirectionListenerState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__idr__SetRedirectionListenerState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__idr__SetRedirectionListenerState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _idr__SetRedirectionListenerState; + if (size) + *size = sizeof(_idr__SetRedirectionListenerState); + ((_idr__SetRedirectionListenerState*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _idr__SetRedirectionListenerState[n]; + if (size) + *size = n * sizeof(_idr__SetRedirectionListenerState); + for (int i = 0; i < n; i++) + ((_idr__SetRedirectionListenerState*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_idr__SetRedirectionListenerState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__idr__SetRedirectionListenerState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _idr__SetRedirectionListenerState %p -> %p\n", q, p)); + *(_idr__SetRedirectionListenerState*)p = *(_idr__SetRedirectionListenerState*)q; +} + +void idr__FirmwareVersionType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((idr__FirmwareVersionType*)this)->Description, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((idr__FirmwareVersionType*)this)->Description); + soap_embedded(soap, &((idr__FirmwareVersionType*)this)->Version, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((idr__FirmwareVersionType*)this)->Version); + /* transient soap skipped */ +} + +void idr__FirmwareVersionType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((idr__FirmwareVersionType*)this)->Description); + soap_default_std__string(soap, &((idr__FirmwareVersionType*)this)->Version); + /* transient soap skipped */ +} + +int idr__FirmwareVersionType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_idr__FirmwareVersionType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int idr__FirmwareVersionType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_idr__FirmwareVersionType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__FirmwareVersionType(struct soap *soap, const char *tag, int id, const idr__FirmwareVersionType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_idr__FirmwareVersionType), type); + soap_out_std__string(soap, "idr:Description", -1, &(((idr__FirmwareVersionType*)a)->Description), ""); + soap_out_std__string(soap, "idr:Version", -1, &(((idr__FirmwareVersionType*)a)->Version), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *idr__FirmwareVersionType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_idr__FirmwareVersionType(soap, this, tag, type); +} + +SOAP_FMAC3 idr__FirmwareVersionType * SOAP_FMAC4 soap_get_idr__FirmwareVersionType(struct soap *soap, idr__FirmwareVersionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_idr__FirmwareVersionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *idr__FirmwareVersionType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_idr__FirmwareVersionType(soap, tag, this, type); +} + +SOAP_FMAC3 idr__FirmwareVersionType * SOAP_FMAC4 soap_in_idr__FirmwareVersionType(struct soap *soap, const char *tag, idr__FirmwareVersionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (idr__FirmwareVersionType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_idr__FirmwareVersionType, sizeof(idr__FirmwareVersionType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_idr__FirmwareVersionType) + { soap_revert(soap); + *soap->id = '\0'; + return (idr__FirmwareVersionType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Description1 = 1, soap_flag_Version1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Description1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "idr:Description", &(((idr__FirmwareVersionType*)a)->Description), "xsd:string")) + { soap_flag_Description1--; + continue; + } + if (soap_flag_Version1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "idr:Version", &(((idr__FirmwareVersionType*)a)->Version), "xsd:string")) + { soap_flag_Version1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Description1 > 0 || soap_flag_Version1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (idr__FirmwareVersionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_idr__FirmwareVersionType, 0, sizeof(idr__FirmwareVersionType), 0, soap_copy_idr__FirmwareVersionType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 idr__FirmwareVersionType * SOAP_FMAC6 soap_new_idr__FirmwareVersionType(struct soap *soap, int n) +{ return soap_instantiate_idr__FirmwareVersionType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_idr__FirmwareVersionType(struct soap *soap, idr__FirmwareVersionType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 idr__FirmwareVersionType * SOAP_FMAC4 soap_instantiate_idr__FirmwareVersionType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_idr__FirmwareVersionType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_idr__FirmwareVersionType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new idr__FirmwareVersionType; + if (size) + *size = sizeof(idr__FirmwareVersionType); + ((idr__FirmwareVersionType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new idr__FirmwareVersionType[n]; + if (size) + *size = n * sizeof(idr__FirmwareVersionType); + for (int i = 0; i < n; i++) + ((idr__FirmwareVersionType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (idr__FirmwareVersionType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_idr__FirmwareVersionType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying idr__FirmwareVersionType %p -> %p\n", q, p)); + *(idr__FirmwareVersionType*)p = *(idr__FirmwareVersionType*)q; +} + +void idr__IderSessionLogEntryType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((idr__IderSessionLogEntryType*)this)->Port, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void idr__IderSessionLogEntryType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_idr__IPv4AddressType(soap, &((idr__IderSessionLogEntryType*)this)->ConsoleAddress); + soap_default_unsignedShort(soap, &((idr__IderSessionLogEntryType*)this)->Port); + soap_default_idr__TimeType(soap, &((idr__IderSessionLogEntryType*)this)->TimeStamp); + /* transient soap skipped */ +} + +int idr__IderSessionLogEntryType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_idr__IderSessionLogEntryType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int idr__IderSessionLogEntryType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_idr__IderSessionLogEntryType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_idr__IderSessionLogEntryType(struct soap *soap, const char *tag, int id, const idr__IderSessionLogEntryType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_idr__IderSessionLogEntryType), type); + soap_out_idr__IPv4AddressType(soap, "idr:ConsoleAddress", -1, &(((idr__IderSessionLogEntryType*)a)->ConsoleAddress), ""); + soap_out_unsignedShort(soap, "idr:Port", -1, &(((idr__IderSessionLogEntryType*)a)->Port), ""); + soap_out_idr__TimeType(soap, "idr:TimeStamp", -1, &(((idr__IderSessionLogEntryType*)a)->TimeStamp), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *idr__IderSessionLogEntryType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_idr__IderSessionLogEntryType(soap, this, tag, type); +} + +SOAP_FMAC3 idr__IderSessionLogEntryType * SOAP_FMAC4 soap_get_idr__IderSessionLogEntryType(struct soap *soap, idr__IderSessionLogEntryType *p, const char *tag, const char *type) +{ + if ((p = soap_in_idr__IderSessionLogEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *idr__IderSessionLogEntryType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_idr__IderSessionLogEntryType(soap, tag, this, type); +} + +SOAP_FMAC3 idr__IderSessionLogEntryType * SOAP_FMAC4 soap_in_idr__IderSessionLogEntryType(struct soap *soap, const char *tag, idr__IderSessionLogEntryType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (idr__IderSessionLogEntryType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_idr__IderSessionLogEntryType, sizeof(idr__IderSessionLogEntryType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_idr__IderSessionLogEntryType) + { soap_revert(soap); + *soap->id = '\0'; + return (idr__IderSessionLogEntryType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ConsoleAddress1 = 1, soap_flag_Port1 = 1, soap_flag_TimeStamp1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ConsoleAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_idr__IPv4AddressType(soap, "idr:ConsoleAddress", &(((idr__IderSessionLogEntryType*)a)->ConsoleAddress), "idr:IPv4AddressType")) + { soap_flag_ConsoleAddress1--; + continue; + } + if (soap_flag_Port1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "idr:Port", &(((idr__IderSessionLogEntryType*)a)->Port), "xsd:unsignedShort")) + { soap_flag_Port1--; + continue; + } + if (soap_flag_TimeStamp1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_idr__TimeType(soap, "idr:TimeStamp", &(((idr__IderSessionLogEntryType*)a)->TimeStamp), "idr:TimeType")) + { soap_flag_TimeStamp1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ConsoleAddress1 > 0 || soap_flag_Port1 > 0 || soap_flag_TimeStamp1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (idr__IderSessionLogEntryType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_idr__IderSessionLogEntryType, 0, sizeof(idr__IderSessionLogEntryType), 0, soap_copy_idr__IderSessionLogEntryType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 idr__IderSessionLogEntryType * SOAP_FMAC6 soap_new_idr__IderSessionLogEntryType(struct soap *soap, int n) +{ return soap_instantiate_idr__IderSessionLogEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_idr__IderSessionLogEntryType(struct soap *soap, idr__IderSessionLogEntryType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 idr__IderSessionLogEntryType * SOAP_FMAC4 soap_instantiate_idr__IderSessionLogEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_idr__IderSessionLogEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_idr__IderSessionLogEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new idr__IderSessionLogEntryType; + if (size) + *size = sizeof(idr__IderSessionLogEntryType); + ((idr__IderSessionLogEntryType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new idr__IderSessionLogEntryType[n]; + if (size) + *size = n * sizeof(idr__IderSessionLogEntryType); + for (int i = 0; i < n; i++) + ((idr__IderSessionLogEntryType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (idr__IderSessionLogEntryType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_idr__IderSessionLogEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying idr__IderSessionLogEntryType %p -> %p\n", q, p)); + *(idr__IderSessionLogEntryType*)p = *(idr__IderSessionLogEntryType*)q; +} + +void _apl__AgentWatchdogShutdownResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _apl__AgentWatchdogShutdownResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apl__PT_USCORESTATUS(soap, &((_apl__AgentWatchdogShutdownResponse*)this)->Status); + /* transient soap skipped */ +} + +int _apl__AgentWatchdogShutdownResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apl__AgentWatchdogShutdownResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apl__AgentWatchdogShutdownResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apl__AgentWatchdogShutdownResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogShutdownResponse(struct soap *soap, const char *tag, int id, const _apl__AgentWatchdogShutdownResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apl__AgentWatchdogShutdownResponse), type); + soap_element_result(soap, "apl:Status"); + soap_out_apl__PT_USCORESTATUS(soap, "apl:Status", -1, &(((_apl__AgentWatchdogShutdownResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apl__AgentWatchdogShutdownResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apl__AgentWatchdogShutdownResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse * SOAP_FMAC4 soap_get__apl__AgentWatchdogShutdownResponse(struct soap *soap, _apl__AgentWatchdogShutdownResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apl__AgentWatchdogShutdownResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apl__AgentWatchdogShutdownResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apl__AgentWatchdogShutdownResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse * SOAP_FMAC4 soap_in__apl__AgentWatchdogShutdownResponse(struct soap *soap, const char *tag, _apl__AgentWatchdogShutdownResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apl__AgentWatchdogShutdownResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apl__AgentWatchdogShutdownResponse, sizeof(_apl__AgentWatchdogShutdownResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apl__AgentWatchdogShutdownResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apl__AgentWatchdogShutdownResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apl__PT_USCORESTATUS(soap, "apl:Status", &(((_apl__AgentWatchdogShutdownResponse*)a)->Status), "apl:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "apl:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apl__AgentWatchdogShutdownResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apl__AgentWatchdogShutdownResponse, 0, sizeof(_apl__AgentWatchdogShutdownResponse), 0, soap_copy__apl__AgentWatchdogShutdownResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apl__AgentWatchdogShutdownResponse * SOAP_FMAC6 soap_new__apl__AgentWatchdogShutdownResponse(struct soap *soap, int n) +{ return soap_instantiate__apl__AgentWatchdogShutdownResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogShutdownResponse(struct soap *soap, _apl__AgentWatchdogShutdownResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogShutdownResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apl__AgentWatchdogShutdownResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apl__AgentWatchdogShutdownResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apl__AgentWatchdogShutdownResponse; + if (size) + *size = sizeof(_apl__AgentWatchdogShutdownResponse); + ((_apl__AgentWatchdogShutdownResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apl__AgentWatchdogShutdownResponse[n]; + if (size) + *size = n * sizeof(_apl__AgentWatchdogShutdownResponse); + for (int i = 0; i < n; i++) + ((_apl__AgentWatchdogShutdownResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apl__AgentWatchdogShutdownResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogShutdownResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apl__AgentWatchdogShutdownResponse %p -> %p\n", q, p)); + *(_apl__AgentWatchdogShutdownResponse*)p = *(_apl__AgentWatchdogShutdownResponse*)q; +} + +void _apl__AgentWatchdogShutdown::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToapl__GUID(soap, &((_apl__AgentWatchdogShutdown*)this)->AgentID); + soap_embedded(soap, &((_apl__AgentWatchdogShutdown*)this)->SessionSequenceNumber, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _apl__AgentWatchdogShutdown::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_apl__AgentWatchdogShutdown*)this)->AgentID = NULL; + soap_default_unsignedInt(soap, &((_apl__AgentWatchdogShutdown*)this)->SessionSequenceNumber); + /* transient soap skipped */ +} + +int _apl__AgentWatchdogShutdown::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apl__AgentWatchdogShutdown); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apl__AgentWatchdogShutdown::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apl__AgentWatchdogShutdown(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogShutdown(struct soap *soap, const char *tag, int id, const _apl__AgentWatchdogShutdown *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apl__AgentWatchdogShutdown), type); + soap_out_PointerToapl__GUID(soap, "apl:AgentID", -1, &(((_apl__AgentWatchdogShutdown*)a)->AgentID), ""); + soap_out_unsignedInt(soap, "apl:SessionSequenceNumber", -1, &(((_apl__AgentWatchdogShutdown*)a)->SessionSequenceNumber), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apl__AgentWatchdogShutdown::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apl__AgentWatchdogShutdown(soap, this, tag, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_get__apl__AgentWatchdogShutdown(struct soap *soap, _apl__AgentWatchdogShutdown *p, const char *tag, const char *type) +{ + if ((p = soap_in__apl__AgentWatchdogShutdown(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apl__AgentWatchdogShutdown::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apl__AgentWatchdogShutdown(soap, tag, this, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_in__apl__AgentWatchdogShutdown(struct soap *soap, const char *tag, _apl__AgentWatchdogShutdown *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apl__AgentWatchdogShutdown *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apl__AgentWatchdogShutdown, sizeof(_apl__AgentWatchdogShutdown), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apl__AgentWatchdogShutdown) + { soap_revert(soap); + *soap->id = '\0'; + return (_apl__AgentWatchdogShutdown *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AgentID1 = 1, soap_flag_SessionSequenceNumber1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AgentID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapl__GUID(soap, "apl:AgentID", &(((_apl__AgentWatchdogShutdown*)a)->AgentID), "apl:GUID")) + { soap_flag_AgentID1--; + continue; + } + if (soap_flag_SessionSequenceNumber1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "apl:SessionSequenceNumber", &(((_apl__AgentWatchdogShutdown*)a)->SessionSequenceNumber), "xsd:unsignedInt")) + { soap_flag_SessionSequenceNumber1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AgentID1 > 0 || soap_flag_SessionSequenceNumber1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apl__AgentWatchdogShutdown *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apl__AgentWatchdogShutdown, 0, sizeof(_apl__AgentWatchdogShutdown), 0, soap_copy__apl__AgentWatchdogShutdown); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apl__AgentWatchdogShutdown * SOAP_FMAC6 soap_new__apl__AgentWatchdogShutdown(struct soap *soap, int n) +{ return soap_instantiate__apl__AgentWatchdogShutdown(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogShutdown(struct soap *soap, _apl__AgentWatchdogShutdown *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogShutdown(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apl__AgentWatchdogShutdown(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apl__AgentWatchdogShutdown, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apl__AgentWatchdogShutdown; + if (size) + *size = sizeof(_apl__AgentWatchdogShutdown); + ((_apl__AgentWatchdogShutdown*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apl__AgentWatchdogShutdown[n]; + if (size) + *size = n * sizeof(_apl__AgentWatchdogShutdown); + for (int i = 0; i < n; i++) + ((_apl__AgentWatchdogShutdown*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apl__AgentWatchdogShutdown*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogShutdown(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apl__AgentWatchdogShutdown %p -> %p\n", q, p)); + *(_apl__AgentWatchdogShutdown*)p = *(_apl__AgentWatchdogShutdown*)q; +} + +void _apl__AgentWatchdogHeartbeatResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _apl__AgentWatchdogHeartbeatResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apl__PT_USCORESTATUS(soap, &((_apl__AgentWatchdogHeartbeatResponse*)this)->Status); + /* transient soap skipped */ +} + +int _apl__AgentWatchdogHeartbeatResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apl__AgentWatchdogHeartbeatResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apl__AgentWatchdogHeartbeatResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogHeartbeatResponse(struct soap *soap, const char *tag, int id, const _apl__AgentWatchdogHeartbeatResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse), type); + soap_element_result(soap, "apl:Status"); + soap_out_apl__PT_USCORESTATUS(soap, "apl:Status", -1, &(((_apl__AgentWatchdogHeartbeatResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apl__AgentWatchdogHeartbeatResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apl__AgentWatchdogHeartbeatResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse * SOAP_FMAC4 soap_get__apl__AgentWatchdogHeartbeatResponse(struct soap *soap, _apl__AgentWatchdogHeartbeatResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apl__AgentWatchdogHeartbeatResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apl__AgentWatchdogHeartbeatResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apl__AgentWatchdogHeartbeatResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse * SOAP_FMAC4 soap_in__apl__AgentWatchdogHeartbeatResponse(struct soap *soap, const char *tag, _apl__AgentWatchdogHeartbeatResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apl__AgentWatchdogHeartbeatResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse, sizeof(_apl__AgentWatchdogHeartbeatResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apl__AgentWatchdogHeartbeatResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apl__PT_USCORESTATUS(soap, "apl:Status", &(((_apl__AgentWatchdogHeartbeatResponse*)a)->Status), "apl:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "apl:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apl__AgentWatchdogHeartbeatResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse, 0, sizeof(_apl__AgentWatchdogHeartbeatResponse), 0, soap_copy__apl__AgentWatchdogHeartbeatResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apl__AgentWatchdogHeartbeatResponse * SOAP_FMAC6 soap_new__apl__AgentWatchdogHeartbeatResponse(struct soap *soap, int n) +{ return soap_instantiate__apl__AgentWatchdogHeartbeatResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogHeartbeatResponse(struct soap *soap, _apl__AgentWatchdogHeartbeatResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogHeartbeatResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apl__AgentWatchdogHeartbeatResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apl__AgentWatchdogHeartbeatResponse; + if (size) + *size = sizeof(_apl__AgentWatchdogHeartbeatResponse); + ((_apl__AgentWatchdogHeartbeatResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apl__AgentWatchdogHeartbeatResponse[n]; + if (size) + *size = n * sizeof(_apl__AgentWatchdogHeartbeatResponse); + for (int i = 0; i < n; i++) + ((_apl__AgentWatchdogHeartbeatResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apl__AgentWatchdogHeartbeatResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogHeartbeatResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apl__AgentWatchdogHeartbeatResponse %p -> %p\n", q, p)); + *(_apl__AgentWatchdogHeartbeatResponse*)p = *(_apl__AgentWatchdogHeartbeatResponse*)q; +} + +void _apl__AgentWatchdogHeartbeat::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToapl__GUID(soap, &((_apl__AgentWatchdogHeartbeat*)this)->AgentID); + soap_embedded(soap, &((_apl__AgentWatchdogHeartbeat*)this)->SessionSequenceNumber, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _apl__AgentWatchdogHeartbeat::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_apl__AgentWatchdogHeartbeat*)this)->AgentID = NULL; + soap_default_unsignedInt(soap, &((_apl__AgentWatchdogHeartbeat*)this)->SessionSequenceNumber); + /* transient soap skipped */ +} + +int _apl__AgentWatchdogHeartbeat::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apl__AgentWatchdogHeartbeat); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apl__AgentWatchdogHeartbeat::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apl__AgentWatchdogHeartbeat(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogHeartbeat(struct soap *soap, const char *tag, int id, const _apl__AgentWatchdogHeartbeat *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apl__AgentWatchdogHeartbeat), type); + soap_out_PointerToapl__GUID(soap, "apl:AgentID", -1, &(((_apl__AgentWatchdogHeartbeat*)a)->AgentID), ""); + soap_out_unsignedInt(soap, "apl:SessionSequenceNumber", -1, &(((_apl__AgentWatchdogHeartbeat*)a)->SessionSequenceNumber), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apl__AgentWatchdogHeartbeat::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apl__AgentWatchdogHeartbeat(soap, this, tag, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_get__apl__AgentWatchdogHeartbeat(struct soap *soap, _apl__AgentWatchdogHeartbeat *p, const char *tag, const char *type) +{ + if ((p = soap_in__apl__AgentWatchdogHeartbeat(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apl__AgentWatchdogHeartbeat::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apl__AgentWatchdogHeartbeat(soap, tag, this, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_in__apl__AgentWatchdogHeartbeat(struct soap *soap, const char *tag, _apl__AgentWatchdogHeartbeat *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apl__AgentWatchdogHeartbeat *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apl__AgentWatchdogHeartbeat, sizeof(_apl__AgentWatchdogHeartbeat), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apl__AgentWatchdogHeartbeat) + { soap_revert(soap); + *soap->id = '\0'; + return (_apl__AgentWatchdogHeartbeat *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AgentID1 = 1, soap_flag_SessionSequenceNumber1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AgentID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapl__GUID(soap, "apl:AgentID", &(((_apl__AgentWatchdogHeartbeat*)a)->AgentID), "apl:GUID")) + { soap_flag_AgentID1--; + continue; + } + if (soap_flag_SessionSequenceNumber1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "apl:SessionSequenceNumber", &(((_apl__AgentWatchdogHeartbeat*)a)->SessionSequenceNumber), "xsd:unsignedInt")) + { soap_flag_SessionSequenceNumber1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AgentID1 > 0 || soap_flag_SessionSequenceNumber1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apl__AgentWatchdogHeartbeat *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apl__AgentWatchdogHeartbeat, 0, sizeof(_apl__AgentWatchdogHeartbeat), 0, soap_copy__apl__AgentWatchdogHeartbeat); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apl__AgentWatchdogHeartbeat * SOAP_FMAC6 soap_new__apl__AgentWatchdogHeartbeat(struct soap *soap, int n) +{ return soap_instantiate__apl__AgentWatchdogHeartbeat(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogHeartbeat(struct soap *soap, _apl__AgentWatchdogHeartbeat *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogHeartbeat(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apl__AgentWatchdogHeartbeat(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apl__AgentWatchdogHeartbeat, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apl__AgentWatchdogHeartbeat; + if (size) + *size = sizeof(_apl__AgentWatchdogHeartbeat); + ((_apl__AgentWatchdogHeartbeat*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apl__AgentWatchdogHeartbeat[n]; + if (size) + *size = n * sizeof(_apl__AgentWatchdogHeartbeat); + for (int i = 0; i < n; i++) + ((_apl__AgentWatchdogHeartbeat*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apl__AgentWatchdogHeartbeat*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogHeartbeat(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apl__AgentWatchdogHeartbeat %p -> %p\n", q, p)); + *(_apl__AgentWatchdogHeartbeat*)p = *(_apl__AgentWatchdogHeartbeat*)q; +} + +void _apl__AgentWatchdogRegisterResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_apl__AgentWatchdogRegisterResponse*)this)->SessionSequenceNumber, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_apl__AgentWatchdogRegisterResponse*)this)->AgentHeartbeatTime, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void _apl__AgentWatchdogRegisterResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apl__PT_USCORESTATUS(soap, &((_apl__AgentWatchdogRegisterResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_apl__AgentWatchdogRegisterResponse*)this)->SessionSequenceNumber); + soap_default_unsignedShort(soap, &((_apl__AgentWatchdogRegisterResponse*)this)->AgentHeartbeatTime); + /* transient soap skipped */ +} + +int _apl__AgentWatchdogRegisterResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apl__AgentWatchdogRegisterResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apl__AgentWatchdogRegisterResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apl__AgentWatchdogRegisterResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogRegisterResponse(struct soap *soap, const char *tag, int id, const _apl__AgentWatchdogRegisterResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apl__AgentWatchdogRegisterResponse), type); + soap_element_result(soap, "apl:Status"); + soap_out_apl__PT_USCORESTATUS(soap, "apl:Status", -1, &(((_apl__AgentWatchdogRegisterResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "apl:SessionSequenceNumber", -1, &(((_apl__AgentWatchdogRegisterResponse*)a)->SessionSequenceNumber), ""); + soap_out_unsignedShort(soap, "apl:AgentHeartbeatTime", -1, &(((_apl__AgentWatchdogRegisterResponse*)a)->AgentHeartbeatTime), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apl__AgentWatchdogRegisterResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apl__AgentWatchdogRegisterResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse * SOAP_FMAC4 soap_get__apl__AgentWatchdogRegisterResponse(struct soap *soap, _apl__AgentWatchdogRegisterResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apl__AgentWatchdogRegisterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apl__AgentWatchdogRegisterResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apl__AgentWatchdogRegisterResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse * SOAP_FMAC4 soap_in__apl__AgentWatchdogRegisterResponse(struct soap *soap, const char *tag, _apl__AgentWatchdogRegisterResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apl__AgentWatchdogRegisterResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apl__AgentWatchdogRegisterResponse, sizeof(_apl__AgentWatchdogRegisterResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apl__AgentWatchdogRegisterResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apl__AgentWatchdogRegisterResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_SessionSequenceNumber1 = 1, soap_flag_AgentHeartbeatTime1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apl__PT_USCORESTATUS(soap, "apl:Status", &(((_apl__AgentWatchdogRegisterResponse*)a)->Status), "apl:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_SessionSequenceNumber1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "apl:SessionSequenceNumber", &(((_apl__AgentWatchdogRegisterResponse*)a)->SessionSequenceNumber), "xsd:unsignedInt")) + { soap_flag_SessionSequenceNumber1--; + continue; + } + if (soap_flag_AgentHeartbeatTime1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "apl:AgentHeartbeatTime", &(((_apl__AgentWatchdogRegisterResponse*)a)->AgentHeartbeatTime), "xsd:unsignedShort")) + { soap_flag_AgentHeartbeatTime1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "apl:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_SessionSequenceNumber1 > 0 || soap_flag_AgentHeartbeatTime1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apl__AgentWatchdogRegisterResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apl__AgentWatchdogRegisterResponse, 0, sizeof(_apl__AgentWatchdogRegisterResponse), 0, soap_copy__apl__AgentWatchdogRegisterResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apl__AgentWatchdogRegisterResponse * SOAP_FMAC6 soap_new__apl__AgentWatchdogRegisterResponse(struct soap *soap, int n) +{ return soap_instantiate__apl__AgentWatchdogRegisterResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogRegisterResponse(struct soap *soap, _apl__AgentWatchdogRegisterResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogRegisterResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apl__AgentWatchdogRegisterResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apl__AgentWatchdogRegisterResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apl__AgentWatchdogRegisterResponse; + if (size) + *size = sizeof(_apl__AgentWatchdogRegisterResponse); + ((_apl__AgentWatchdogRegisterResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apl__AgentWatchdogRegisterResponse[n]; + if (size) + *size = n * sizeof(_apl__AgentWatchdogRegisterResponse); + for (int i = 0; i < n; i++) + ((_apl__AgentWatchdogRegisterResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apl__AgentWatchdogRegisterResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogRegisterResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apl__AgentWatchdogRegisterResponse %p -> %p\n", q, p)); + *(_apl__AgentWatchdogRegisterResponse*)p = *(_apl__AgentWatchdogRegisterResponse*)q; +} + +void _apl__AgentWatchdogRegister::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToapl__GUID(soap, &((_apl__AgentWatchdogRegister*)this)->AgentID); + /* transient soap skipped */ +} + +void _apl__AgentWatchdogRegister::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_apl__AgentWatchdogRegister*)this)->AgentID = NULL; + /* transient soap skipped */ +} + +int _apl__AgentWatchdogRegister::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apl__AgentWatchdogRegister); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apl__AgentWatchdogRegister::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apl__AgentWatchdogRegister(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apl__AgentWatchdogRegister(struct soap *soap, const char *tag, int id, const _apl__AgentWatchdogRegister *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apl__AgentWatchdogRegister), type); + soap_out_PointerToapl__GUID(soap, "apl:AgentID", -1, &(((_apl__AgentWatchdogRegister*)a)->AgentID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apl__AgentWatchdogRegister::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apl__AgentWatchdogRegister(soap, this, tag, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogRegister * SOAP_FMAC4 soap_get__apl__AgentWatchdogRegister(struct soap *soap, _apl__AgentWatchdogRegister *p, const char *tag, const char *type) +{ + if ((p = soap_in__apl__AgentWatchdogRegister(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apl__AgentWatchdogRegister::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apl__AgentWatchdogRegister(soap, tag, this, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogRegister * SOAP_FMAC4 soap_in__apl__AgentWatchdogRegister(struct soap *soap, const char *tag, _apl__AgentWatchdogRegister *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apl__AgentWatchdogRegister *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apl__AgentWatchdogRegister, sizeof(_apl__AgentWatchdogRegister), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apl__AgentWatchdogRegister) + { soap_revert(soap); + *soap->id = '\0'; + return (_apl__AgentWatchdogRegister *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AgentID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AgentID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapl__GUID(soap, "apl:AgentID", &(((_apl__AgentWatchdogRegister*)a)->AgentID), "apl:GUID")) + { soap_flag_AgentID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AgentID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apl__AgentWatchdogRegister *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apl__AgentWatchdogRegister, 0, sizeof(_apl__AgentWatchdogRegister), 0, soap_copy__apl__AgentWatchdogRegister); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apl__AgentWatchdogRegister * SOAP_FMAC6 soap_new__apl__AgentWatchdogRegister(struct soap *soap, int n) +{ return soap_instantiate__apl__AgentWatchdogRegister(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apl__AgentWatchdogRegister(struct soap *soap, _apl__AgentWatchdogRegister *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apl__AgentWatchdogRegister * SOAP_FMAC4 soap_instantiate__apl__AgentWatchdogRegister(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apl__AgentWatchdogRegister(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apl__AgentWatchdogRegister, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apl__AgentWatchdogRegister; + if (size) + *size = sizeof(_apl__AgentWatchdogRegister); + ((_apl__AgentWatchdogRegister*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apl__AgentWatchdogRegister[n]; + if (size) + *size = n * sizeof(_apl__AgentWatchdogRegister); + for (int i = 0; i < n; i++) + ((_apl__AgentWatchdogRegister*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apl__AgentWatchdogRegister*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apl__AgentWatchdogRegister(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apl__AgentWatchdogRegister %p -> %p\n", q, p)); + *(_apl__AgentWatchdogRegister*)p = *(_apl__AgentWatchdogRegister*)q; +} + +void apl__GUID::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((apl__GUID*)this)->Byte); + /* transient soap skipped */ +} + +void apl__GUID::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfunsignedByte(soap, &((apl__GUID*)this)->Byte); + /* transient soap skipped */ +} + +int apl__GUID::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_apl__GUID); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int apl__GUID::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_apl__GUID(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apl__GUID(struct soap *soap, const char *tag, int id, const apl__GUID *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_apl__GUID), type); + soap_out_std__vectorTemplateOfunsignedByte(soap, "apl:Byte", -1, &(((apl__GUID*)a)->Byte), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *apl__GUID::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_apl__GUID(soap, this, tag, type); +} + +SOAP_FMAC3 apl__GUID * SOAP_FMAC4 soap_get_apl__GUID(struct soap *soap, apl__GUID *p, const char *tag, const char *type) +{ + if ((p = soap_in_apl__GUID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *apl__GUID::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_apl__GUID(soap, tag, this, type); +} + +SOAP_FMAC3 apl__GUID * SOAP_FMAC4 soap_in_apl__GUID(struct soap *soap, const char *tag, apl__GUID *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (apl__GUID *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_apl__GUID, sizeof(apl__GUID), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_apl__GUID) + { soap_revert(soap); + *soap->id = '\0'; + return (apl__GUID *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "apl:Byte", &(((apl__GUID*)a)->Byte), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((apl__GUID*)a)->Byte.size() < 16 || ((apl__GUID*)a)->Byte.size() > 16)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (apl__GUID *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_apl__GUID, 0, sizeof(apl__GUID), 0, soap_copy_apl__GUID); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 apl__GUID * SOAP_FMAC6 soap_new_apl__GUID(struct soap *soap, int n) +{ return soap_instantiate_apl__GUID(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apl__GUID(struct soap *soap, apl__GUID *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 apl__GUID * SOAP_FMAC4 soap_instantiate_apl__GUID(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_apl__GUID(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_apl__GUID, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new apl__GUID; + if (size) + *size = sizeof(apl__GUID); + ((apl__GUID*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new apl__GUID[n]; + if (size) + *size = n * sizeof(apl__GUID); + for (int i = 0; i < n; i++) + ((apl__GUID*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (apl__GUID*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apl__GUID(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying apl__GUID %p -> %p\n", q, p)); + *(apl__GUID*)p = *(apl__GUID*)q; +} + +void _apr__ConsoleWatchdogQueryCapabilitiesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToapr__AgentPresenceCapabilitiesType(soap, &((_apr__ConsoleWatchdogQueryCapabilitiesResponse*)this)->Capabilities); + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogQueryCapabilitiesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apr__PT_USCORESTATUS(soap, &((_apr__ConsoleWatchdogQueryCapabilitiesResponse*)this)->Status); + ((_apr__ConsoleWatchdogQueryCapabilitiesResponse*)this)->Capabilities = NULL; + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogQueryCapabilitiesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogQueryCapabilitiesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogQueryCapabilitiesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse), type); + soap_element_result(soap, "apr:Status"); + soap_out_apr__PT_USCORESTATUS(soap, "apr:Status", -1, &(((_apr__ConsoleWatchdogQueryCapabilitiesResponse*)a)->Status), ""); + soap_out_PointerToapr__AgentPresenceCapabilitiesType(soap, "apr:Capabilities", -1, &(((_apr__ConsoleWatchdogQueryCapabilitiesResponse*)a)->Capabilities), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogQueryCapabilitiesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilitiesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogQueryCapabilitiesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogQueryCapabilitiesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogQueryCapabilitiesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse, sizeof(_apr__ConsoleWatchdogQueryCapabilitiesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogQueryCapabilitiesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Capabilities1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__PT_USCORESTATUS(soap, "apr:Status", &(((_apr__ConsoleWatchdogQueryCapabilitiesResponse*)a)->Status), "apr:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Capabilities1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapr__AgentPresenceCapabilitiesType(soap, "apr:Capabilities", &(((_apr__ConsoleWatchdogQueryCapabilitiesResponse*)a)->Capabilities), "apr:AgentPresenceCapabilitiesType")) + { soap_flag_Capabilities1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "apr:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Capabilities1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogQueryCapabilitiesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse, 0, sizeof(_apr__ConsoleWatchdogQueryCapabilitiesResponse), 0, soap_copy__apr__ConsoleWatchdogQueryCapabilitiesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogQueryCapabilitiesResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilitiesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogQueryCapabilitiesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogQueryCapabilitiesResponse; + if (size) + *size = sizeof(_apr__ConsoleWatchdogQueryCapabilitiesResponse); + ((_apr__ConsoleWatchdogQueryCapabilitiesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogQueryCapabilitiesResponse[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogQueryCapabilitiesResponse); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogQueryCapabilitiesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogQueryCapabilitiesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogQueryCapabilitiesResponse %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogQueryCapabilitiesResponse*)p = *(_apr__ConsoleWatchdogQueryCapabilitiesResponse*)q; +} + +void _apr__ConsoleWatchdogQueryCapabilities::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogQueryCapabilities::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogQueryCapabilities::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogQueryCapabilities::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogQueryCapabilities(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogQueryCapabilities *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogQueryCapabilities::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogQueryCapabilities(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilities *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogQueryCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogQueryCapabilities::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogQueryCapabilities(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const char *tag, _apr__ConsoleWatchdogQueryCapabilities *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogQueryCapabilities *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities, sizeof(_apr__ConsoleWatchdogQueryCapabilities), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogQueryCapabilities *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogQueryCapabilities *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities, 0, sizeof(_apr__ConsoleWatchdogQueryCapabilities), 0, soap_copy__apr__ConsoleWatchdogQueryCapabilities); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogQueryCapabilities(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilities *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogQueryCapabilities(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogQueryCapabilities; + if (size) + *size = sizeof(_apr__ConsoleWatchdogQueryCapabilities); + ((_apr__ConsoleWatchdogQueryCapabilities*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogQueryCapabilities[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogQueryCapabilities); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogQueryCapabilities*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogQueryCapabilities*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogQueryCapabilities %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogQueryCapabilities*)p = *(_apr__ConsoleWatchdogQueryCapabilities*)q; +} + +void _apr__ConsoleWatchdogGetCbPolicyResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, &((_apr__ConsoleWatchdogGetCbPolicyResponse*)this)->HwPolicies); + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogGetCbPolicyResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apr__PT_USCORESTATUS(soap, &((_apr__ConsoleWatchdogGetCbPolicyResponse*)this)->Status); + soap_default_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, &((_apr__ConsoleWatchdogGetCbPolicyResponse*)this)->HwPolicies); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogGetCbPolicyResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogGetCbPolicyResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogGetCbPolicyResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogGetCbPolicyResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse), type); + soap_element_result(soap, "apr:Status"); + soap_out_apr__PT_USCORESTATUS(soap, "apr:Status", -1, &(((_apr__ConsoleWatchdogGetCbPolicyResponse*)a)->Status), ""); + soap_out_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, "apr:HwPolicies", -1, &(((_apr__ConsoleWatchdogGetCbPolicyResponse*)a)->HwPolicies), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogGetCbPolicyResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogGetCbPolicyResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicyResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogGetCbPolicyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogGetCbPolicyResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogGetCbPolicyResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogGetCbPolicyResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogGetCbPolicyResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse, sizeof(_apr__ConsoleWatchdogGetCbPolicyResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogGetCbPolicyResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__PT_USCORESTATUS(soap, "apr:Status", &(((_apr__ConsoleWatchdogGetCbPolicyResponse*)a)->Status), "apr:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, "apr:HwPolicies", &(((_apr__ConsoleWatchdogGetCbPolicyResponse*)a)->HwPolicies), "apr:CircuitBreakerHardwarePolicyType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "apr:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogGetCbPolicyResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse, 0, sizeof(_apr__ConsoleWatchdogGetCbPolicyResponse), 0, soap_copy__apr__ConsoleWatchdogGetCbPolicyResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogGetCbPolicyResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogGetCbPolicyResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicyResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogGetCbPolicyResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogGetCbPolicyResponse; + if (size) + *size = sizeof(_apr__ConsoleWatchdogGetCbPolicyResponse); + ((_apr__ConsoleWatchdogGetCbPolicyResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogGetCbPolicyResponse[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogGetCbPolicyResponse); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogGetCbPolicyResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogGetCbPolicyResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogGetCbPolicyResponse %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogGetCbPolicyResponse*)p = *(_apr__ConsoleWatchdogGetCbPolicyResponse*)q; +} + +void _apr__ConsoleWatchdogGetCbPolicy::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogGetCbPolicy::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogGetCbPolicy::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogGetCbPolicy::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogGetCbPolicy(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogGetCbPolicy *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogGetCbPolicy::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogGetCbPolicy(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicy *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogGetCbPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogGetCbPolicy::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogGetCbPolicy(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const char *tag, _apr__ConsoleWatchdogGetCbPolicy *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogGetCbPolicy *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy, sizeof(_apr__ConsoleWatchdogGetCbPolicy), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogGetCbPolicy *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogGetCbPolicy *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy, 0, sizeof(_apr__ConsoleWatchdogGetCbPolicy), 0, soap_copy__apr__ConsoleWatchdogGetCbPolicy); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogGetCbPolicy(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicy *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogGetCbPolicy(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogGetCbPolicy; + if (size) + *size = sizeof(_apr__ConsoleWatchdogGetCbPolicy); + ((_apr__ConsoleWatchdogGetCbPolicy*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogGetCbPolicy[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogGetCbPolicy); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogGetCbPolicy*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogGetCbPolicy*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogGetCbPolicy %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogGetCbPolicy*)p = *(_apr__ConsoleWatchdogGetCbPolicy*)q; +} + +void _apr__ConsoleWatchdogSetCbPolicyResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogSetCbPolicyResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apr__PT_USCORESTATUS(soap, &((_apr__ConsoleWatchdogSetCbPolicyResponse*)this)->Status); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogSetCbPolicyResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogSetCbPolicyResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogSetCbPolicyResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogSetCbPolicyResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse), type); + soap_element_result(soap, "apr:Status"); + soap_out_apr__PT_USCORESTATUS(soap, "apr:Status", -1, &(((_apr__ConsoleWatchdogSetCbPolicyResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogSetCbPolicyResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogSetCbPolicyResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicyResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogSetCbPolicyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogSetCbPolicyResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogSetCbPolicyResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogSetCbPolicyResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogSetCbPolicyResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse, sizeof(_apr__ConsoleWatchdogSetCbPolicyResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogSetCbPolicyResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__PT_USCORESTATUS(soap, "apr:Status", &(((_apr__ConsoleWatchdogSetCbPolicyResponse*)a)->Status), "apr:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "apr:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogSetCbPolicyResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse, 0, sizeof(_apr__ConsoleWatchdogSetCbPolicyResponse), 0, soap_copy__apr__ConsoleWatchdogSetCbPolicyResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogSetCbPolicyResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogSetCbPolicyResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicyResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogSetCbPolicyResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogSetCbPolicyResponse; + if (size) + *size = sizeof(_apr__ConsoleWatchdogSetCbPolicyResponse); + ((_apr__ConsoleWatchdogSetCbPolicyResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogSetCbPolicyResponse[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogSetCbPolicyResponse); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogSetCbPolicyResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogSetCbPolicyResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogSetCbPolicyResponse %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogSetCbPolicyResponse*)p = *(_apr__ConsoleWatchdogSetCbPolicyResponse*)q; +} + +void _apr__ConsoleWatchdogSetCbPolicy::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, &((_apr__ConsoleWatchdogSetCbPolicy*)this)->HwPolicies); + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogSetCbPolicy::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, &((_apr__ConsoleWatchdogSetCbPolicy*)this)->HwPolicies); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogSetCbPolicy::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogSetCbPolicy::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogSetCbPolicy(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogSetCbPolicy *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy), type); + soap_out_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, "apr:HwPolicies", -1, &(((_apr__ConsoleWatchdogSetCbPolicy*)a)->HwPolicies), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogSetCbPolicy::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogSetCbPolicy(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicy *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogSetCbPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogSetCbPolicy::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogSetCbPolicy(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const char *tag, _apr__ConsoleWatchdogSetCbPolicy *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogSetCbPolicy *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy, sizeof(_apr__ConsoleWatchdogSetCbPolicy), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogSetCbPolicy *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, "apr:HwPolicies", &(((_apr__ConsoleWatchdogSetCbPolicy*)a)->HwPolicies), "apr:CircuitBreakerHardwarePolicyType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogSetCbPolicy *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy, 0, sizeof(_apr__ConsoleWatchdogSetCbPolicy), 0, soap_copy__apr__ConsoleWatchdogSetCbPolicy); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogSetCbPolicy(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicy *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogSetCbPolicy(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogSetCbPolicy; + if (size) + *size = sizeof(_apr__ConsoleWatchdogSetCbPolicy); + ((_apr__ConsoleWatchdogSetCbPolicy*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogSetCbPolicy[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogSetCbPolicy); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogSetCbPolicy*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogSetCbPolicy*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogSetCbPolicy %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogSetCbPolicy*)p = *(_apr__ConsoleWatchdogSetCbPolicy*)q; +} + +void _apr__ConsoleWatchdogGetActionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, &((_apr__ConsoleWatchdogGetActionsResponse*)this)->ConsoleWatchdogActions); + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogGetActionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apr__PT_USCORESTATUS(soap, &((_apr__ConsoleWatchdogGetActionsResponse*)this)->Status); + soap_default_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, &((_apr__ConsoleWatchdogGetActionsResponse*)this)->ConsoleWatchdogActions); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogGetActionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogGetActionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogGetActionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogGetActionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse), type); + soap_element_result(soap, "apr:Status"); + soap_out_apr__PT_USCORESTATUS(soap, "apr:Status", -1, &(((_apr__ConsoleWatchdogGetActionsResponse*)a)->Status), ""); + soap_out_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, "apr:ConsoleWatchdogActions", -1, &(((_apr__ConsoleWatchdogGetActionsResponse*)a)->ConsoleWatchdogActions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogGetActionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogGetActionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogGetActionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogGetActionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogGetActionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogGetActionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogGetActionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogGetActionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse, sizeof(_apr__ConsoleWatchdogGetActionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogGetActionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__PT_USCORESTATUS(soap, "apr:Status", &(((_apr__ConsoleWatchdogGetActionsResponse*)a)->Status), "apr:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, "apr:ConsoleWatchdogActions", &(((_apr__ConsoleWatchdogGetActionsResponse*)a)->ConsoleWatchdogActions), "apr:ConsoleWatchdogActionType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "apr:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogGetActionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse, 0, sizeof(_apr__ConsoleWatchdogGetActionsResponse), 0, soap_copy__apr__ConsoleWatchdogGetActionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogGetActionsResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogGetActionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogGetActionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogGetActionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogGetActionsResponse; + if (size) + *size = sizeof(_apr__ConsoleWatchdogGetActionsResponse); + ((_apr__ConsoleWatchdogGetActionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogGetActionsResponse[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogGetActionsResponse); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogGetActionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogGetActionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogGetActionsResponse %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogGetActionsResponse*)p = *(_apr__ConsoleWatchdogGetActionsResponse*)q; +} + +void _apr__ConsoleWatchdogGetActions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToapr__GUID(soap, &((_apr__ConsoleWatchdogGetActions*)this)->AgentID); + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogGetActions::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_apr__ConsoleWatchdogGetActions*)this)->AgentID = NULL; + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogGetActions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogGetActions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogGetActions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogGetActions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogGetActions(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogGetActions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogGetActions), type); + soap_out_PointerToapr__GUID(soap, "apr:AgentID", -1, &(((_apr__ConsoleWatchdogGetActions*)a)->AgentID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogGetActions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogGetActions(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogGetActions(struct soap *soap, _apr__ConsoleWatchdogGetActions *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogGetActions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogGetActions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogGetActions(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogGetActions(struct soap *soap, const char *tag, _apr__ConsoleWatchdogGetActions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogGetActions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogGetActions, sizeof(_apr__ConsoleWatchdogGetActions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogGetActions) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogGetActions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AgentID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AgentID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapr__GUID(soap, "apr:AgentID", &(((_apr__ConsoleWatchdogGetActions*)a)->AgentID), "apr:GUID")) + { soap_flag_AgentID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AgentID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogGetActions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogGetActions, 0, sizeof(_apr__ConsoleWatchdogGetActions), 0, soap_copy__apr__ConsoleWatchdogGetActions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogGetActions * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogGetActions(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogGetActions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogGetActions(struct soap *soap, _apr__ConsoleWatchdogGetActions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogGetActions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogGetActions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogGetActions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogGetActions; + if (size) + *size = sizeof(_apr__ConsoleWatchdogGetActions); + ((_apr__ConsoleWatchdogGetActions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogGetActions[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogGetActions); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogGetActions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogGetActions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogGetActions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogGetActions %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogGetActions*)p = *(_apr__ConsoleWatchdogGetActions*)q; +} + +void _apr__ConsoleWatchdogSetActionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogSetActionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apr__PT_USCORESTATUS(soap, &((_apr__ConsoleWatchdogSetActionsResponse*)this)->Status); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogSetActionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogSetActionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogSetActionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogSetActionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse), type); + soap_element_result(soap, "apr:Status"); + soap_out_apr__PT_USCORESTATUS(soap, "apr:Status", -1, &(((_apr__ConsoleWatchdogSetActionsResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogSetActionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogSetActionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogSetActionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogSetActionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogSetActionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogSetActionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogSetActionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogSetActionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse, sizeof(_apr__ConsoleWatchdogSetActionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogSetActionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__PT_USCORESTATUS(soap, "apr:Status", &(((_apr__ConsoleWatchdogSetActionsResponse*)a)->Status), "apr:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "apr:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogSetActionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse, 0, sizeof(_apr__ConsoleWatchdogSetActionsResponse), 0, soap_copy__apr__ConsoleWatchdogSetActionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogSetActionsResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogSetActionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogSetActionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogSetActionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogSetActionsResponse; + if (size) + *size = sizeof(_apr__ConsoleWatchdogSetActionsResponse); + ((_apr__ConsoleWatchdogSetActionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogSetActionsResponse[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogSetActionsResponse); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogSetActionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogSetActionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogSetActionsResponse %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogSetActionsResponse*)p = *(_apr__ConsoleWatchdogSetActionsResponse*)q; +} + +void _apr__ConsoleWatchdogSetActions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToapr__GUID(soap, &((_apr__ConsoleWatchdogSetActions*)this)->AgentID); + soap_serialize_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, &((_apr__ConsoleWatchdogSetActions*)this)->ConsoleWatchdogActions); + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogSetActions::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_apr__ConsoleWatchdogSetActions*)this)->AgentID = NULL; + soap_default_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, &((_apr__ConsoleWatchdogSetActions*)this)->ConsoleWatchdogActions); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogSetActions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogSetActions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogSetActions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogSetActions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogSetActions(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogSetActions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogSetActions), type); + soap_out_PointerToapr__GUID(soap, "apr:AgentID", -1, &(((_apr__ConsoleWatchdogSetActions*)a)->AgentID), ""); + soap_out_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, "apr:ConsoleWatchdogActions", -1, &(((_apr__ConsoleWatchdogSetActions*)a)->ConsoleWatchdogActions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogSetActions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogSetActions(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogSetActions(struct soap *soap, _apr__ConsoleWatchdogSetActions *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogSetActions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogSetActions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogSetActions(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogSetActions(struct soap *soap, const char *tag, _apr__ConsoleWatchdogSetActions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogSetActions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogSetActions, sizeof(_apr__ConsoleWatchdogSetActions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogSetActions) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogSetActions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AgentID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AgentID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapr__GUID(soap, "apr:AgentID", &(((_apr__ConsoleWatchdogSetActions*)a)->AgentID), "apr:GUID")) + { soap_flag_AgentID1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, "apr:ConsoleWatchdogActions", &(((_apr__ConsoleWatchdogSetActions*)a)->ConsoleWatchdogActions), "apr:ConsoleWatchdogActionType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AgentID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogSetActions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogSetActions, 0, sizeof(_apr__ConsoleWatchdogSetActions), 0, soap_copy__apr__ConsoleWatchdogSetActions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogSetActions * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogSetActions(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogSetActions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogSetActions(struct soap *soap, _apr__ConsoleWatchdogSetActions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogSetActions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogSetActions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogSetActions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogSetActions; + if (size) + *size = sizeof(_apr__ConsoleWatchdogSetActions); + ((_apr__ConsoleWatchdogSetActions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogSetActions[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogSetActions); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogSetActions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogSetActions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogSetActions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogSetActions %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogSetActions*)p = *(_apr__ConsoleWatchdogSetActions*)q; +} + +void _apr__ConsoleWatchdogEnumerateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(soap, &((_apr__ConsoleWatchdogEnumerateResponse*)this)->ConsoleWatchdogEntries); + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogEnumerateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apr__PT_USCORESTATUS(soap, &((_apr__ConsoleWatchdogEnumerateResponse*)this)->Status); + soap_default_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(soap, &((_apr__ConsoleWatchdogEnumerateResponse*)this)->ConsoleWatchdogEntries); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogEnumerateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogEnumerateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogEnumerateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogEnumerateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse), type); + soap_element_result(soap, "apr:Status"); + soap_out_apr__PT_USCORESTATUS(soap, "apr:Status", -1, &(((_apr__ConsoleWatchdogEnumerateResponse*)a)->Status), ""); + soap_out_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(soap, "apr:ConsoleWatchdogEntries", -1, &(((_apr__ConsoleWatchdogEnumerateResponse*)a)->ConsoleWatchdogEntries), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogEnumerateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogEnumerateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, _apr__ConsoleWatchdogEnumerateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogEnumerateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogEnumerateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogEnumerateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogEnumerateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogEnumerateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse, sizeof(_apr__ConsoleWatchdogEnumerateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogEnumerateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__PT_USCORESTATUS(soap, "apr:Status", &(((_apr__ConsoleWatchdogEnumerateResponse*)a)->Status), "apr:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(soap, "apr:ConsoleWatchdogEntries", &(((_apr__ConsoleWatchdogEnumerateResponse*)a)->ConsoleWatchdogEntries), "apr:ConsoleWatchdogEntryType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "apr:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogEnumerateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse, 0, sizeof(_apr__ConsoleWatchdogEnumerateResponse), 0, soap_copy__apr__ConsoleWatchdogEnumerateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogEnumerateResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogEnumerateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, _apr__ConsoleWatchdogEnumerateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogEnumerateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogEnumerateResponse; + if (size) + *size = sizeof(_apr__ConsoleWatchdogEnumerateResponse); + ((_apr__ConsoleWatchdogEnumerateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogEnumerateResponse[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogEnumerateResponse); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogEnumerateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogEnumerateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogEnumerateResponse %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogEnumerateResponse*)p = *(_apr__ConsoleWatchdogEnumerateResponse*)q; +} + +void _apr__ConsoleWatchdogEnumerate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogEnumerate::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogEnumerate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogEnumerate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogEnumerate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogEnumerate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogEnumerate(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogEnumerate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogEnumerate), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogEnumerate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogEnumerate(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogEnumerate(struct soap *soap, _apr__ConsoleWatchdogEnumerate *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogEnumerate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogEnumerate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogEnumerate(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogEnumerate(struct soap *soap, const char *tag, _apr__ConsoleWatchdogEnumerate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogEnumerate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogEnumerate, sizeof(_apr__ConsoleWatchdogEnumerate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogEnumerate) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogEnumerate *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogEnumerate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogEnumerate, 0, sizeof(_apr__ConsoleWatchdogEnumerate), 0, soap_copy__apr__ConsoleWatchdogEnumerate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogEnumerate * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogEnumerate(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogEnumerate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogEnumerate(struct soap *soap, _apr__ConsoleWatchdogEnumerate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogEnumerate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogEnumerate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogEnumerate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogEnumerate; + if (size) + *size = sizeof(_apr__ConsoleWatchdogEnumerate); + ((_apr__ConsoleWatchdogEnumerate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogEnumerate[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogEnumerate); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogEnumerate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogEnumerate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogEnumerate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogEnumerate %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogEnumerate*)p = *(_apr__ConsoleWatchdogEnumerate*)q; +} + +void _apr__ConsoleWatchdogDeleteResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogDeleteResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apr__PT_USCORESTATUS(soap, &((_apr__ConsoleWatchdogDeleteResponse*)this)->Status); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogDeleteResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogDeleteResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogDeleteResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogDeleteResponse(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogDeleteResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse), type); + soap_element_result(soap, "apr:Status"); + soap_out_apr__PT_USCORESTATUS(soap, "apr:Status", -1, &(((_apr__ConsoleWatchdogDeleteResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogDeleteResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogDeleteResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogDeleteResponse(struct soap *soap, _apr__ConsoleWatchdogDeleteResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogDeleteResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogDeleteResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogDeleteResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogDeleteResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogDeleteResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogDeleteResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse, sizeof(_apr__ConsoleWatchdogDeleteResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogDeleteResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__PT_USCORESTATUS(soap, "apr:Status", &(((_apr__ConsoleWatchdogDeleteResponse*)a)->Status), "apr:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "apr:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogDeleteResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse, 0, sizeof(_apr__ConsoleWatchdogDeleteResponse), 0, soap_copy__apr__ConsoleWatchdogDeleteResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogDeleteResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogDeleteResponse(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogDeleteResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogDeleteResponse(struct soap *soap, _apr__ConsoleWatchdogDeleteResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogDeleteResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogDeleteResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogDeleteResponse; + if (size) + *size = sizeof(_apr__ConsoleWatchdogDeleteResponse); + ((_apr__ConsoleWatchdogDeleteResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogDeleteResponse[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogDeleteResponse); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogDeleteResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogDeleteResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogDeleteResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogDeleteResponse %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogDeleteResponse*)p = *(_apr__ConsoleWatchdogDeleteResponse*)q; +} + +void _apr__ConsoleWatchdogDelete::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToapr__GUID(soap, &((_apr__ConsoleWatchdogDelete*)this)->AgentID); + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogDelete::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_apr__ConsoleWatchdogDelete*)this)->AgentID = NULL; + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogDelete::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogDelete); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogDelete::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogDelete(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogDelete(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogDelete *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogDelete), type); + soap_out_PointerToapr__GUID(soap, "apr:AgentID", -1, &(((_apr__ConsoleWatchdogDelete*)a)->AgentID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogDelete::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogDelete(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogDelete(struct soap *soap, _apr__ConsoleWatchdogDelete *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogDelete(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogDelete::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogDelete(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogDelete(struct soap *soap, const char *tag, _apr__ConsoleWatchdogDelete *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogDelete *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogDelete, sizeof(_apr__ConsoleWatchdogDelete), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogDelete) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogDelete *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AgentID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AgentID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapr__GUID(soap, "apr:AgentID", &(((_apr__ConsoleWatchdogDelete*)a)->AgentID), "apr:GUID")) + { soap_flag_AgentID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AgentID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogDelete *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogDelete, 0, sizeof(_apr__ConsoleWatchdogDelete), 0, soap_copy__apr__ConsoleWatchdogDelete); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogDelete * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogDelete(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogDelete(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogDelete(struct soap *soap, _apr__ConsoleWatchdogDelete *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogDelete(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogDelete(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogDelete, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogDelete; + if (size) + *size = sizeof(_apr__ConsoleWatchdogDelete); + ((_apr__ConsoleWatchdogDelete*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogDelete[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogDelete); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogDelete*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogDelete*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogDelete(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogDelete %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogDelete*)p = *(_apr__ConsoleWatchdogDelete*)q; +} + +void _apr__ConsoleWatchdogCreateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogCreateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apr__PT_USCORESTATUS(soap, &((_apr__ConsoleWatchdogCreateResponse*)this)->Status); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogCreateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogCreateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogCreateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogCreateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogCreateResponse(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogCreateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogCreateResponse), type); + soap_element_result(soap, "apr:Status"); + soap_out_apr__PT_USCORESTATUS(soap, "apr:Status", -1, &(((_apr__ConsoleWatchdogCreateResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogCreateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogCreateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogCreateResponse(struct soap *soap, _apr__ConsoleWatchdogCreateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogCreateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogCreateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogCreateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogCreateResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogCreateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogCreateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogCreateResponse, sizeof(_apr__ConsoleWatchdogCreateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogCreateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogCreateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__PT_USCORESTATUS(soap, "apr:Status", &(((_apr__ConsoleWatchdogCreateResponse*)a)->Status), "apr:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "apr:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogCreateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogCreateResponse, 0, sizeof(_apr__ConsoleWatchdogCreateResponse), 0, soap_copy__apr__ConsoleWatchdogCreateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogCreateResponse * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogCreateResponse(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogCreateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogCreateResponse(struct soap *soap, _apr__ConsoleWatchdogCreateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogCreateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogCreateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogCreateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogCreateResponse; + if (size) + *size = sizeof(_apr__ConsoleWatchdogCreateResponse); + ((_apr__ConsoleWatchdogCreateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogCreateResponse[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogCreateResponse); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogCreateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogCreateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogCreateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogCreateResponse %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogCreateResponse*)p = *(_apr__ConsoleWatchdogCreateResponse*)q; +} + +void _apr__ConsoleWatchdogCreate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToapr__GUID(soap, &((_apr__ConsoleWatchdogCreate*)this)->AgentID); + soap_embedded(soap, &((_apr__ConsoleWatchdogCreate*)this)->AgentHeartbeatTime, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((_apr__ConsoleWatchdogCreate*)this)->AgentStartupTime, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void _apr__ConsoleWatchdogCreate::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_apr__ConsoleWatchdogCreate*)this)->AgentID = NULL; + ((_apr__ConsoleWatchdogCreate*)this)->AgentDescription = NULL; + soap_default_unsignedShort(soap, &((_apr__ConsoleWatchdogCreate*)this)->AgentHeartbeatTime); + soap_default_unsignedShort(soap, &((_apr__ConsoleWatchdogCreate*)this)->AgentStartupTime); + /* transient soap skipped */ +} + +int _apr__ConsoleWatchdogCreate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__apr__ConsoleWatchdogCreate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _apr__ConsoleWatchdogCreate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__apr__ConsoleWatchdogCreate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__apr__ConsoleWatchdogCreate(struct soap *soap, const char *tag, int id, const _apr__ConsoleWatchdogCreate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__apr__ConsoleWatchdogCreate), type); + soap_out_PointerToapr__GUID(soap, "apr:AgentID", -1, &(((_apr__ConsoleWatchdogCreate*)a)->AgentID), ""); + soap_outliteral(soap, "apr:AgentDescription", &(((_apr__ConsoleWatchdogCreate*)a)->AgentDescription), NULL); + soap_out_unsignedShort(soap, "apr:AgentHeartbeatTime", -1, &(((_apr__ConsoleWatchdogCreate*)a)->AgentHeartbeatTime), ""); + soap_out_unsignedShort(soap, "apr:AgentStartupTime", -1, &(((_apr__ConsoleWatchdogCreate*)a)->AgentStartupTime), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_apr__ConsoleWatchdogCreate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__apr__ConsoleWatchdogCreate(soap, this, tag, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_get__apr__ConsoleWatchdogCreate(struct soap *soap, _apr__ConsoleWatchdogCreate *p, const char *tag, const char *type) +{ + if ((p = soap_in__apr__ConsoleWatchdogCreate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_apr__ConsoleWatchdogCreate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__apr__ConsoleWatchdogCreate(soap, tag, this, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_in__apr__ConsoleWatchdogCreate(struct soap *soap, const char *tag, _apr__ConsoleWatchdogCreate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_apr__ConsoleWatchdogCreate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__apr__ConsoleWatchdogCreate, sizeof(_apr__ConsoleWatchdogCreate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__apr__ConsoleWatchdogCreate) + { soap_revert(soap); + *soap->id = '\0'; + return (_apr__ConsoleWatchdogCreate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AgentID1 = 1, soap_flag_AgentDescription1 = 1, soap_flag_AgentHeartbeatTime1 = 1, soap_flag_AgentStartupTime1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AgentID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapr__GUID(soap, "apr:AgentID", &(((_apr__ConsoleWatchdogCreate*)a)->AgentID), "apr:GUID")) + { soap_flag_AgentID1--; + continue; + } + if (soap_flag_AgentDescription1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_inliteral(soap, "apr:AgentDescription", &(((_apr__ConsoleWatchdogCreate*)a)->AgentDescription))) + { soap_flag_AgentDescription1--; + continue; + } + if (soap_flag_AgentHeartbeatTime1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "apr:AgentHeartbeatTime", &(((_apr__ConsoleWatchdogCreate*)a)->AgentHeartbeatTime), "xsd:unsignedShort")) + { soap_flag_AgentHeartbeatTime1--; + continue; + } + if (soap_flag_AgentStartupTime1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "apr:AgentStartupTime", &(((_apr__ConsoleWatchdogCreate*)a)->AgentStartupTime), "xsd:unsignedShort")) + { soap_flag_AgentStartupTime1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AgentID1 > 0 || soap_flag_AgentHeartbeatTime1 > 0 || soap_flag_AgentStartupTime1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogCreate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__apr__ConsoleWatchdogCreate, 0, sizeof(_apr__ConsoleWatchdogCreate), 0, soap_copy__apr__ConsoleWatchdogCreate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _apr__ConsoleWatchdogCreate * SOAP_FMAC6 soap_new__apr__ConsoleWatchdogCreate(struct soap *soap, int n) +{ return soap_instantiate__apr__ConsoleWatchdogCreate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__apr__ConsoleWatchdogCreate(struct soap *soap, _apr__ConsoleWatchdogCreate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_instantiate__apr__ConsoleWatchdogCreate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__apr__ConsoleWatchdogCreate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__apr__ConsoleWatchdogCreate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _apr__ConsoleWatchdogCreate; + if (size) + *size = sizeof(_apr__ConsoleWatchdogCreate); + ((_apr__ConsoleWatchdogCreate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _apr__ConsoleWatchdogCreate[n]; + if (size) + *size = n * sizeof(_apr__ConsoleWatchdogCreate); + for (int i = 0; i < n; i++) + ((_apr__ConsoleWatchdogCreate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_apr__ConsoleWatchdogCreate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__apr__ConsoleWatchdogCreate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _apr__ConsoleWatchdogCreate %p -> %p\n", q, p)); + *(_apr__ConsoleWatchdogCreate*)p = *(_apr__ConsoleWatchdogCreate*)q; +} + +void apr__AgentPresenceCapabilitiesType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((apr__AgentPresenceCapabilitiesType*)this)->MaxTotalAgents, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((apr__AgentPresenceCapabilitiesType*)this)->MaxTotalActions, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((apr__AgentPresenceCapabilitiesType*)this)->MinGuaranteedActionListSize, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void apr__AgentPresenceCapabilitiesType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((apr__AgentPresenceCapabilitiesType*)this)->MaxTotalAgents); + soap_default_unsignedInt(soap, &((apr__AgentPresenceCapabilitiesType*)this)->MaxTotalActions); + soap_default_unsignedInt(soap, &((apr__AgentPresenceCapabilitiesType*)this)->MinGuaranteedActionListSize); + /* transient soap skipped */ +} + +int apr__AgentPresenceCapabilitiesType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_apr__AgentPresenceCapabilitiesType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int apr__AgentPresenceCapabilitiesType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_apr__AgentPresenceCapabilitiesType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__AgentPresenceCapabilitiesType(struct soap *soap, const char *tag, int id, const apr__AgentPresenceCapabilitiesType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_apr__AgentPresenceCapabilitiesType), type); + soap_out_unsignedInt(soap, "apr:MaxTotalAgents", -1, &(((apr__AgentPresenceCapabilitiesType*)a)->MaxTotalAgents), ""); + soap_out_unsignedInt(soap, "apr:MaxTotalActions", -1, &(((apr__AgentPresenceCapabilitiesType*)a)->MaxTotalActions), ""); + soap_out_unsignedInt(soap, "apr:MinGuaranteedActionListSize", -1, &(((apr__AgentPresenceCapabilitiesType*)a)->MinGuaranteedActionListSize), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *apr__AgentPresenceCapabilitiesType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_apr__AgentPresenceCapabilitiesType(soap, this, tag, type); +} + +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType * SOAP_FMAC4 soap_get_apr__AgentPresenceCapabilitiesType(struct soap *soap, apr__AgentPresenceCapabilitiesType *p, const char *tag, const char *type) +{ + if ((p = soap_in_apr__AgentPresenceCapabilitiesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *apr__AgentPresenceCapabilitiesType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_apr__AgentPresenceCapabilitiesType(soap, tag, this, type); +} + +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType * SOAP_FMAC4 soap_in_apr__AgentPresenceCapabilitiesType(struct soap *soap, const char *tag, apr__AgentPresenceCapabilitiesType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (apr__AgentPresenceCapabilitiesType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_apr__AgentPresenceCapabilitiesType, sizeof(apr__AgentPresenceCapabilitiesType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_apr__AgentPresenceCapabilitiesType) + { soap_revert(soap); + *soap->id = '\0'; + return (apr__AgentPresenceCapabilitiesType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_MaxTotalAgents1 = 1, soap_flag_MaxTotalActions1 = 1, soap_flag_MinGuaranteedActionListSize1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_MaxTotalAgents1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "apr:MaxTotalAgents", &(((apr__AgentPresenceCapabilitiesType*)a)->MaxTotalAgents), "xsd:unsignedInt")) + { soap_flag_MaxTotalAgents1--; + continue; + } + if (soap_flag_MaxTotalActions1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "apr:MaxTotalActions", &(((apr__AgentPresenceCapabilitiesType*)a)->MaxTotalActions), "xsd:unsignedInt")) + { soap_flag_MaxTotalActions1--; + continue; + } + if (soap_flag_MinGuaranteedActionListSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "apr:MinGuaranteedActionListSize", &(((apr__AgentPresenceCapabilitiesType*)a)->MinGuaranteedActionListSize), "xsd:unsignedInt")) + { soap_flag_MinGuaranteedActionListSize1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_MaxTotalAgents1 > 0 || soap_flag_MaxTotalActions1 > 0 || soap_flag_MinGuaranteedActionListSize1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (apr__AgentPresenceCapabilitiesType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_apr__AgentPresenceCapabilitiesType, 0, sizeof(apr__AgentPresenceCapabilitiesType), 0, soap_copy_apr__AgentPresenceCapabilitiesType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 apr__AgentPresenceCapabilitiesType * SOAP_FMAC6 soap_new_apr__AgentPresenceCapabilitiesType(struct soap *soap, int n) +{ return soap_instantiate_apr__AgentPresenceCapabilitiesType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__AgentPresenceCapabilitiesType(struct soap *soap, apr__AgentPresenceCapabilitiesType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType * SOAP_FMAC4 soap_instantiate_apr__AgentPresenceCapabilitiesType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_apr__AgentPresenceCapabilitiesType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_apr__AgentPresenceCapabilitiesType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new apr__AgentPresenceCapabilitiesType; + if (size) + *size = sizeof(apr__AgentPresenceCapabilitiesType); + ((apr__AgentPresenceCapabilitiesType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new apr__AgentPresenceCapabilitiesType[n]; + if (size) + *size = n * sizeof(apr__AgentPresenceCapabilitiesType); + for (int i = 0; i < n; i++) + ((apr__AgentPresenceCapabilitiesType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (apr__AgentPresenceCapabilitiesType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__AgentPresenceCapabilitiesType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying apr__AgentPresenceCapabilitiesType %p -> %p\n", q, p)); + *(apr__AgentPresenceCapabilitiesType*)p = *(apr__AgentPresenceCapabilitiesType*)q; +} + +void apr__CircuitBreakerHardwarePolicyType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((apr__CircuitBreakerHardwarePolicyType*)this)->HardwareID, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((apr__CircuitBreakerHardwarePolicyType*)this)->PolicyCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void apr__CircuitBreakerHardwarePolicyType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((apr__CircuitBreakerHardwarePolicyType*)this)->HardwareID); + soap_default_unsignedInt(soap, &((apr__CircuitBreakerHardwarePolicyType*)this)->PolicyCreationHandle); + /* transient soap skipped */ +} + +int apr__CircuitBreakerHardwarePolicyType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int apr__CircuitBreakerHardwarePolicyType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_apr__CircuitBreakerHardwarePolicyType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, int id, const apr__CircuitBreakerHardwarePolicyType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType), type); + soap_out_unsignedInt(soap, "apr:HardwareID", -1, &(((apr__CircuitBreakerHardwarePolicyType*)a)->HardwareID), ""); + soap_out_unsignedInt(soap, "apr:PolicyCreationHandle", -1, &(((apr__CircuitBreakerHardwarePolicyType*)a)->PolicyCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *apr__CircuitBreakerHardwarePolicyType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_apr__CircuitBreakerHardwarePolicyType(soap, this, tag, type); +} + +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_get_apr__CircuitBreakerHardwarePolicyType(struct soap *soap, apr__CircuitBreakerHardwarePolicyType *p, const char *tag, const char *type) +{ + if ((p = soap_in_apr__CircuitBreakerHardwarePolicyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *apr__CircuitBreakerHardwarePolicyType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_apr__CircuitBreakerHardwarePolicyType(soap, tag, this, type); +} + +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_in_apr__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, apr__CircuitBreakerHardwarePolicyType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (apr__CircuitBreakerHardwarePolicyType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType, sizeof(apr__CircuitBreakerHardwarePolicyType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType) + { soap_revert(soap); + *soap->id = '\0'; + return (apr__CircuitBreakerHardwarePolicyType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_HardwareID1 = 1, soap_flag_PolicyCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_HardwareID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "apr:HardwareID", &(((apr__CircuitBreakerHardwarePolicyType*)a)->HardwareID), "xsd:unsignedInt")) + { soap_flag_HardwareID1--; + continue; + } + if (soap_flag_PolicyCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "apr:PolicyCreationHandle", &(((apr__CircuitBreakerHardwarePolicyType*)a)->PolicyCreationHandle), "xsd:unsignedInt")) + { soap_flag_PolicyCreationHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_HardwareID1 > 0 || soap_flag_PolicyCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (apr__CircuitBreakerHardwarePolicyType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType, 0, sizeof(apr__CircuitBreakerHardwarePolicyType), 0, soap_copy_apr__CircuitBreakerHardwarePolicyType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 apr__CircuitBreakerHardwarePolicyType * SOAP_FMAC6 soap_new_apr__CircuitBreakerHardwarePolicyType(struct soap *soap, int n) +{ return soap_instantiate_apr__CircuitBreakerHardwarePolicyType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__CircuitBreakerHardwarePolicyType(struct soap *soap, apr__CircuitBreakerHardwarePolicyType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_instantiate_apr__CircuitBreakerHardwarePolicyType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_apr__CircuitBreakerHardwarePolicyType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new apr__CircuitBreakerHardwarePolicyType; + if (size) + *size = sizeof(apr__CircuitBreakerHardwarePolicyType); + ((apr__CircuitBreakerHardwarePolicyType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new apr__CircuitBreakerHardwarePolicyType[n]; + if (size) + *size = n * sizeof(apr__CircuitBreakerHardwarePolicyType); + for (int i = 0; i < n; i++) + ((apr__CircuitBreakerHardwarePolicyType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (apr__CircuitBreakerHardwarePolicyType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__CircuitBreakerHardwarePolicyType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying apr__CircuitBreakerHardwarePolicyType %p -> %p\n", q, p)); + *(apr__CircuitBreakerHardwarePolicyType*)p = *(apr__CircuitBreakerHardwarePolicyType*)q; +} + +void apr__ConsoleWatchdogActionType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((apr__ConsoleWatchdogActionType*)this)->ActionEventOnTransition, SOAP_TYPE_bool); + soap_serialize_PointerToapr__CbActionType(soap, &((apr__ConsoleWatchdogActionType*)this)->ActionCb); + /* transient soap skipped */ +} + +void apr__ConsoleWatchdogActionType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_apr__WatchdogState(soap, &((apr__ConsoleWatchdogActionType*)this)->OldState); + soap_default_apr__WatchdogState(soap, &((apr__ConsoleWatchdogActionType*)this)->NewState); + soap_default_bool(soap, &((apr__ConsoleWatchdogActionType*)this)->ActionEventOnTransition); + ((apr__ConsoleWatchdogActionType*)this)->ActionCb = NULL; + /* transient soap skipped */ +} + +int apr__ConsoleWatchdogActionType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_apr__ConsoleWatchdogActionType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int apr__ConsoleWatchdogActionType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_apr__ConsoleWatchdogActionType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__ConsoleWatchdogActionType(struct soap *soap, const char *tag, int id, const apr__ConsoleWatchdogActionType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_apr__ConsoleWatchdogActionType), type); + soap_out_apr__WatchdogState(soap, "apr:OldState", -1, &(((apr__ConsoleWatchdogActionType*)a)->OldState), ""); + soap_out_apr__WatchdogState(soap, "apr:NewState", -1, &(((apr__ConsoleWatchdogActionType*)a)->NewState), ""); + soap_out_bool(soap, "apr:ActionEventOnTransition", -1, &(((apr__ConsoleWatchdogActionType*)a)->ActionEventOnTransition), ""); + soap_out_PointerToapr__CbActionType(soap, "apr:ActionCb", -1, &(((apr__ConsoleWatchdogActionType*)a)->ActionCb), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *apr__ConsoleWatchdogActionType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_apr__ConsoleWatchdogActionType(soap, this, tag, type); +} + +SOAP_FMAC3 apr__ConsoleWatchdogActionType * SOAP_FMAC4 soap_get_apr__ConsoleWatchdogActionType(struct soap *soap, apr__ConsoleWatchdogActionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_apr__ConsoleWatchdogActionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *apr__ConsoleWatchdogActionType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_apr__ConsoleWatchdogActionType(soap, tag, this, type); +} + +SOAP_FMAC3 apr__ConsoleWatchdogActionType * SOAP_FMAC4 soap_in_apr__ConsoleWatchdogActionType(struct soap *soap, const char *tag, apr__ConsoleWatchdogActionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (apr__ConsoleWatchdogActionType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_apr__ConsoleWatchdogActionType, sizeof(apr__ConsoleWatchdogActionType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_apr__ConsoleWatchdogActionType) + { soap_revert(soap); + *soap->id = '\0'; + return (apr__ConsoleWatchdogActionType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_OldState1 = 1, soap_flag_NewState1 = 1, soap_flag_ActionEventOnTransition1 = 1, soap_flag_ActionCb1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_OldState1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__WatchdogState(soap, "apr:OldState", &(((apr__ConsoleWatchdogActionType*)a)->OldState), "apr:WatchdogState")) + { soap_flag_OldState1--; + continue; + } + if (soap_flag_NewState1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__WatchdogState(soap, "apr:NewState", &(((apr__ConsoleWatchdogActionType*)a)->NewState), "apr:WatchdogState")) + { soap_flag_NewState1--; + continue; + } + if (soap_flag_ActionEventOnTransition1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "apr:ActionEventOnTransition", &(((apr__ConsoleWatchdogActionType*)a)->ActionEventOnTransition), "xsd:boolean")) + { soap_flag_ActionEventOnTransition1--; + continue; + } + if (soap_flag_ActionCb1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapr__CbActionType(soap, "apr:ActionCb", &(((apr__ConsoleWatchdogActionType*)a)->ActionCb), "apr:CbActionType")) + { soap_flag_ActionCb1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_OldState1 > 0 || soap_flag_NewState1 > 0 || soap_flag_ActionEventOnTransition1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (apr__ConsoleWatchdogActionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_apr__ConsoleWatchdogActionType, 0, sizeof(apr__ConsoleWatchdogActionType), 0, soap_copy_apr__ConsoleWatchdogActionType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 apr__ConsoleWatchdogActionType * SOAP_FMAC6 soap_new_apr__ConsoleWatchdogActionType(struct soap *soap, int n) +{ return soap_instantiate_apr__ConsoleWatchdogActionType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__ConsoleWatchdogActionType(struct soap *soap, apr__ConsoleWatchdogActionType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 apr__ConsoleWatchdogActionType * SOAP_FMAC4 soap_instantiate_apr__ConsoleWatchdogActionType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_apr__ConsoleWatchdogActionType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_apr__ConsoleWatchdogActionType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new apr__ConsoleWatchdogActionType; + if (size) + *size = sizeof(apr__ConsoleWatchdogActionType); + ((apr__ConsoleWatchdogActionType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new apr__ConsoleWatchdogActionType[n]; + if (size) + *size = n * sizeof(apr__ConsoleWatchdogActionType); + for (int i = 0; i < n; i++) + ((apr__ConsoleWatchdogActionType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (apr__ConsoleWatchdogActionType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__ConsoleWatchdogActionType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying apr__ConsoleWatchdogActionType %p -> %p\n", q, p)); + *(apr__ConsoleWatchdogActionType*)p = *(apr__ConsoleWatchdogActionType*)q; +} + +void apr__ConsoleWatchdogEntryType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToapr__GUID(soap, &((apr__ConsoleWatchdogEntryType*)this)->AgentID); + soap_embedded(soap, &((apr__ConsoleWatchdogEntryType*)this)->AgentHeartbeatTime, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((apr__ConsoleWatchdogEntryType*)this)->AgentStartupTime, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((apr__ConsoleWatchdogEntryType*)this)->NumActions, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void apr__ConsoleWatchdogEntryType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((apr__ConsoleWatchdogEntryType*)this)->AgentID = NULL; + ((apr__ConsoleWatchdogEntryType*)this)->AgentDescription = NULL; + soap_default_unsignedShort(soap, &((apr__ConsoleWatchdogEntryType*)this)->AgentHeartbeatTime); + soap_default_unsignedShort(soap, &((apr__ConsoleWatchdogEntryType*)this)->AgentStartupTime); + soap_default_unsignedInt(soap, &((apr__ConsoleWatchdogEntryType*)this)->NumActions); + soap_default_apr__WatchdogState(soap, &((apr__ConsoleWatchdogEntryType*)this)->State); + /* transient soap skipped */ +} + +int apr__ConsoleWatchdogEntryType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_apr__ConsoleWatchdogEntryType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int apr__ConsoleWatchdogEntryType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_apr__ConsoleWatchdogEntryType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__ConsoleWatchdogEntryType(struct soap *soap, const char *tag, int id, const apr__ConsoleWatchdogEntryType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_apr__ConsoleWatchdogEntryType), type); + soap_out_PointerToapr__GUID(soap, "apr:AgentID", -1, &(((apr__ConsoleWatchdogEntryType*)a)->AgentID), ""); + soap_outliteral(soap, "apr:AgentDescription", &(((apr__ConsoleWatchdogEntryType*)a)->AgentDescription), NULL); + soap_out_unsignedShort(soap, "apr:AgentHeartbeatTime", -1, &(((apr__ConsoleWatchdogEntryType*)a)->AgentHeartbeatTime), ""); + soap_out_unsignedShort(soap, "apr:AgentStartupTime", -1, &(((apr__ConsoleWatchdogEntryType*)a)->AgentStartupTime), ""); + soap_out_unsignedInt(soap, "apr:NumActions", -1, &(((apr__ConsoleWatchdogEntryType*)a)->NumActions), ""); + soap_out_apr__WatchdogState(soap, "apr:State", -1, &(((apr__ConsoleWatchdogEntryType*)a)->State), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *apr__ConsoleWatchdogEntryType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_apr__ConsoleWatchdogEntryType(soap, this, tag, type); +} + +SOAP_FMAC3 apr__ConsoleWatchdogEntryType * SOAP_FMAC4 soap_get_apr__ConsoleWatchdogEntryType(struct soap *soap, apr__ConsoleWatchdogEntryType *p, const char *tag, const char *type) +{ + if ((p = soap_in_apr__ConsoleWatchdogEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *apr__ConsoleWatchdogEntryType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_apr__ConsoleWatchdogEntryType(soap, tag, this, type); +} + +SOAP_FMAC3 apr__ConsoleWatchdogEntryType * SOAP_FMAC4 soap_in_apr__ConsoleWatchdogEntryType(struct soap *soap, const char *tag, apr__ConsoleWatchdogEntryType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (apr__ConsoleWatchdogEntryType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_apr__ConsoleWatchdogEntryType, sizeof(apr__ConsoleWatchdogEntryType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_apr__ConsoleWatchdogEntryType) + { soap_revert(soap); + *soap->id = '\0'; + return (apr__ConsoleWatchdogEntryType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AgentID1 = 1, soap_flag_AgentDescription1 = 1, soap_flag_AgentHeartbeatTime1 = 1, soap_flag_AgentStartupTime1 = 1, soap_flag_NumActions1 = 1, soap_flag_State1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AgentID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToapr__GUID(soap, "apr:AgentID", &(((apr__ConsoleWatchdogEntryType*)a)->AgentID), "apr:GUID")) + { soap_flag_AgentID1--; + continue; + } + if (soap_flag_AgentDescription1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_inliteral(soap, "apr:AgentDescription", &(((apr__ConsoleWatchdogEntryType*)a)->AgentDescription))) + { soap_flag_AgentDescription1--; + continue; + } + if (soap_flag_AgentHeartbeatTime1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "apr:AgentHeartbeatTime", &(((apr__ConsoleWatchdogEntryType*)a)->AgentHeartbeatTime), "xsd:unsignedShort")) + { soap_flag_AgentHeartbeatTime1--; + continue; + } + if (soap_flag_AgentStartupTime1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "apr:AgentStartupTime", &(((apr__ConsoleWatchdogEntryType*)a)->AgentStartupTime), "xsd:unsignedShort")) + { soap_flag_AgentStartupTime1--; + continue; + } + if (soap_flag_NumActions1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "apr:NumActions", &(((apr__ConsoleWatchdogEntryType*)a)->NumActions), "xsd:unsignedInt")) + { soap_flag_NumActions1--; + continue; + } + if (soap_flag_State1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_apr__WatchdogState(soap, "apr:State", &(((apr__ConsoleWatchdogEntryType*)a)->State), "apr:WatchdogState")) + { soap_flag_State1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AgentID1 > 0 || soap_flag_AgentHeartbeatTime1 > 0 || soap_flag_AgentStartupTime1 > 0 || soap_flag_NumActions1 > 0 || soap_flag_State1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (apr__ConsoleWatchdogEntryType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_apr__ConsoleWatchdogEntryType, 0, sizeof(apr__ConsoleWatchdogEntryType), 0, soap_copy_apr__ConsoleWatchdogEntryType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 apr__ConsoleWatchdogEntryType * SOAP_FMAC6 soap_new_apr__ConsoleWatchdogEntryType(struct soap *soap, int n) +{ return soap_instantiate_apr__ConsoleWatchdogEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__ConsoleWatchdogEntryType(struct soap *soap, apr__ConsoleWatchdogEntryType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 apr__ConsoleWatchdogEntryType * SOAP_FMAC4 soap_instantiate_apr__ConsoleWatchdogEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_apr__ConsoleWatchdogEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_apr__ConsoleWatchdogEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new apr__ConsoleWatchdogEntryType; + if (size) + *size = sizeof(apr__ConsoleWatchdogEntryType); + ((apr__ConsoleWatchdogEntryType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new apr__ConsoleWatchdogEntryType[n]; + if (size) + *size = n * sizeof(apr__ConsoleWatchdogEntryType); + for (int i = 0; i < n; i++) + ((apr__ConsoleWatchdogEntryType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (apr__ConsoleWatchdogEntryType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__ConsoleWatchdogEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying apr__ConsoleWatchdogEntryType %p -> %p\n", q, p)); + *(apr__ConsoleWatchdogEntryType*)p = *(apr__ConsoleWatchdogEntryType*)q; +} + +void apr__GUID::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((apr__GUID*)this)->Byte); + /* transient soap skipped */ +} + +void apr__GUID::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfunsignedByte(soap, &((apr__GUID*)this)->Byte); + /* transient soap skipped */ +} + +int apr__GUID::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_apr__GUID); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int apr__GUID::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_apr__GUID(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_apr__GUID(struct soap *soap, const char *tag, int id, const apr__GUID *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_apr__GUID), type); + soap_out_std__vectorTemplateOfunsignedByte(soap, "apr:Byte", -1, &(((apr__GUID*)a)->Byte), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *apr__GUID::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_apr__GUID(soap, this, tag, type); +} + +SOAP_FMAC3 apr__GUID * SOAP_FMAC4 soap_get_apr__GUID(struct soap *soap, apr__GUID *p, const char *tag, const char *type) +{ + if ((p = soap_in_apr__GUID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *apr__GUID::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_apr__GUID(soap, tag, this, type); +} + +SOAP_FMAC3 apr__GUID * SOAP_FMAC4 soap_in_apr__GUID(struct soap *soap, const char *tag, apr__GUID *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (apr__GUID *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_apr__GUID, sizeof(apr__GUID), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_apr__GUID) + { soap_revert(soap); + *soap->id = '\0'; + return (apr__GUID *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "apr:Byte", &(((apr__GUID*)a)->Byte), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((apr__GUID*)a)->Byte.size() < 16 || ((apr__GUID*)a)->Byte.size() > 16)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (apr__GUID *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_apr__GUID, 0, sizeof(apr__GUID), 0, soap_copy_apr__GUID); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 apr__GUID * SOAP_FMAC6 soap_new_apr__GUID(struct soap *soap, int n) +{ return soap_instantiate_apr__GUID(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_apr__GUID(struct soap *soap, apr__GUID *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 apr__GUID * SOAP_FMAC4 soap_instantiate_apr__GUID(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_apr__GUID(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_apr__GUID, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new apr__GUID; + if (size) + *size = sizeof(apr__GUID); + ((apr__GUID*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new apr__GUID[n]; + if (size) + *size = n * sizeof(apr__GUID); + for (int i = 0; i < n; i++) + ((apr__GUID*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (apr__GUID*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_apr__GUID(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying apr__GUID %p -> %p\n", q, p)); + *(apr__GUID*)p = *(apr__GUID*)q; +} + +void _hwa__GetAssetDataResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_hwa__GetAssetDataResponse*)this)->Count, SOAP_TYPE_unsignedInt); + soap_serialize_PointerTohwa__AssetDataArrayType(soap, &((_hwa__GetAssetDataResponse*)this)->AssetData); + /* transient soap skipped */ +} + +void _hwa__GetAssetDataResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_hwa__PT_USCORESTATUS(soap, &((_hwa__GetAssetDataResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_hwa__GetAssetDataResponse*)this)->Count); + ((_hwa__GetAssetDataResponse*)this)->AssetData = NULL; + /* transient soap skipped */ +} + +int _hwa__GetAssetDataResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__hwa__GetAssetDataResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _hwa__GetAssetDataResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__hwa__GetAssetDataResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__hwa__GetAssetDataResponse(struct soap *soap, const char *tag, int id, const _hwa__GetAssetDataResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__hwa__GetAssetDataResponse), type); + soap_element_result(soap, "hwa:Status"); + soap_out_hwa__PT_USCORESTATUS(soap, "hwa:Status", -1, &(((_hwa__GetAssetDataResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "hwa:Count", -1, &(((_hwa__GetAssetDataResponse*)a)->Count), ""); + soap_out_PointerTohwa__AssetDataArrayType(soap, "hwa:AssetData", -1, &(((_hwa__GetAssetDataResponse*)a)->AssetData), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_hwa__GetAssetDataResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__hwa__GetAssetDataResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _hwa__GetAssetDataResponse * SOAP_FMAC4 soap_get__hwa__GetAssetDataResponse(struct soap *soap, _hwa__GetAssetDataResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__hwa__GetAssetDataResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_hwa__GetAssetDataResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__hwa__GetAssetDataResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _hwa__GetAssetDataResponse * SOAP_FMAC4 soap_in__hwa__GetAssetDataResponse(struct soap *soap, const char *tag, _hwa__GetAssetDataResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_hwa__GetAssetDataResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__hwa__GetAssetDataResponse, sizeof(_hwa__GetAssetDataResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__hwa__GetAssetDataResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_hwa__GetAssetDataResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Count1 = 1, soap_flag_AssetData1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCORESTATUS(soap, "hwa:Status", &(((_hwa__GetAssetDataResponse*)a)->Status), "hwa:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Count1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:Count", &(((_hwa__GetAssetDataResponse*)a)->Count), "xsd:unsignedInt")) + { soap_flag_Count1--; + continue; + } + if (soap_flag_AssetData1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTohwa__AssetDataArrayType(soap, "hwa:AssetData", &(((_hwa__GetAssetDataResponse*)a)->AssetData), "hwa:AssetDataArrayType")) + { soap_flag_AssetData1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "hwa:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Count1 > 0 || soap_flag_AssetData1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_hwa__GetAssetDataResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__hwa__GetAssetDataResponse, 0, sizeof(_hwa__GetAssetDataResponse), 0, soap_copy__hwa__GetAssetDataResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _hwa__GetAssetDataResponse * SOAP_FMAC6 soap_new__hwa__GetAssetDataResponse(struct soap *soap, int n) +{ return soap_instantiate__hwa__GetAssetDataResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__hwa__GetAssetDataResponse(struct soap *soap, _hwa__GetAssetDataResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _hwa__GetAssetDataResponse * SOAP_FMAC4 soap_instantiate__hwa__GetAssetDataResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__hwa__GetAssetDataResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__hwa__GetAssetDataResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _hwa__GetAssetDataResponse; + if (size) + *size = sizeof(_hwa__GetAssetDataResponse); + ((_hwa__GetAssetDataResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _hwa__GetAssetDataResponse[n]; + if (size) + *size = n * sizeof(_hwa__GetAssetDataResponse); + for (int i = 0; i < n; i++) + ((_hwa__GetAssetDataResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_hwa__GetAssetDataResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__hwa__GetAssetDataResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _hwa__GetAssetDataResponse %p -> %p\n", q, p)); + *(_hwa__GetAssetDataResponse*)p = *(_hwa__GetAssetDataResponse*)q; +} + +void _hwa__GetAssetData::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _hwa__GetAssetData::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_hwa__AssetTypeType(soap, &((_hwa__GetAssetData*)this)->AssetType); + /* transient soap skipped */ +} + +int _hwa__GetAssetData::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__hwa__GetAssetData); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _hwa__GetAssetData::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__hwa__GetAssetData(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__hwa__GetAssetData(struct soap *soap, const char *tag, int id, const _hwa__GetAssetData *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__hwa__GetAssetData), type); + soap_out_hwa__AssetTypeType(soap, "hwa:AssetType", -1, &(((_hwa__GetAssetData*)a)->AssetType), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_hwa__GetAssetData::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__hwa__GetAssetData(soap, this, tag, type); +} + +SOAP_FMAC3 _hwa__GetAssetData * SOAP_FMAC4 soap_get__hwa__GetAssetData(struct soap *soap, _hwa__GetAssetData *p, const char *tag, const char *type) +{ + if ((p = soap_in__hwa__GetAssetData(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_hwa__GetAssetData::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__hwa__GetAssetData(soap, tag, this, type); +} + +SOAP_FMAC3 _hwa__GetAssetData * SOAP_FMAC4 soap_in__hwa__GetAssetData(struct soap *soap, const char *tag, _hwa__GetAssetData *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_hwa__GetAssetData *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__hwa__GetAssetData, sizeof(_hwa__GetAssetData), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__hwa__GetAssetData) + { soap_revert(soap); + *soap->id = '\0'; + return (_hwa__GetAssetData *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AssetType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AssetType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__AssetTypeType(soap, "hwa:AssetType", &(((_hwa__GetAssetData*)a)->AssetType), "hwa:AssetTypeType")) + { soap_flag_AssetType1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AssetType1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_hwa__GetAssetData *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__hwa__GetAssetData, 0, sizeof(_hwa__GetAssetData), 0, soap_copy__hwa__GetAssetData); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _hwa__GetAssetData * SOAP_FMAC6 soap_new__hwa__GetAssetData(struct soap *soap, int n) +{ return soap_instantiate__hwa__GetAssetData(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__hwa__GetAssetData(struct soap *soap, _hwa__GetAssetData *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _hwa__GetAssetData * SOAP_FMAC4 soap_instantiate__hwa__GetAssetData(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__hwa__GetAssetData(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__hwa__GetAssetData, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _hwa__GetAssetData; + if (size) + *size = sizeof(_hwa__GetAssetData); + ((_hwa__GetAssetData*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _hwa__GetAssetData[n]; + if (size) + *size = n * sizeof(_hwa__GetAssetData); + for (int i = 0; i < n; i++) + ((_hwa__GetAssetData*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_hwa__GetAssetData*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__hwa__GetAssetData(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _hwa__GetAssetData %p -> %p\n", q, p)); + *(_hwa__GetAssetData*)p = *(_hwa__GetAssetData*)q; +} + +void _hwa__EnumerateAssetTypesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_hwa__EnumerateAssetTypesResponse*)this)->Count, SOAP_TYPE_unsignedInt); + soap_serialize_PointerTohwa__AssetTypeArrayType(soap, &((_hwa__EnumerateAssetTypesResponse*)this)->AssetTypes); + /* transient soap skipped */ +} + +void _hwa__EnumerateAssetTypesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_hwa__PT_USCORESTATUS(soap, &((_hwa__EnumerateAssetTypesResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_hwa__EnumerateAssetTypesResponse*)this)->Count); + ((_hwa__EnumerateAssetTypesResponse*)this)->AssetTypes = NULL; + /* transient soap skipped */ +} + +int _hwa__EnumerateAssetTypesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__hwa__EnumerateAssetTypesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _hwa__EnumerateAssetTypesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__hwa__EnumerateAssetTypesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__hwa__EnumerateAssetTypesResponse(struct soap *soap, const char *tag, int id, const _hwa__EnumerateAssetTypesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__hwa__EnumerateAssetTypesResponse), type); + soap_element_result(soap, "hwa:Status"); + soap_out_hwa__PT_USCORESTATUS(soap, "hwa:Status", -1, &(((_hwa__EnumerateAssetTypesResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "hwa:Count", -1, &(((_hwa__EnumerateAssetTypesResponse*)a)->Count), ""); + soap_out_PointerTohwa__AssetTypeArrayType(soap, "hwa:AssetTypes", -1, &(((_hwa__EnumerateAssetTypesResponse*)a)->AssetTypes), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_hwa__EnumerateAssetTypesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__hwa__EnumerateAssetTypesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse * SOAP_FMAC4 soap_get__hwa__EnumerateAssetTypesResponse(struct soap *soap, _hwa__EnumerateAssetTypesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__hwa__EnumerateAssetTypesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_hwa__EnumerateAssetTypesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__hwa__EnumerateAssetTypesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse * SOAP_FMAC4 soap_in__hwa__EnumerateAssetTypesResponse(struct soap *soap, const char *tag, _hwa__EnumerateAssetTypesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_hwa__EnumerateAssetTypesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__hwa__EnumerateAssetTypesResponse, sizeof(_hwa__EnumerateAssetTypesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__hwa__EnumerateAssetTypesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_hwa__EnumerateAssetTypesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Count1 = 1, soap_flag_AssetTypes1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCORESTATUS(soap, "hwa:Status", &(((_hwa__EnumerateAssetTypesResponse*)a)->Status), "hwa:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Count1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:Count", &(((_hwa__EnumerateAssetTypesResponse*)a)->Count), "xsd:unsignedInt")) + { soap_flag_Count1--; + continue; + } + if (soap_flag_AssetTypes1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTohwa__AssetTypeArrayType(soap, "hwa:AssetTypes", &(((_hwa__EnumerateAssetTypesResponse*)a)->AssetTypes), "hwa:AssetTypeArrayType")) + { soap_flag_AssetTypes1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "hwa:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Count1 > 0 || soap_flag_AssetTypes1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_hwa__EnumerateAssetTypesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__hwa__EnumerateAssetTypesResponse, 0, sizeof(_hwa__EnumerateAssetTypesResponse), 0, soap_copy__hwa__EnumerateAssetTypesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _hwa__EnumerateAssetTypesResponse * SOAP_FMAC6 soap_new__hwa__EnumerateAssetTypesResponse(struct soap *soap, int n) +{ return soap_instantiate__hwa__EnumerateAssetTypesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__hwa__EnumerateAssetTypesResponse(struct soap *soap, _hwa__EnumerateAssetTypesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse * SOAP_FMAC4 soap_instantiate__hwa__EnumerateAssetTypesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__hwa__EnumerateAssetTypesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__hwa__EnumerateAssetTypesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _hwa__EnumerateAssetTypesResponse; + if (size) + *size = sizeof(_hwa__EnumerateAssetTypesResponse); + ((_hwa__EnumerateAssetTypesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _hwa__EnumerateAssetTypesResponse[n]; + if (size) + *size = n * sizeof(_hwa__EnumerateAssetTypesResponse); + for (int i = 0; i < n; i++) + ((_hwa__EnumerateAssetTypesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_hwa__EnumerateAssetTypesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__hwa__EnumerateAssetTypesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _hwa__EnumerateAssetTypesResponse %p -> %p\n", q, p)); + *(_hwa__EnumerateAssetTypesResponse*)p = *(_hwa__EnumerateAssetTypesResponse*)q; +} + +void _hwa__EnumerateAssetTypes::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _hwa__EnumerateAssetTypes::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _hwa__EnumerateAssetTypes::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__hwa__EnumerateAssetTypes); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _hwa__EnumerateAssetTypes::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__hwa__EnumerateAssetTypes(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__hwa__EnumerateAssetTypes(struct soap *soap, const char *tag, int id, const _hwa__EnumerateAssetTypes *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__hwa__EnumerateAssetTypes), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_hwa__EnumerateAssetTypes::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__hwa__EnumerateAssetTypes(soap, this, tag, type); +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_get__hwa__EnumerateAssetTypes(struct soap *soap, _hwa__EnumerateAssetTypes *p, const char *tag, const char *type) +{ + if ((p = soap_in__hwa__EnumerateAssetTypes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_hwa__EnumerateAssetTypes::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__hwa__EnumerateAssetTypes(soap, tag, this, type); +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_in__hwa__EnumerateAssetTypes(struct soap *soap, const char *tag, _hwa__EnumerateAssetTypes *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_hwa__EnumerateAssetTypes *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__hwa__EnumerateAssetTypes, sizeof(_hwa__EnumerateAssetTypes), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__hwa__EnumerateAssetTypes) + { soap_revert(soap); + *soap->id = '\0'; + return (_hwa__EnumerateAssetTypes *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_hwa__EnumerateAssetTypes *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__hwa__EnumerateAssetTypes, 0, sizeof(_hwa__EnumerateAssetTypes), 0, soap_copy__hwa__EnumerateAssetTypes); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _hwa__EnumerateAssetTypes * SOAP_FMAC6 soap_new__hwa__EnumerateAssetTypes(struct soap *soap, int n) +{ return soap_instantiate__hwa__EnumerateAssetTypes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__hwa__EnumerateAssetTypes(struct soap *soap, _hwa__EnumerateAssetTypes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_instantiate__hwa__EnumerateAssetTypes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__hwa__EnumerateAssetTypes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__hwa__EnumerateAssetTypes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _hwa__EnumerateAssetTypes; + if (size) + *size = sizeof(_hwa__EnumerateAssetTypes); + ((_hwa__EnumerateAssetTypes*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _hwa__EnumerateAssetTypes[n]; + if (size) + *size = n * sizeof(_hwa__EnumerateAssetTypes); + for (int i = 0; i < n; i++) + ((_hwa__EnumerateAssetTypes*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_hwa__EnumerateAssetTypes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__hwa__EnumerateAssetTypes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _hwa__EnumerateAssetTypes %p -> %p\n", q, p)); + *(_hwa__EnumerateAssetTypes*)p = *(_hwa__EnumerateAssetTypes*)q; +} + +void hwa__PT_USCOREMEDIA_USCOREDEVICE::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->StructureVersion, SOAP_TYPE_unsignedInt); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->ModelNumber); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->SerialNumber); + soap_serialize_std__vectorTemplateOfunsignedShort(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->Capabilities); + soap_serialize_std__vectorTemplateOfunsignedInt(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->MaxMediaSize); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->Padding); + /* transient soap skipped */ +} + +void hwa__PT_USCOREMEDIA_USCOREDEVICE::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->StructureVersion); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->ModelNumber); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->SerialNumber); + soap_default_std__vectorTemplateOfunsignedShort(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->Capabilities); + soap_default_std__vectorTemplateOfunsignedInt(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->MaxMediaSize); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEDIA_USCOREDEVICE*)this)->Padding); + /* transient soap skipped */ +} + +int hwa__PT_USCOREMEDIA_USCOREDEVICE::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__PT_USCOREMEDIA_USCOREDEVICE::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__PT_USCOREMEDIA_USCOREDEVICE(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap *soap, const char *tag, int id, const hwa__PT_USCOREMEDIA_USCOREDEVICE *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE), type); + soap_out_unsignedInt(soap, "hwa:StructureVersion", -1, &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->StructureVersion), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:ModelNumber", -1, &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->ModelNumber), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:SerialNumber", -1, &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->SerialNumber), ""); + soap_out_std__vectorTemplateOfunsignedShort(soap, "hwa:Capabilities", -1, &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->Capabilities), ""); + soap_out_std__vectorTemplateOfunsignedInt(soap, "hwa:MaxMediaSize", -1, &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->MaxMediaSize), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Padding", -1, &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->Padding), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__PT_USCOREMEDIA_USCOREDEVICE::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__PT_USCOREMEDIA_USCOREDEVICE(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__PT_USCOREMEDIA_USCOREDEVICE * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap *soap, hwa__PT_USCOREMEDIA_USCOREDEVICE *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREMEDIA_USCOREDEVICE(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__PT_USCOREMEDIA_USCOREDEVICE::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__PT_USCOREMEDIA_USCOREDEVICE(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__PT_USCOREMEDIA_USCOREDEVICE * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap *soap, const char *tag, hwa__PT_USCOREMEDIA_USCOREDEVICE *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__PT_USCOREMEDIA_USCOREDEVICE *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE, sizeof(hwa__PT_USCOREMEDIA_USCOREDEVICE), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__PT_USCOREMEDIA_USCOREDEVICE *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StructureVersion1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StructureVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:StructureVersion", &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->StructureVersion), "xsd:unsignedInt")) + { soap_flag_StructureVersion1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:ModelNumber", &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->ModelNumber), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:SerialNumber", &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->SerialNumber), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedShort(soap, "hwa:Capabilities", &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->Capabilities), "xsd:unsignedShort")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedInt(soap, "hwa:MaxMediaSize", &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->MaxMediaSize), "xsd:unsignedInt")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Padding", &(((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->Padding), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StructureVersion1 > 0 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->ModelNumber.size() < 40 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->ModelNumber.size() > 40 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->SerialNumber.size() < 20 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->SerialNumber.size() > 20 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->Capabilities.size() < 3 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->Capabilities.size() > 3 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->MaxMediaSize.size() < 2 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->MaxMediaSize.size() > 2 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->Padding.size() < 2 || ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)a)->Padding.size() > 2)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__PT_USCOREMEDIA_USCOREDEVICE *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE, 0, sizeof(hwa__PT_USCOREMEDIA_USCOREDEVICE), 0, soap_copy_hwa__PT_USCOREMEDIA_USCOREDEVICE); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__PT_USCOREMEDIA_USCOREDEVICE * SOAP_FMAC6 soap_new_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap *soap, int n) +{ return soap_instantiate_hwa__PT_USCOREMEDIA_USCOREDEVICE(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap *soap, hwa__PT_USCOREMEDIA_USCOREDEVICE *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__PT_USCOREMEDIA_USCOREDEVICE * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__PT_USCOREMEDIA_USCOREDEVICE(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__PT_USCOREMEDIA_USCOREDEVICE, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__PT_USCOREMEDIA_USCOREDEVICE; + if (size) + *size = sizeof(hwa__PT_USCOREMEDIA_USCOREDEVICE); + ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__PT_USCOREMEDIA_USCOREDEVICE[n]; + if (size) + *size = n * sizeof(hwa__PT_USCOREMEDIA_USCOREDEVICE); + for (int i = 0; i < n; i++) + ((hwa__PT_USCOREMEDIA_USCOREDEVICE*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__PT_USCOREMEDIA_USCOREDEVICE*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREMEDIA_USCOREDEVICE(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__PT_USCOREMEDIA_USCOREDEVICE %p -> %p\n", q, p)); + *(hwa__PT_USCOREMEDIA_USCOREDEVICE*)p = *(hwa__PT_USCOREMEDIA_USCOREDEVICE*)q; +} + +void hwa__PT_USCOREFRU::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->StructureVersion, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->VendorID, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->DeviceID, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->RevisionID, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->ProgIf, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->Subclass, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->BaseClass, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->SubvendorID, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->SubsystemID, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((hwa__PT_USCOREFRU*)this)->DeviceLocation, SOAP_TYPE_unsignedShort); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREFRU*)this)->Padding); + /* transient soap skipped */ +} + +void hwa__PT_USCOREFRU::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((hwa__PT_USCOREFRU*)this)->StructureVersion); + soap_default_unsignedShort(soap, &((hwa__PT_USCOREFRU*)this)->VendorID); + soap_default_unsignedShort(soap, &((hwa__PT_USCOREFRU*)this)->DeviceID); + soap_default_unsignedByte(soap, &((hwa__PT_USCOREFRU*)this)->RevisionID); + soap_default_unsignedByte(soap, &((hwa__PT_USCOREFRU*)this)->ProgIf); + soap_default_unsignedByte(soap, &((hwa__PT_USCOREFRU*)this)->Subclass); + soap_default_unsignedByte(soap, &((hwa__PT_USCOREFRU*)this)->BaseClass); + soap_default_unsignedShort(soap, &((hwa__PT_USCOREFRU*)this)->SubvendorID); + soap_default_unsignedShort(soap, &((hwa__PT_USCOREFRU*)this)->SubsystemID); + soap_default_unsignedShort(soap, &((hwa__PT_USCOREFRU*)this)->DeviceLocation); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREFRU*)this)->Padding); + /* transient soap skipped */ +} + +int hwa__PT_USCOREFRU::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREFRU); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__PT_USCOREFRU::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__PT_USCOREFRU(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREFRU(struct soap *soap, const char *tag, int id, const hwa__PT_USCOREFRU *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__PT_USCOREFRU), type); + soap_out_unsignedInt(soap, "hwa:StructureVersion", -1, &(((hwa__PT_USCOREFRU*)a)->StructureVersion), ""); + soap_out_unsignedShort(soap, "hwa:VendorID", -1, &(((hwa__PT_USCOREFRU*)a)->VendorID), ""); + soap_out_unsignedShort(soap, "hwa:DeviceID", -1, &(((hwa__PT_USCOREFRU*)a)->DeviceID), ""); + soap_out_unsignedByte(soap, "hwa:RevisionID", -1, &(((hwa__PT_USCOREFRU*)a)->RevisionID), ""); + soap_out_unsignedByte(soap, "hwa:ProgIf", -1, &(((hwa__PT_USCOREFRU*)a)->ProgIf), ""); + soap_out_unsignedByte(soap, "hwa:Subclass", -1, &(((hwa__PT_USCOREFRU*)a)->Subclass), ""); + soap_out_unsignedByte(soap, "hwa:BaseClass", -1, &(((hwa__PT_USCOREFRU*)a)->BaseClass), ""); + soap_out_unsignedShort(soap, "hwa:SubvendorID", -1, &(((hwa__PT_USCOREFRU*)a)->SubvendorID), ""); + soap_out_unsignedShort(soap, "hwa:SubsystemID", -1, &(((hwa__PT_USCOREFRU*)a)->SubsystemID), ""); + soap_out_unsignedShort(soap, "hwa:DeviceLocation", -1, &(((hwa__PT_USCOREFRU*)a)->DeviceLocation), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Padding", -1, &(((hwa__PT_USCOREFRU*)a)->Padding), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__PT_USCOREFRU::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__PT_USCOREFRU(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__PT_USCOREFRU * SOAP_FMAC4 soap_get_hwa__PT_USCOREFRU(struct soap *soap, hwa__PT_USCOREFRU *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREFRU(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__PT_USCOREFRU::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__PT_USCOREFRU(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__PT_USCOREFRU * SOAP_FMAC4 soap_in_hwa__PT_USCOREFRU(struct soap *soap, const char *tag, hwa__PT_USCOREFRU *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__PT_USCOREFRU *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__PT_USCOREFRU, sizeof(hwa__PT_USCOREFRU), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__PT_USCOREFRU) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__PT_USCOREFRU *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StructureVersion1 = 1, soap_flag_VendorID1 = 1, soap_flag_DeviceID1 = 1, soap_flag_RevisionID1 = 1, soap_flag_ProgIf1 = 1, soap_flag_Subclass1 = 1, soap_flag_BaseClass1 = 1, soap_flag_SubvendorID1 = 1, soap_flag_SubsystemID1 = 1, soap_flag_DeviceLocation1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StructureVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:StructureVersion", &(((hwa__PT_USCOREFRU*)a)->StructureVersion), "xsd:unsignedInt")) + { soap_flag_StructureVersion1--; + continue; + } + if (soap_flag_VendorID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "hwa:VendorID", &(((hwa__PT_USCOREFRU*)a)->VendorID), "xsd:unsignedShort")) + { soap_flag_VendorID1--; + continue; + } + if (soap_flag_DeviceID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "hwa:DeviceID", &(((hwa__PT_USCOREFRU*)a)->DeviceID), "xsd:unsignedShort")) + { soap_flag_DeviceID1--; + continue; + } + if (soap_flag_RevisionID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "hwa:RevisionID", &(((hwa__PT_USCOREFRU*)a)->RevisionID), "xsd:unsignedByte")) + { soap_flag_RevisionID1--; + continue; + } + if (soap_flag_ProgIf1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "hwa:ProgIf", &(((hwa__PT_USCOREFRU*)a)->ProgIf), "xsd:unsignedByte")) + { soap_flag_ProgIf1--; + continue; + } + if (soap_flag_Subclass1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "hwa:Subclass", &(((hwa__PT_USCOREFRU*)a)->Subclass), "xsd:unsignedByte")) + { soap_flag_Subclass1--; + continue; + } + if (soap_flag_BaseClass1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "hwa:BaseClass", &(((hwa__PT_USCOREFRU*)a)->BaseClass), "xsd:unsignedByte")) + { soap_flag_BaseClass1--; + continue; + } + if (soap_flag_SubvendorID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "hwa:SubvendorID", &(((hwa__PT_USCOREFRU*)a)->SubvendorID), "xsd:unsignedShort")) + { soap_flag_SubvendorID1--; + continue; + } + if (soap_flag_SubsystemID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "hwa:SubsystemID", &(((hwa__PT_USCOREFRU*)a)->SubsystemID), "xsd:unsignedShort")) + { soap_flag_SubsystemID1--; + continue; + } + if (soap_flag_DeviceLocation1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "hwa:DeviceLocation", &(((hwa__PT_USCOREFRU*)a)->DeviceLocation), "xsd:unsignedShort")) + { soap_flag_DeviceLocation1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Padding", &(((hwa__PT_USCOREFRU*)a)->Padding), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StructureVersion1 > 0 || soap_flag_VendorID1 > 0 || soap_flag_DeviceID1 > 0 || soap_flag_RevisionID1 > 0 || soap_flag_ProgIf1 > 0 || soap_flag_Subclass1 > 0 || soap_flag_BaseClass1 > 0 || soap_flag_SubvendorID1 > 0 || soap_flag_SubsystemID1 > 0 || soap_flag_DeviceLocation1 > 0 || ((hwa__PT_USCOREFRU*)a)->Padding.size() < 2 || ((hwa__PT_USCOREFRU*)a)->Padding.size() > 2)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__PT_USCOREFRU *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__PT_USCOREFRU, 0, sizeof(hwa__PT_USCOREFRU), 0, soap_copy_hwa__PT_USCOREFRU); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__PT_USCOREFRU * SOAP_FMAC6 soap_new_hwa__PT_USCOREFRU(struct soap *soap, int n) +{ return soap_instantiate_hwa__PT_USCOREFRU(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREFRU(struct soap *soap, hwa__PT_USCOREFRU *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__PT_USCOREFRU * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREFRU(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__PT_USCOREFRU(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__PT_USCOREFRU, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__PT_USCOREFRU; + if (size) + *size = sizeof(hwa__PT_USCOREFRU); + ((hwa__PT_USCOREFRU*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__PT_USCOREFRU[n]; + if (size) + *size = n * sizeof(hwa__PT_USCOREFRU); + for (int i = 0; i < n; i++) + ((hwa__PT_USCOREFRU*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__PT_USCOREFRU*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREFRU(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__PT_USCOREFRU %p -> %p\n", q, p)); + *(hwa__PT_USCOREFRU*)p = *(hwa__PT_USCOREFRU*)q; +} + +void hwa__PT_USCOREMEMORY_USCOREMODULE::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->StructureVersion, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->Size, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->Speed, SOAP_TYPE_unsignedShort); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->Manufacturer); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->SerialNumber); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->AssetTag); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->PartNumber); + /* transient soap skipped */ +} + +void hwa__PT_USCOREMEMORY_USCOREMODULE::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->StructureVersion); + soap_default_unsignedShort(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->Size); + soap_default_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->FormFactor); + soap_default_hwa__PT_USCOREMEMORY_USCORETYPE(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->Type); + soap_default_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->TypeDetail); + soap_default_unsignedShort(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->Speed); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->Manufacturer); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->SerialNumber); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->AssetTag); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREMEMORY_USCOREMODULE*)this)->PartNumber); + /* transient soap skipped */ +} + +int hwa__PT_USCOREMEMORY_USCOREMODULE::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__PT_USCOREMEMORY_USCOREMODULE::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__PT_USCOREMEMORY_USCOREMODULE(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap *soap, const char *tag, int id, const hwa__PT_USCOREMEMORY_USCOREMODULE *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE), type); + soap_out_unsignedInt(soap, "hwa:StructureVersion", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->StructureVersion), ""); + soap_out_unsignedShort(soap, "hwa:Size", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Size), ""); + soap_out_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(soap, "hwa:FormFactor", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->FormFactor), ""); + soap_out_hwa__PT_USCOREMEMORY_USCORETYPE(soap, "hwa:Type", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Type), ""); + soap_out_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(soap, "hwa:TypeDetail", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->TypeDetail), ""); + soap_out_unsignedShort(soap, "hwa:Speed", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Speed), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Manufacturer", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Manufacturer), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:SerialNumber", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->SerialNumber), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:AssetTag", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->AssetTag), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:PartNumber", -1, &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->PartNumber), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__PT_USCOREMEMORY_USCOREMODULE::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__PT_USCOREMEMORY_USCOREMODULE(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__PT_USCOREMEMORY_USCOREMODULE * SOAP_FMAC4 soap_get_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap *soap, hwa__PT_USCOREMEMORY_USCOREMODULE *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREMEMORY_USCOREMODULE(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__PT_USCOREMEMORY_USCOREMODULE::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__PT_USCOREMEMORY_USCOREMODULE(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__PT_USCOREMEMORY_USCOREMODULE * SOAP_FMAC4 soap_in_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap *soap, const char *tag, hwa__PT_USCOREMEMORY_USCOREMODULE *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__PT_USCOREMEMORY_USCOREMODULE *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE, sizeof(hwa__PT_USCOREMEMORY_USCOREMODULE), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__PT_USCOREMEMORY_USCOREMODULE *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StructureVersion1 = 1, soap_flag_Size1 = 1, soap_flag_FormFactor1 = 1, soap_flag_Type1 = 1, soap_flag_TypeDetail1 = 1, soap_flag_Speed1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StructureVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:StructureVersion", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->StructureVersion), "xsd:unsignedInt")) + { soap_flag_StructureVersion1--; + continue; + } + if (soap_flag_Size1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "hwa:Size", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Size), "xsd:unsignedShort")) + { soap_flag_Size1--; + continue; + } + if (soap_flag_FormFactor1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCOREMEMORY_USCOREFORM_USCOREFACTOR(soap, "hwa:FormFactor", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->FormFactor), "hwa:PT_MEMORY_FORM_FACTOR")) + { soap_flag_FormFactor1--; + continue; + } + if (soap_flag_Type1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCOREMEMORY_USCORETYPE(soap, "hwa:Type", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Type), "hwa:PT_MEMORY_TYPE")) + { soap_flag_Type1--; + continue; + } + if (soap_flag_TypeDetail1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCOREMEMORY_USCORETYPE_USCOREDETAIL(soap, "hwa:TypeDetail", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->TypeDetail), "hwa:PT_MEMORY_TYPE_DETAIL")) + { soap_flag_TypeDetail1--; + continue; + } + if (soap_flag_Speed1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "hwa:Speed", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Speed), "xsd:unsignedShort")) + { soap_flag_Speed1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Manufacturer", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Manufacturer), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:SerialNumber", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->SerialNumber), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:AssetTag", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->AssetTag), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:PartNumber", &(((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->PartNumber), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StructureVersion1 > 0 || soap_flag_Size1 > 0 || soap_flag_FormFactor1 > 0 || soap_flag_Type1 > 0 || soap_flag_TypeDetail1 > 0 || soap_flag_Speed1 > 0 || ((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Manufacturer.size() < 65 || ((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->Manufacturer.size() > 65 || ((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->SerialNumber.size() < 65 || ((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->SerialNumber.size() > 65 || ((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->AssetTag.size() < 65 || ((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->AssetTag.size() > 65 || ((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->PartNumber.size() < 65 || ((hwa__PT_USCOREMEMORY_USCOREMODULE*)a)->PartNumber.size() > 65)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__PT_USCOREMEMORY_USCOREMODULE *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE, 0, sizeof(hwa__PT_USCOREMEMORY_USCOREMODULE), 0, soap_copy_hwa__PT_USCOREMEMORY_USCOREMODULE); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__PT_USCOREMEMORY_USCOREMODULE * SOAP_FMAC6 soap_new_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap *soap, int n) +{ return soap_instantiate_hwa__PT_USCOREMEMORY_USCOREMODULE(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap *soap, hwa__PT_USCOREMEMORY_USCOREMODULE *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__PT_USCOREMEMORY_USCOREMODULE * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__PT_USCOREMEMORY_USCOREMODULE(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__PT_USCOREMEMORY_USCOREMODULE, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__PT_USCOREMEMORY_USCOREMODULE; + if (size) + *size = sizeof(hwa__PT_USCOREMEMORY_USCOREMODULE); + ((hwa__PT_USCOREMEMORY_USCOREMODULE*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__PT_USCOREMEMORY_USCOREMODULE[n]; + if (size) + *size = n * sizeof(hwa__PT_USCOREMEMORY_USCOREMODULE); + for (int i = 0; i < n; i++) + ((hwa__PT_USCOREMEMORY_USCOREMODULE*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__PT_USCOREMEMORY_USCOREMODULE*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREMEMORY_USCOREMODULE(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__PT_USCOREMEMORY_USCOREMODULE %p -> %p\n", q, p)); + *(hwa__PT_USCOREMEMORY_USCOREMODULE*)p = *(hwa__PT_USCOREMEMORY_USCOREMODULE*)q; +} + +void hwa__PT_USCOREPROCESSOR::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((hwa__PT_USCOREPROCESSOR*)this)->StructureVersion, SOAP_TYPE_unsignedInt); + soap_serialize_std__vectorTemplateOfunsignedInt(soap, &((hwa__PT_USCOREPROCESSOR*)this)->ID); + soap_embedded(soap, &((hwa__PT_USCOREPROCESSOR*)this)->MaxSocketSpeed, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((hwa__PT_USCOREPROCESSOR*)this)->CurrentSpeed, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((hwa__PT_USCOREPROCESSOR*)this)->SocketPopluated, SOAP_TYPE_unsignedByte); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREPROCESSOR*)this)->SocketDesignation); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREPROCESSOR*)this)->Manufacturer); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREPROCESSOR*)this)->Version); + /* transient soap skipped */ +} + +void hwa__PT_USCOREPROCESSOR::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((hwa__PT_USCOREPROCESSOR*)this)->StructureVersion); + soap_default_std__vectorTemplateOfunsignedInt(soap, &((hwa__PT_USCOREPROCESSOR*)this)->ID); + soap_default_unsignedShort(soap, &((hwa__PT_USCOREPROCESSOR*)this)->MaxSocketSpeed); + soap_default_unsignedShort(soap, &((hwa__PT_USCOREPROCESSOR*)this)->CurrentSpeed); + soap_default_hwa__PT_USCOREPROCESSOR_USCORESTATUS(soap, &((hwa__PT_USCOREPROCESSOR*)this)->Status); + soap_default_hwa__PT_USCOREPROCESSOR_USCORETYPE(soap, &((hwa__PT_USCOREPROCESSOR*)this)->Type); + soap_default_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(soap, &((hwa__PT_USCOREPROCESSOR*)this)->Family); + soap_default_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(soap, &((hwa__PT_USCOREPROCESSOR*)this)->UpgradeInformation); + soap_default_unsignedByte(soap, &((hwa__PT_USCOREPROCESSOR*)this)->SocketPopluated); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREPROCESSOR*)this)->SocketDesignation); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREPROCESSOR*)this)->Manufacturer); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREPROCESSOR*)this)->Version); + /* transient soap skipped */ +} + +int hwa__PT_USCOREPROCESSOR::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREPROCESSOR); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__PT_USCOREPROCESSOR::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__PT_USCOREPROCESSOR(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREPROCESSOR(struct soap *soap, const char *tag, int id, const hwa__PT_USCOREPROCESSOR *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__PT_USCOREPROCESSOR), type); + soap_out_unsignedInt(soap, "hwa:StructureVersion", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->StructureVersion), ""); + soap_out_std__vectorTemplateOfunsignedInt(soap, "hwa:ID", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->ID), ""); + soap_out_unsignedShort(soap, "hwa:MaxSocketSpeed", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->MaxSocketSpeed), ""); + soap_out_unsignedShort(soap, "hwa:CurrentSpeed", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->CurrentSpeed), ""); + soap_out_hwa__PT_USCOREPROCESSOR_USCORESTATUS(soap, "hwa:Status", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->Status), ""); + soap_out_hwa__PT_USCOREPROCESSOR_USCORETYPE(soap, "hwa:Type", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->Type), ""); + soap_out_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(soap, "hwa:Family", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->Family), ""); + soap_out_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(soap, "hwa:UpgradeInformation", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->UpgradeInformation), ""); + soap_out_unsignedByte(soap, "hwa:SocketPopluated", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->SocketPopluated), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:SocketDesignation", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->SocketDesignation), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Manufacturer", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->Manufacturer), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Version", -1, &(((hwa__PT_USCOREPROCESSOR*)a)->Version), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__PT_USCOREPROCESSOR::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__PT_USCOREPROCESSOR(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__PT_USCOREPROCESSOR * SOAP_FMAC4 soap_get_hwa__PT_USCOREPROCESSOR(struct soap *soap, hwa__PT_USCOREPROCESSOR *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREPROCESSOR(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__PT_USCOREPROCESSOR::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__PT_USCOREPROCESSOR(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__PT_USCOREPROCESSOR * SOAP_FMAC4 soap_in_hwa__PT_USCOREPROCESSOR(struct soap *soap, const char *tag, hwa__PT_USCOREPROCESSOR *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__PT_USCOREPROCESSOR *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__PT_USCOREPROCESSOR, sizeof(hwa__PT_USCOREPROCESSOR), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__PT_USCOREPROCESSOR) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__PT_USCOREPROCESSOR *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StructureVersion1 = 1, soap_flag_MaxSocketSpeed1 = 1, soap_flag_CurrentSpeed1 = 1, soap_flag_Status1 = 1, soap_flag_Type1 = 1, soap_flag_Family1 = 1, soap_flag_UpgradeInformation1 = 1, soap_flag_SocketPopluated1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StructureVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:StructureVersion", &(((hwa__PT_USCOREPROCESSOR*)a)->StructureVersion), "xsd:unsignedInt")) + { soap_flag_StructureVersion1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedInt(soap, "hwa:ID", &(((hwa__PT_USCOREPROCESSOR*)a)->ID), "xsd:unsignedInt")) + continue; + if (soap_flag_MaxSocketSpeed1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "hwa:MaxSocketSpeed", &(((hwa__PT_USCOREPROCESSOR*)a)->MaxSocketSpeed), "xsd:unsignedShort")) + { soap_flag_MaxSocketSpeed1--; + continue; + } + if (soap_flag_CurrentSpeed1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "hwa:CurrentSpeed", &(((hwa__PT_USCOREPROCESSOR*)a)->CurrentSpeed), "xsd:unsignedShort")) + { soap_flag_CurrentSpeed1--; + continue; + } + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCOREPROCESSOR_USCORESTATUS(soap, "hwa:Status", &(((hwa__PT_USCOREPROCESSOR*)a)->Status), "hwa:PT_PROCESSOR_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Type1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCOREPROCESSOR_USCORETYPE(soap, "hwa:Type", &(((hwa__PT_USCOREPROCESSOR*)a)->Type), "hwa:PT_PROCESSOR_TYPE")) + { soap_flag_Type1--; + continue; + } + if (soap_flag_Family1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCOREPROCESSOR_USCOREFAMILY(soap, "hwa:Family", &(((hwa__PT_USCOREPROCESSOR*)a)->Family), "hwa:PT_PROCESSOR_FAMILY")) + { soap_flag_Family1--; + continue; + } + if (soap_flag_UpgradeInformation1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCOREPROCESSOR_USCOREUPGRADE(soap, "hwa:UpgradeInformation", &(((hwa__PT_USCOREPROCESSOR*)a)->UpgradeInformation), "hwa:PT_PROCESSOR_UPGRADE")) + { soap_flag_UpgradeInformation1--; + continue; + } + if (soap_flag_SocketPopluated1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "hwa:SocketPopluated", &(((hwa__PT_USCOREPROCESSOR*)a)->SocketPopluated), "xsd:unsignedByte")) + { soap_flag_SocketPopluated1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:SocketDesignation", &(((hwa__PT_USCOREPROCESSOR*)a)->SocketDesignation), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Manufacturer", &(((hwa__PT_USCOREPROCESSOR*)a)->Manufacturer), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Version", &(((hwa__PT_USCOREPROCESSOR*)a)->Version), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StructureVersion1 > 0 || ((hwa__PT_USCOREPROCESSOR*)a)->ID.size() < 2 || ((hwa__PT_USCOREPROCESSOR*)a)->ID.size() > 2 || soap_flag_MaxSocketSpeed1 > 0 || soap_flag_CurrentSpeed1 > 0 || soap_flag_Status1 > 0 || soap_flag_Type1 > 0 || soap_flag_Family1 > 0 || soap_flag_UpgradeInformation1 > 0 || soap_flag_SocketPopluated1 > 0 || ((hwa__PT_USCOREPROCESSOR*)a)->SocketDesignation.size() < 65 || ((hwa__PT_USCOREPROCESSOR*)a)->SocketDesignation.size() > 65 || ((hwa__PT_USCOREPROCESSOR*)a)->Manufacturer.size() < 65 || ((hwa__PT_USCOREPROCESSOR*)a)->Manufacturer.size() > 65 || ((hwa__PT_USCOREPROCESSOR*)a)->Version.size() < 65 || ((hwa__PT_USCOREPROCESSOR*)a)->Version.size() > 65)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__PT_USCOREPROCESSOR *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__PT_USCOREPROCESSOR, 0, sizeof(hwa__PT_USCOREPROCESSOR), 0, soap_copy_hwa__PT_USCOREPROCESSOR); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__PT_USCOREPROCESSOR * SOAP_FMAC6 soap_new_hwa__PT_USCOREPROCESSOR(struct soap *soap, int n) +{ return soap_instantiate_hwa__PT_USCOREPROCESSOR(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREPROCESSOR(struct soap *soap, hwa__PT_USCOREPROCESSOR *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__PT_USCOREPROCESSOR * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREPROCESSOR(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__PT_USCOREPROCESSOR(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__PT_USCOREPROCESSOR, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__PT_USCOREPROCESSOR; + if (size) + *size = sizeof(hwa__PT_USCOREPROCESSOR); + ((hwa__PT_USCOREPROCESSOR*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__PT_USCOREPROCESSOR[n]; + if (size) + *size = n * sizeof(hwa__PT_USCOREPROCESSOR); + for (int i = 0; i < n; i++) + ((hwa__PT_USCOREPROCESSOR*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__PT_USCOREPROCESSOR*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREPROCESSOR(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__PT_USCOREPROCESSOR %p -> %p\n", q, p)); + *(hwa__PT_USCOREPROCESSOR*)p = *(hwa__PT_USCOREPROCESSOR*)q; +} + +void hwa__PT_USCOREBASEBOARD::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((hwa__PT_USCOREBASEBOARD*)this)->StructureVersion, SOAP_TYPE_unsignedInt); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Manufacturer); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Product); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Version); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->SerialNumber); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->AssetTag); + soap_embedded(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Replaceable, SOAP_TYPE_unsignedByte); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Padding); + /* transient soap skipped */ +} + +void hwa__PT_USCOREBASEBOARD::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((hwa__PT_USCOREBASEBOARD*)this)->StructureVersion); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Manufacturer); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Product); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Version); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->SerialNumber); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->AssetTag); + soap_default_unsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Replaceable); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBASEBOARD*)this)->Padding); + /* transient soap skipped */ +} + +int hwa__PT_USCOREBASEBOARD::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREBASEBOARD); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__PT_USCOREBASEBOARD::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__PT_USCOREBASEBOARD(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREBASEBOARD(struct soap *soap, const char *tag, int id, const hwa__PT_USCOREBASEBOARD *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__PT_USCOREBASEBOARD), type); + soap_out_unsignedInt(soap, "hwa:StructureVersion", -1, &(((hwa__PT_USCOREBASEBOARD*)a)->StructureVersion), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Manufacturer", -1, &(((hwa__PT_USCOREBASEBOARD*)a)->Manufacturer), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Product", -1, &(((hwa__PT_USCOREBASEBOARD*)a)->Product), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Version", -1, &(((hwa__PT_USCOREBASEBOARD*)a)->Version), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:SerialNumber", -1, &(((hwa__PT_USCOREBASEBOARD*)a)->SerialNumber), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:AssetTag", -1, &(((hwa__PT_USCOREBASEBOARD*)a)->AssetTag), ""); + soap_out_unsignedByte(soap, "hwa:Replaceable", -1, &(((hwa__PT_USCOREBASEBOARD*)a)->Replaceable), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Padding", -1, &(((hwa__PT_USCOREBASEBOARD*)a)->Padding), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__PT_USCOREBASEBOARD::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__PT_USCOREBASEBOARD(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__PT_USCOREBASEBOARD * SOAP_FMAC4 soap_get_hwa__PT_USCOREBASEBOARD(struct soap *soap, hwa__PT_USCOREBASEBOARD *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREBASEBOARD(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__PT_USCOREBASEBOARD::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__PT_USCOREBASEBOARD(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__PT_USCOREBASEBOARD * SOAP_FMAC4 soap_in_hwa__PT_USCOREBASEBOARD(struct soap *soap, const char *tag, hwa__PT_USCOREBASEBOARD *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__PT_USCOREBASEBOARD *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__PT_USCOREBASEBOARD, sizeof(hwa__PT_USCOREBASEBOARD), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__PT_USCOREBASEBOARD) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__PT_USCOREBASEBOARD *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StructureVersion1 = 1, soap_flag_Replaceable1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StructureVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:StructureVersion", &(((hwa__PT_USCOREBASEBOARD*)a)->StructureVersion), "xsd:unsignedInt")) + { soap_flag_StructureVersion1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Manufacturer", &(((hwa__PT_USCOREBASEBOARD*)a)->Manufacturer), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Product", &(((hwa__PT_USCOREBASEBOARD*)a)->Product), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Version", &(((hwa__PT_USCOREBASEBOARD*)a)->Version), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:SerialNumber", &(((hwa__PT_USCOREBASEBOARD*)a)->SerialNumber), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:AssetTag", &(((hwa__PT_USCOREBASEBOARD*)a)->AssetTag), "xsd:unsignedByte")) + continue; + if (soap_flag_Replaceable1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "hwa:Replaceable", &(((hwa__PT_USCOREBASEBOARD*)a)->Replaceable), "xsd:unsignedByte")) + { soap_flag_Replaceable1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Padding", &(((hwa__PT_USCOREBASEBOARD*)a)->Padding), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StructureVersion1 > 0 || ((hwa__PT_USCOREBASEBOARD*)a)->Manufacturer.size() < 65 || ((hwa__PT_USCOREBASEBOARD*)a)->Manufacturer.size() > 65 || ((hwa__PT_USCOREBASEBOARD*)a)->Product.size() < 65 || ((hwa__PT_USCOREBASEBOARD*)a)->Product.size() > 65 || ((hwa__PT_USCOREBASEBOARD*)a)->Version.size() < 65 || ((hwa__PT_USCOREBASEBOARD*)a)->Version.size() > 65 || ((hwa__PT_USCOREBASEBOARD*)a)->SerialNumber.size() < 65 || ((hwa__PT_USCOREBASEBOARD*)a)->SerialNumber.size() > 65 || ((hwa__PT_USCOREBASEBOARD*)a)->AssetTag.size() < 65 || ((hwa__PT_USCOREBASEBOARD*)a)->AssetTag.size() > 65 || soap_flag_Replaceable1 > 0 || ((hwa__PT_USCOREBASEBOARD*)a)->Padding.size() < 2 || ((hwa__PT_USCOREBASEBOARD*)a)->Padding.size() > 2)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__PT_USCOREBASEBOARD *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__PT_USCOREBASEBOARD, 0, sizeof(hwa__PT_USCOREBASEBOARD), 0, soap_copy_hwa__PT_USCOREBASEBOARD); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__PT_USCOREBASEBOARD * SOAP_FMAC6 soap_new_hwa__PT_USCOREBASEBOARD(struct soap *soap, int n) +{ return soap_instantiate_hwa__PT_USCOREBASEBOARD(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREBASEBOARD(struct soap *soap, hwa__PT_USCOREBASEBOARD *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__PT_USCOREBASEBOARD * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREBASEBOARD(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__PT_USCOREBASEBOARD(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__PT_USCOREBASEBOARD, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__PT_USCOREBASEBOARD; + if (size) + *size = sizeof(hwa__PT_USCOREBASEBOARD); + ((hwa__PT_USCOREBASEBOARD*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__PT_USCOREBASEBOARD[n]; + if (size) + *size = n * sizeof(hwa__PT_USCOREBASEBOARD); + for (int i = 0; i < n; i++) + ((hwa__PT_USCOREBASEBOARD*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__PT_USCOREBASEBOARD*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREBASEBOARD(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__PT_USCOREBASEBOARD %p -> %p\n", q, p)); + *(hwa__PT_USCOREBASEBOARD*)p = *(hwa__PT_USCOREBASEBOARD*)q; +} + +void hwa__GUID::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__GUID*)this)->GUIDbyte); + /* transient soap skipped */ +} + +void hwa__GUID::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__GUID*)this)->GUIDbyte); + /* transient soap skipped */ +} + +int hwa__GUID::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__GUID); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__GUID::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__GUID(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__GUID(struct soap *soap, const char *tag, int id, const hwa__GUID *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__GUID), type); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:GUIDbyte", -1, &(((hwa__GUID*)a)->GUIDbyte), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__GUID::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__GUID(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__GUID * SOAP_FMAC4 soap_get_hwa__GUID(struct soap *soap, hwa__GUID *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__GUID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__GUID::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__GUID(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__GUID * SOAP_FMAC4 soap_in_hwa__GUID(struct soap *soap, const char *tag, hwa__GUID *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__GUID *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__GUID, sizeof(hwa__GUID), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__GUID) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__GUID *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:GUIDbyte", &(((hwa__GUID*)a)->GUIDbyte), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((hwa__GUID*)a)->GUIDbyte.size() < 16 || ((hwa__GUID*)a)->GUIDbyte.size() > 16)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__GUID *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__GUID, 0, sizeof(hwa__GUID), 0, soap_copy_hwa__GUID); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__GUID * SOAP_FMAC6 soap_new_hwa__GUID(struct soap *soap, int n) +{ return soap_instantiate_hwa__GUID(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__GUID(struct soap *soap, hwa__GUID *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__GUID * SOAP_FMAC4 soap_instantiate_hwa__GUID(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__GUID(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__GUID, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__GUID; + if (size) + *size = sizeof(hwa__GUID); + ((hwa__GUID*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__GUID[n]; + if (size) + *size = n * sizeof(hwa__GUID); + for (int i = 0; i < n; i++) + ((hwa__GUID*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__GUID*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__GUID(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__GUID %p -> %p\n", q, p)); + *(hwa__GUID*)p = *(hwa__GUID*)q; +} + +void hwa__PT_USCORECOMPUTER_USCORESYSTEM::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->StructureVersion, SOAP_TYPE_unsignedInt); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->Manufacturer); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->Product); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->Version); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->SerialNumber); + soap_serialize_PointerTohwa__GUID(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->UUID); + /* transient soap skipped */ +} + +void hwa__PT_USCORECOMPUTER_USCORESYSTEM::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->StructureVersion); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->Manufacturer); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->Product); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->Version); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->SerialNumber); + ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)this)->UUID = NULL; + /* transient soap skipped */ +} + +int hwa__PT_USCORECOMPUTER_USCORESYSTEM::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__PT_USCORECOMPUTER_USCORESYSTEM::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__PT_USCORECOMPUTER_USCORESYSTEM(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap *soap, const char *tag, int id, const hwa__PT_USCORECOMPUTER_USCORESYSTEM *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM), type); + soap_out_unsignedInt(soap, "hwa:StructureVersion", -1, &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->StructureVersion), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Manufacturer", -1, &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Manufacturer), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Product", -1, &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Product), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Version", -1, &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Version), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:SerialNumber", -1, &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->SerialNumber), ""); + soap_out_PointerTohwa__GUID(soap, "hwa:UUID", -1, &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->UUID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__PT_USCORECOMPUTER_USCORESYSTEM::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__PT_USCORECOMPUTER_USCORESYSTEM(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__PT_USCORECOMPUTER_USCORESYSTEM * SOAP_FMAC4 soap_get_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap *soap, hwa__PT_USCORECOMPUTER_USCORESYSTEM *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCORECOMPUTER_USCORESYSTEM(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__PT_USCORECOMPUTER_USCORESYSTEM::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__PT_USCORECOMPUTER_USCORESYSTEM(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__PT_USCORECOMPUTER_USCORESYSTEM * SOAP_FMAC4 soap_in_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap *soap, const char *tag, hwa__PT_USCORECOMPUTER_USCORESYSTEM *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__PT_USCORECOMPUTER_USCORESYSTEM *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM, sizeof(hwa__PT_USCORECOMPUTER_USCORESYSTEM), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__PT_USCORECOMPUTER_USCORESYSTEM *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StructureVersion1 = 1, soap_flag_UUID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StructureVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:StructureVersion", &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->StructureVersion), "xsd:unsignedInt")) + { soap_flag_StructureVersion1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Manufacturer", &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Manufacturer), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Product", &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Product), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Version", &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Version), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:SerialNumber", &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->SerialNumber), "xsd:unsignedByte")) + continue; + if (soap_flag_UUID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTohwa__GUID(soap, "hwa:UUID", &(((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->UUID), "hwa:GUID")) + { soap_flag_UUID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StructureVersion1 > 0 || ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Manufacturer.size() < 65 || ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Manufacturer.size() > 65 || ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Product.size() < 65 || ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Product.size() > 65 || ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Version.size() < 65 || ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->Version.size() > 65 || ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->SerialNumber.size() < 65 || ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)a)->SerialNumber.size() > 65 || soap_flag_UUID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__PT_USCORECOMPUTER_USCORESYSTEM *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM, 0, sizeof(hwa__PT_USCORECOMPUTER_USCORESYSTEM), 0, soap_copy_hwa__PT_USCORECOMPUTER_USCORESYSTEM); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__PT_USCORECOMPUTER_USCORESYSTEM * SOAP_FMAC6 soap_new_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap *soap, int n) +{ return soap_instantiate_hwa__PT_USCORECOMPUTER_USCORESYSTEM(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap *soap, hwa__PT_USCORECOMPUTER_USCORESYSTEM *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__PT_USCORECOMPUTER_USCORESYSTEM * SOAP_FMAC4 soap_instantiate_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__PT_USCORECOMPUTER_USCORESYSTEM(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__PT_USCORECOMPUTER_USCORESYSTEM, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__PT_USCORECOMPUTER_USCORESYSTEM; + if (size) + *size = sizeof(hwa__PT_USCORECOMPUTER_USCORESYSTEM); + ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__PT_USCORECOMPUTER_USCORESYSTEM[n]; + if (size) + *size = n * sizeof(hwa__PT_USCORECOMPUTER_USCORESYSTEM); + for (int i = 0; i < n; i++) + ((hwa__PT_USCORECOMPUTER_USCORESYSTEM*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__PT_USCORECOMPUTER_USCORESYSTEM*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCORECOMPUTER_USCORESYSTEM(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__PT_USCORECOMPUTER_USCORESYSTEM %p -> %p\n", q, p)); + *(hwa__PT_USCORECOMPUTER_USCORESYSTEM*)p = *(hwa__PT_USCORECOMPUTER_USCORESYSTEM*)q; +} + +void hwa__PT_USCOREBIOS::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((hwa__PT_USCOREBIOS*)this)->StructureVersion, SOAP_TYPE_unsignedInt); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBIOS*)this)->Vendor); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBIOS*)this)->Version); + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBIOS*)this)->ReleaseDate); + soap_embedded(soap, &((hwa__PT_USCOREBIOS*)this)->padding, SOAP_TYPE_unsignedByte); + /* transient soap skipped */ +} + +void hwa__PT_USCOREBIOS::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((hwa__PT_USCOREBIOS*)this)->StructureVersion); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBIOS*)this)->Vendor); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBIOS*)this)->Version); + soap_default_std__vectorTemplateOfunsignedByte(soap, &((hwa__PT_USCOREBIOS*)this)->ReleaseDate); + soap_default_unsignedByte(soap, &((hwa__PT_USCOREBIOS*)this)->padding); + soap_default_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(soap, &((hwa__PT_USCOREBIOS*)this)->Characteristics); + /* transient soap skipped */ +} + +int hwa__PT_USCOREBIOS::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__PT_USCOREBIOS); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__PT_USCOREBIOS::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__PT_USCOREBIOS(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__PT_USCOREBIOS(struct soap *soap, const char *tag, int id, const hwa__PT_USCOREBIOS *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__PT_USCOREBIOS), type); + soap_out_unsignedInt(soap, "hwa:StructureVersion", -1, &(((hwa__PT_USCOREBIOS*)a)->StructureVersion), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Vendor", -1, &(((hwa__PT_USCOREBIOS*)a)->Vendor), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:Version", -1, &(((hwa__PT_USCOREBIOS*)a)->Version), ""); + soap_out_std__vectorTemplateOfunsignedByte(soap, "hwa:ReleaseDate", -1, &(((hwa__PT_USCOREBIOS*)a)->ReleaseDate), ""); + soap_out_unsignedByte(soap, "hwa:padding", -1, &(((hwa__PT_USCOREBIOS*)a)->padding), ""); + soap_out_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(soap, "hwa:Characteristics", -1, &(((hwa__PT_USCOREBIOS*)a)->Characteristics), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__PT_USCOREBIOS::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__PT_USCOREBIOS(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__PT_USCOREBIOS * SOAP_FMAC4 soap_get_hwa__PT_USCOREBIOS(struct soap *soap, hwa__PT_USCOREBIOS *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__PT_USCOREBIOS(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__PT_USCOREBIOS::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__PT_USCOREBIOS(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__PT_USCOREBIOS * SOAP_FMAC4 soap_in_hwa__PT_USCOREBIOS(struct soap *soap, const char *tag, hwa__PT_USCOREBIOS *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__PT_USCOREBIOS *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__PT_USCOREBIOS, sizeof(hwa__PT_USCOREBIOS), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__PT_USCOREBIOS) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__PT_USCOREBIOS *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StructureVersion1 = 1, soap_flag_padding1 = 1, soap_flag_Characteristics1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StructureVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:StructureVersion", &(((hwa__PT_USCOREBIOS*)a)->StructureVersion), "xsd:unsignedInt")) + { soap_flag_StructureVersion1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Vendor", &(((hwa__PT_USCOREBIOS*)a)->Vendor), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:Version", &(((hwa__PT_USCOREBIOS*)a)->Version), "xsd:unsignedByte")) + continue; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "hwa:ReleaseDate", &(((hwa__PT_USCOREBIOS*)a)->ReleaseDate), "xsd:unsignedByte")) + continue; + if (soap_flag_padding1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "hwa:padding", &(((hwa__PT_USCOREBIOS*)a)->padding), "xsd:unsignedByte")) + { soap_flag_padding1--; + continue; + } + if (soap_flag_Characteristics1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__PT_USCOREBIOS_USCORECHARACTERISTICS(soap, "hwa:Characteristics", &(((hwa__PT_USCOREBIOS*)a)->Characteristics), "hwa:PT_BIOS_CHARACTERISTICS")) + { soap_flag_Characteristics1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StructureVersion1 > 0 || ((hwa__PT_USCOREBIOS*)a)->Vendor.size() < 65 || ((hwa__PT_USCOREBIOS*)a)->Vendor.size() > 65 || ((hwa__PT_USCOREBIOS*)a)->Version.size() < 65 || ((hwa__PT_USCOREBIOS*)a)->Version.size() > 65 || ((hwa__PT_USCOREBIOS*)a)->ReleaseDate.size() < 65 || ((hwa__PT_USCOREBIOS*)a)->ReleaseDate.size() > 65 || soap_flag_padding1 > 0 || soap_flag_Characteristics1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__PT_USCOREBIOS *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__PT_USCOREBIOS, 0, sizeof(hwa__PT_USCOREBIOS), 0, soap_copy_hwa__PT_USCOREBIOS); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__PT_USCOREBIOS * SOAP_FMAC6 soap_new_hwa__PT_USCOREBIOS(struct soap *soap, int n) +{ return soap_instantiate_hwa__PT_USCOREBIOS(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__PT_USCOREBIOS(struct soap *soap, hwa__PT_USCOREBIOS *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__PT_USCOREBIOS * SOAP_FMAC4 soap_instantiate_hwa__PT_USCOREBIOS(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__PT_USCOREBIOS(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__PT_USCOREBIOS, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__PT_USCOREBIOS; + if (size) + *size = sizeof(hwa__PT_USCOREBIOS); + ((hwa__PT_USCOREBIOS*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__PT_USCOREBIOS[n]; + if (size) + *size = n * sizeof(hwa__PT_USCOREBIOS); + for (int i = 0; i < n; i++) + ((hwa__PT_USCOREBIOS*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__PT_USCOREBIOS*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__PT_USCOREBIOS(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__PT_USCOREBIOS %p -> %p\n", q, p)); + *(hwa__PT_USCOREBIOS*)p = *(hwa__PT_USCOREBIOS*)q; +} + +void hwa__AssetDataType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((hwa__AssetDataType*)this)->AssetSize, SOAP_TYPE_unsignedInt); + soap_serialize_PointerToxsd__base64Binary(soap, &((hwa__AssetDataType*)this)->AssetData); + /* transient soap skipped */ +} + +void hwa__AssetDataType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_hwa__AssetTypeType(soap, &((hwa__AssetDataType*)this)->AssetType); + soap_default_unsignedInt(soap, &((hwa__AssetDataType*)this)->AssetSize); + ((hwa__AssetDataType*)this)->AssetData = NULL; + /* transient soap skipped */ +} + +int hwa__AssetDataType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__AssetDataType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__AssetDataType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__AssetDataType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__AssetDataType(struct soap *soap, const char *tag, int id, const hwa__AssetDataType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__AssetDataType), type); + soap_out_hwa__AssetTypeType(soap, "hwa:AssetType", -1, &(((hwa__AssetDataType*)a)->AssetType), ""); + soap_out_unsignedInt(soap, "hwa:AssetSize", -1, &(((hwa__AssetDataType*)a)->AssetSize), ""); + soap_out_PointerToxsd__base64Binary(soap, "hwa:AssetData", -1, &(((hwa__AssetDataType*)a)->AssetData), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__AssetDataType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__AssetDataType(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__AssetDataType * SOAP_FMAC4 soap_get_hwa__AssetDataType(struct soap *soap, hwa__AssetDataType *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__AssetDataType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__AssetDataType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__AssetDataType(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__AssetDataType * SOAP_FMAC4 soap_in_hwa__AssetDataType(struct soap *soap, const char *tag, hwa__AssetDataType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__AssetDataType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__AssetDataType, sizeof(hwa__AssetDataType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__AssetDataType) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__AssetDataType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AssetType1 = 1, soap_flag_AssetSize1 = 1, soap_flag_AssetData1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AssetType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_hwa__AssetTypeType(soap, "hwa:AssetType", &(((hwa__AssetDataType*)a)->AssetType), "hwa:AssetTypeType")) + { soap_flag_AssetType1--; + continue; + } + if (soap_flag_AssetSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "hwa:AssetSize", &(((hwa__AssetDataType*)a)->AssetSize), "xsd:unsignedInt")) + { soap_flag_AssetSize1--; + continue; + } + if (soap_flag_AssetData1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxsd__base64Binary(soap, "hwa:AssetData", &(((hwa__AssetDataType*)a)->AssetData), "xsd:base64Binary")) + { soap_flag_AssetData1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AssetType1 > 0 || soap_flag_AssetSize1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__AssetDataType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__AssetDataType, 0, sizeof(hwa__AssetDataType), 0, soap_copy_hwa__AssetDataType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__AssetDataType * SOAP_FMAC6 soap_new_hwa__AssetDataType(struct soap *soap, int n) +{ return soap_instantiate_hwa__AssetDataType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__AssetDataType(struct soap *soap, hwa__AssetDataType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__AssetDataType * SOAP_FMAC4 soap_instantiate_hwa__AssetDataType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__AssetDataType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__AssetDataType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__AssetDataType; + if (size) + *size = sizeof(hwa__AssetDataType); + ((hwa__AssetDataType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__AssetDataType[n]; + if (size) + *size = n * sizeof(hwa__AssetDataType); + for (int i = 0; i < n; i++) + ((hwa__AssetDataType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__AssetDataType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__AssetDataType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__AssetDataType %p -> %p\n", q, p)); + *(hwa__AssetDataType*)p = *(hwa__AssetDataType*)q; +} + +void hwa__AssetDataArrayType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTohwa__AssetDataType(soap, &((hwa__AssetDataArrayType*)this)->AssetData); + /* transient soap skipped */ +} + +void hwa__AssetDataArrayType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfPointerTohwa__AssetDataType(soap, &((hwa__AssetDataArrayType*)this)->AssetData); + /* transient soap skipped */ +} + +int hwa__AssetDataArrayType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__AssetDataArrayType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__AssetDataArrayType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__AssetDataArrayType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__AssetDataArrayType(struct soap *soap, const char *tag, int id, const hwa__AssetDataArrayType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__AssetDataArrayType), type); + soap_out_std__vectorTemplateOfPointerTohwa__AssetDataType(soap, "hwa:AssetData", -1, &(((hwa__AssetDataArrayType*)a)->AssetData), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__AssetDataArrayType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__AssetDataArrayType(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__AssetDataArrayType * SOAP_FMAC4 soap_get_hwa__AssetDataArrayType(struct soap *soap, hwa__AssetDataArrayType *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__AssetDataArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__AssetDataArrayType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__AssetDataArrayType(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__AssetDataArrayType * SOAP_FMAC4 soap_in_hwa__AssetDataArrayType(struct soap *soap, const char *tag, hwa__AssetDataArrayType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__AssetDataArrayType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__AssetDataArrayType, sizeof(hwa__AssetDataArrayType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__AssetDataArrayType) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__AssetDataArrayType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTohwa__AssetDataType(soap, "hwa:AssetData", &(((hwa__AssetDataArrayType*)a)->AssetData), "hwa:AssetDataType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__AssetDataArrayType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__AssetDataArrayType, 0, sizeof(hwa__AssetDataArrayType), 0, soap_copy_hwa__AssetDataArrayType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__AssetDataArrayType * SOAP_FMAC6 soap_new_hwa__AssetDataArrayType(struct soap *soap, int n) +{ return soap_instantiate_hwa__AssetDataArrayType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__AssetDataArrayType(struct soap *soap, hwa__AssetDataArrayType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__AssetDataArrayType * SOAP_FMAC4 soap_instantiate_hwa__AssetDataArrayType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__AssetDataArrayType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__AssetDataArrayType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__AssetDataArrayType; + if (size) + *size = sizeof(hwa__AssetDataArrayType); + ((hwa__AssetDataArrayType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__AssetDataArrayType[n]; + if (size) + *size = n * sizeof(hwa__AssetDataArrayType); + for (int i = 0; i < n; i++) + ((hwa__AssetDataArrayType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__AssetDataArrayType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__AssetDataArrayType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__AssetDataArrayType %p -> %p\n", q, p)); + *(hwa__AssetDataArrayType*)p = *(hwa__AssetDataArrayType*)q; +} + +void hwa__AssetTypeArrayType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfhwa__AssetTypeType(soap, &((hwa__AssetTypeArrayType*)this)->AssetType); + /* transient soap skipped */ +} + +void hwa__AssetTypeArrayType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfhwa__AssetTypeType(soap, &((hwa__AssetTypeArrayType*)this)->AssetType); + /* transient soap skipped */ +} + +int hwa__AssetTypeArrayType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_hwa__AssetTypeArrayType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int hwa__AssetTypeArrayType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_hwa__AssetTypeArrayType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_hwa__AssetTypeArrayType(struct soap *soap, const char *tag, int id, const hwa__AssetTypeArrayType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_hwa__AssetTypeArrayType), type); + soap_out_std__vectorTemplateOfhwa__AssetTypeType(soap, "hwa:AssetType", -1, &(((hwa__AssetTypeArrayType*)a)->AssetType), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *hwa__AssetTypeArrayType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_hwa__AssetTypeArrayType(soap, this, tag, type); +} + +SOAP_FMAC3 hwa__AssetTypeArrayType * SOAP_FMAC4 soap_get_hwa__AssetTypeArrayType(struct soap *soap, hwa__AssetTypeArrayType *p, const char *tag, const char *type) +{ + if ((p = soap_in_hwa__AssetTypeArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *hwa__AssetTypeArrayType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_hwa__AssetTypeArrayType(soap, tag, this, type); +} + +SOAP_FMAC3 hwa__AssetTypeArrayType * SOAP_FMAC4 soap_in_hwa__AssetTypeArrayType(struct soap *soap, const char *tag, hwa__AssetTypeArrayType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (hwa__AssetTypeArrayType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_hwa__AssetTypeArrayType, sizeof(hwa__AssetTypeArrayType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_hwa__AssetTypeArrayType) + { soap_revert(soap); + *soap->id = '\0'; + return (hwa__AssetTypeArrayType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfhwa__AssetTypeType(soap, "hwa:AssetType", &(((hwa__AssetTypeArrayType*)a)->AssetType), "hwa:AssetTypeType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (hwa__AssetTypeArrayType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_hwa__AssetTypeArrayType, 0, sizeof(hwa__AssetTypeArrayType), 0, soap_copy_hwa__AssetTypeArrayType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 hwa__AssetTypeArrayType * SOAP_FMAC6 soap_new_hwa__AssetTypeArrayType(struct soap *soap, int n) +{ return soap_instantiate_hwa__AssetTypeArrayType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_hwa__AssetTypeArrayType(struct soap *soap, hwa__AssetTypeArrayType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 hwa__AssetTypeArrayType * SOAP_FMAC4 soap_instantiate_hwa__AssetTypeArrayType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_hwa__AssetTypeArrayType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_hwa__AssetTypeArrayType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new hwa__AssetTypeArrayType; + if (size) + *size = sizeof(hwa__AssetTypeArrayType); + ((hwa__AssetTypeArrayType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new hwa__AssetTypeArrayType[n]; + if (size) + *size = n * sizeof(hwa__AssetTypeArrayType); + for (int i = 0; i < n; i++) + ((hwa__AssetTypeArrayType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (hwa__AssetTypeArrayType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_hwa__AssetTypeArrayType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying hwa__AssetTypeArrayType %p -> %p\n", q, p)); + *(hwa__AssetTypeArrayType*)p = *(hwa__AssetTypeArrayType*)q; +} + +void _cb__GetHcbStateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__GetHcbStateResponse*)this)->BlockedAll, SOAP_TYPE_bool); + soap_serialize_PointerTocb__TimeType(soap, &((_cb__GetHcbStateResponse*)this)->TimeStamp); + soap_serialize_PointerTocb__HcbTriggerReasonType(soap, &((_cb__GetHcbStateResponse*)this)->HcbTriggerReason); + soap_serialize_PointerTocb__BlockedPortInfoType(soap, &((_cb__GetHcbStateResponse*)this)->BlockedPortInfo); + soap_serialize_PointerTounsignedInt(soap, &((_cb__GetHcbStateResponse*)this)->EnabledCbPolicy); + /* transient soap skipped */ +} + +void _cb__GetHcbStateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_cb__GetHcbStateResponse*)this)->Status); + soap_default_cb__HcbStateType(soap, &((_cb__GetHcbStateResponse*)this)->HcbState); + soap_default_bool(soap, &((_cb__GetHcbStateResponse*)this)->BlockedAll); + ((_cb__GetHcbStateResponse*)this)->TimeStamp = NULL; + ((_cb__GetHcbStateResponse*)this)->HcbTriggerReason = NULL; + ((_cb__GetHcbStateResponse*)this)->BlockedPortInfo = NULL; + ((_cb__GetHcbStateResponse*)this)->EnabledCbPolicy = NULL; + /* transient soap skipped */ +} + +int _cb__GetHcbStateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__GetHcbStateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__GetHcbStateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__GetHcbStateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__GetHcbStateResponse(struct soap *soap, const char *tag, int id, const _cb__GetHcbStateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__GetHcbStateResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__GetHcbStateResponse*)a)->Status), ""); + soap_out_cb__HcbStateType(soap, "cb:HcbState", -1, &(((_cb__GetHcbStateResponse*)a)->HcbState), ""); + soap_out_bool(soap, "cb:BlockedAll", -1, &(((_cb__GetHcbStateResponse*)a)->BlockedAll), ""); + soap_out_PointerTocb__TimeType(soap, "cb:TimeStamp", -1, &(((_cb__GetHcbStateResponse*)a)->TimeStamp), ""); + soap_out_PointerTocb__HcbTriggerReasonType(soap, "cb:HcbTriggerReason", -1, &(((_cb__GetHcbStateResponse*)a)->HcbTriggerReason), ""); + soap_out_PointerTocb__BlockedPortInfoType(soap, "cb:BlockedPortInfo", -1, &(((_cb__GetHcbStateResponse*)a)->BlockedPortInfo), ""); + soap_out_PointerTounsignedInt(soap, "cb:EnabledCbPolicy", -1, &(((_cb__GetHcbStateResponse*)a)->EnabledCbPolicy), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__GetHcbStateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__GetHcbStateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__GetHcbStateResponse * SOAP_FMAC4 soap_get__cb__GetHcbStateResponse(struct soap *soap, _cb__GetHcbStateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__GetHcbStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__GetHcbStateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__GetHcbStateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__GetHcbStateResponse * SOAP_FMAC4 soap_in__cb__GetHcbStateResponse(struct soap *soap, const char *tag, _cb__GetHcbStateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__GetHcbStateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__GetHcbStateResponse, sizeof(_cb__GetHcbStateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__GetHcbStateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__GetHcbStateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_HcbState1 = 1, soap_flag_BlockedAll1 = 1, soap_flag_TimeStamp1 = 1, soap_flag_HcbTriggerReason1 = 1, soap_flag_BlockedPortInfo1 = 1, soap_flag_EnabledCbPolicy1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__GetHcbStateResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_HcbState1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__HcbStateType(soap, "cb:HcbState", &(((_cb__GetHcbStateResponse*)a)->HcbState), "cb:HcbStateType")) + { soap_flag_HcbState1--; + continue; + } + if (soap_flag_BlockedAll1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:BlockedAll", &(((_cb__GetHcbStateResponse*)a)->BlockedAll), "xsd:boolean")) + { soap_flag_BlockedAll1--; + continue; + } + if (soap_flag_TimeStamp1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__TimeType(soap, "cb:TimeStamp", &(((_cb__GetHcbStateResponse*)a)->TimeStamp), "cb:TimeType")) + { soap_flag_TimeStamp1--; + continue; + } + if (soap_flag_HcbTriggerReason1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__HcbTriggerReasonType(soap, "cb:HcbTriggerReason", &(((_cb__GetHcbStateResponse*)a)->HcbTriggerReason), "cb:HcbTriggerReasonType")) + { soap_flag_HcbTriggerReason1--; + continue; + } + if (soap_flag_BlockedPortInfo1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__BlockedPortInfoType(soap, "cb:BlockedPortInfo", &(((_cb__GetHcbStateResponse*)a)->BlockedPortInfo), "cb:BlockedPortInfoType")) + { soap_flag_BlockedPortInfo1--; + continue; + } + if (soap_flag_EnabledCbPolicy1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedInt(soap, "cb:EnabledCbPolicy", &(((_cb__GetHcbStateResponse*)a)->EnabledCbPolicy), "xsd:unsignedInt")) + { soap_flag_EnabledCbPolicy1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_HcbState1 > 0 || soap_flag_BlockedAll1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__GetHcbStateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__GetHcbStateResponse, 0, sizeof(_cb__GetHcbStateResponse), 0, soap_copy__cb__GetHcbStateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__GetHcbStateResponse * SOAP_FMAC6 soap_new__cb__GetHcbStateResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__GetHcbStateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__GetHcbStateResponse(struct soap *soap, _cb__GetHcbStateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__GetHcbStateResponse * SOAP_FMAC4 soap_instantiate__cb__GetHcbStateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__GetHcbStateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__GetHcbStateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__GetHcbStateResponse; + if (size) + *size = sizeof(_cb__GetHcbStateResponse); + ((_cb__GetHcbStateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__GetHcbStateResponse[n]; + if (size) + *size = n * sizeof(_cb__GetHcbStateResponse); + for (int i = 0; i < n; i++) + ((_cb__GetHcbStateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__GetHcbStateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__GetHcbStateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__GetHcbStateResponse %p -> %p\n", q, p)); + *(_cb__GetHcbStateResponse*)p = *(_cb__GetHcbStateResponse*)q; +} + +void _cb__GetHcbState::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__GetHcbState::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__InterfaceHandleType(soap, &((_cb__GetHcbState*)this)->InterfaceHandle); + /* transient soap skipped */ +} + +int _cb__GetHcbState::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__GetHcbState); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__GetHcbState::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__GetHcbState(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__GetHcbState(struct soap *soap, const char *tag, int id, const _cb__GetHcbState *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__GetHcbState), type); + soap_out_net__InterfaceHandleType(soap, "cb:InterfaceHandle", -1, &(((_cb__GetHcbState*)a)->InterfaceHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__GetHcbState::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__GetHcbState(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__GetHcbState * SOAP_FMAC4 soap_get__cb__GetHcbState(struct soap *soap, _cb__GetHcbState *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__GetHcbState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__GetHcbState::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__GetHcbState(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__GetHcbState * SOAP_FMAC4 soap_in__cb__GetHcbState(struct soap *soap, const char *tag, _cb__GetHcbState *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__GetHcbState *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__GetHcbState, sizeof(_cb__GetHcbState), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__GetHcbState) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__GetHcbState *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__InterfaceHandleType(soap, "cb:InterfaceHandle", &(((_cb__GetHcbState*)a)->InterfaceHandle), "net:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_InterfaceHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__GetHcbState *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__GetHcbState, 0, sizeof(_cb__GetHcbState), 0, soap_copy__cb__GetHcbState); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__GetHcbState * SOAP_FMAC6 soap_new__cb__GetHcbState(struct soap *soap, int n) +{ return soap_instantiate__cb__GetHcbState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__GetHcbState(struct soap *soap, _cb__GetHcbState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__GetHcbState * SOAP_FMAC4 soap_instantiate__cb__GetHcbState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__GetHcbState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__GetHcbState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__GetHcbState; + if (size) + *size = sizeof(_cb__GetHcbState); + ((_cb__GetHcbState*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__GetHcbState[n]; + if (size) + *size = n * sizeof(_cb__GetHcbState); + for (int i = 0; i < n; i++) + ((_cb__GetHcbState*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__GetHcbState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__GetHcbState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__GetHcbState %p -> %p\n", q, p)); + *(_cb__GetHcbState*)p = *(_cb__GetHcbState*)q; +} + +void _cb__ClearHcbStateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__ClearHcbStateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_cb__ClearHcbStateResponse*)this)->Status); + /* transient soap skipped */ +} + +int _cb__ClearHcbStateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__ClearHcbStateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__ClearHcbStateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__ClearHcbStateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__ClearHcbStateResponse(struct soap *soap, const char *tag, int id, const _cb__ClearHcbStateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__ClearHcbStateResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__ClearHcbStateResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__ClearHcbStateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__ClearHcbStateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__ClearHcbStateResponse * SOAP_FMAC4 soap_get__cb__ClearHcbStateResponse(struct soap *soap, _cb__ClearHcbStateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__ClearHcbStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__ClearHcbStateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__ClearHcbStateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__ClearHcbStateResponse * SOAP_FMAC4 soap_in__cb__ClearHcbStateResponse(struct soap *soap, const char *tag, _cb__ClearHcbStateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__ClearHcbStateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__ClearHcbStateResponse, sizeof(_cb__ClearHcbStateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__ClearHcbStateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__ClearHcbStateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__ClearHcbStateResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__ClearHcbStateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__ClearHcbStateResponse, 0, sizeof(_cb__ClearHcbStateResponse), 0, soap_copy__cb__ClearHcbStateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__ClearHcbStateResponse * SOAP_FMAC6 soap_new__cb__ClearHcbStateResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__ClearHcbStateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__ClearHcbStateResponse(struct soap *soap, _cb__ClearHcbStateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__ClearHcbStateResponse * SOAP_FMAC4 soap_instantiate__cb__ClearHcbStateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__ClearHcbStateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__ClearHcbStateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__ClearHcbStateResponse; + if (size) + *size = sizeof(_cb__ClearHcbStateResponse); + ((_cb__ClearHcbStateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__ClearHcbStateResponse[n]; + if (size) + *size = n * sizeof(_cb__ClearHcbStateResponse); + for (int i = 0; i < n; i++) + ((_cb__ClearHcbStateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__ClearHcbStateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__ClearHcbStateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__ClearHcbStateResponse %p -> %p\n", q, p)); + *(_cb__ClearHcbStateResponse*)p = *(_cb__ClearHcbStateResponse*)q; +} + +void _cb__ClearHcbState::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__ClearHcbState::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__InterfaceHandleType(soap, &((_cb__ClearHcbState*)this)->InterfaceHandle); + /* transient soap skipped */ +} + +int _cb__ClearHcbState::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__ClearHcbState); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__ClearHcbState::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__ClearHcbState(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__ClearHcbState(struct soap *soap, const char *tag, int id, const _cb__ClearHcbState *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__ClearHcbState), type); + soap_out_net__InterfaceHandleType(soap, "cb:InterfaceHandle", -1, &(((_cb__ClearHcbState*)a)->InterfaceHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__ClearHcbState::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__ClearHcbState(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__ClearHcbState * SOAP_FMAC4 soap_get__cb__ClearHcbState(struct soap *soap, _cb__ClearHcbState *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__ClearHcbState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__ClearHcbState::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__ClearHcbState(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__ClearHcbState * SOAP_FMAC4 soap_in__cb__ClearHcbState(struct soap *soap, const char *tag, _cb__ClearHcbState *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__ClearHcbState *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__ClearHcbState, sizeof(_cb__ClearHcbState), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__ClearHcbState) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__ClearHcbState *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__InterfaceHandleType(soap, "cb:InterfaceHandle", &(((_cb__ClearHcbState*)a)->InterfaceHandle), "net:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_InterfaceHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__ClearHcbState *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__ClearHcbState, 0, sizeof(_cb__ClearHcbState), 0, soap_copy__cb__ClearHcbState); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__ClearHcbState * SOAP_FMAC6 soap_new__cb__ClearHcbState(struct soap *soap, int n) +{ return soap_instantiate__cb__ClearHcbState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__ClearHcbState(struct soap *soap, _cb__ClearHcbState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__ClearHcbState * SOAP_FMAC4 soap_instantiate__cb__ClearHcbState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__ClearHcbState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__ClearHcbState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__ClearHcbState; + if (size) + *size = sizeof(_cb__ClearHcbState); + ((_cb__ClearHcbState*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__ClearHcbState[n]; + if (size) + *size = n * sizeof(_cb__ClearHcbState); + for (int i = 0; i < n; i++) + ((_cb__ClearHcbState*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__ClearHcbState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__ClearHcbState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__ClearHcbState %p -> %p\n", q, p)); + *(_cb__ClearHcbState*)p = *(_cb__ClearHcbState*)q; +} + +void _cb__GetHcbOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__HcbOptionsType(soap, &((_cb__GetHcbOptionsResponse*)this)->HcbOptions); + /* transient soap skipped */ +} + +void _cb__GetHcbOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_cb__GetHcbOptionsResponse*)this)->Status); + ((_cb__GetHcbOptionsResponse*)this)->HcbOptions = NULL; + /* transient soap skipped */ +} + +int _cb__GetHcbOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__GetHcbOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__GetHcbOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__GetHcbOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__GetHcbOptionsResponse(struct soap *soap, const char *tag, int id, const _cb__GetHcbOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__GetHcbOptionsResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__GetHcbOptionsResponse*)a)->Status), ""); + soap_out_PointerTocb__HcbOptionsType(soap, "cb:HcbOptions", -1, &(((_cb__GetHcbOptionsResponse*)a)->HcbOptions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__GetHcbOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__GetHcbOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__GetHcbOptionsResponse * SOAP_FMAC4 soap_get__cb__GetHcbOptionsResponse(struct soap *soap, _cb__GetHcbOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__GetHcbOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__GetHcbOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__GetHcbOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__GetHcbOptionsResponse * SOAP_FMAC4 soap_in__cb__GetHcbOptionsResponse(struct soap *soap, const char *tag, _cb__GetHcbOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__GetHcbOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__GetHcbOptionsResponse, sizeof(_cb__GetHcbOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__GetHcbOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__GetHcbOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_HcbOptions1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__GetHcbOptionsResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_HcbOptions1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__HcbOptionsType(soap, "cb:HcbOptions", &(((_cb__GetHcbOptionsResponse*)a)->HcbOptions), "cb:HcbOptionsType")) + { soap_flag_HcbOptions1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__GetHcbOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__GetHcbOptionsResponse, 0, sizeof(_cb__GetHcbOptionsResponse), 0, soap_copy__cb__GetHcbOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__GetHcbOptionsResponse * SOAP_FMAC6 soap_new__cb__GetHcbOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__GetHcbOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__GetHcbOptionsResponse(struct soap *soap, _cb__GetHcbOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__GetHcbOptionsResponse * SOAP_FMAC4 soap_instantiate__cb__GetHcbOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__GetHcbOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__GetHcbOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__GetHcbOptionsResponse; + if (size) + *size = sizeof(_cb__GetHcbOptionsResponse); + ((_cb__GetHcbOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__GetHcbOptionsResponse[n]; + if (size) + *size = n * sizeof(_cb__GetHcbOptionsResponse); + for (int i = 0; i < n; i++) + ((_cb__GetHcbOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__GetHcbOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__GetHcbOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__GetHcbOptionsResponse %p -> %p\n", q, p)); + *(_cb__GetHcbOptionsResponse*)p = *(_cb__GetHcbOptionsResponse*)q; +} + +void _cb__GetHcbOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__GetHcbOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__InterfaceHandleType(soap, &((_cb__GetHcbOptions*)this)->InterfaceHandle); + /* transient soap skipped */ +} + +int _cb__GetHcbOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__GetHcbOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__GetHcbOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__GetHcbOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__GetHcbOptions(struct soap *soap, const char *tag, int id, const _cb__GetHcbOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__GetHcbOptions), type); + soap_out_net__InterfaceHandleType(soap, "cb:InterfaceHandle", -1, &(((_cb__GetHcbOptions*)a)->InterfaceHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__GetHcbOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__GetHcbOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__GetHcbOptions * SOAP_FMAC4 soap_get__cb__GetHcbOptions(struct soap *soap, _cb__GetHcbOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__GetHcbOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__GetHcbOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__GetHcbOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__GetHcbOptions * SOAP_FMAC4 soap_in__cb__GetHcbOptions(struct soap *soap, const char *tag, _cb__GetHcbOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__GetHcbOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__GetHcbOptions, sizeof(_cb__GetHcbOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__GetHcbOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__GetHcbOptions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__InterfaceHandleType(soap, "cb:InterfaceHandle", &(((_cb__GetHcbOptions*)a)->InterfaceHandle), "net:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_InterfaceHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__GetHcbOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__GetHcbOptions, 0, sizeof(_cb__GetHcbOptions), 0, soap_copy__cb__GetHcbOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__GetHcbOptions * SOAP_FMAC6 soap_new__cb__GetHcbOptions(struct soap *soap, int n) +{ return soap_instantiate__cb__GetHcbOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__GetHcbOptions(struct soap *soap, _cb__GetHcbOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__GetHcbOptions * SOAP_FMAC4 soap_instantiate__cb__GetHcbOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__GetHcbOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__GetHcbOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__GetHcbOptions; + if (size) + *size = sizeof(_cb__GetHcbOptions); + ((_cb__GetHcbOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__GetHcbOptions[n]; + if (size) + *size = n * sizeof(_cb__GetHcbOptions); + for (int i = 0; i < n; i++) + ((_cb__GetHcbOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__GetHcbOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__GetHcbOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__GetHcbOptions %p -> %p\n", q, p)); + *(_cb__GetHcbOptions*)p = *(_cb__GetHcbOptions*)q; +} + +void _cb__SetHcbOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__SetHcbOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_cb__SetHcbOptionsResponse*)this)->Status); + /* transient soap skipped */ +} + +int _cb__SetHcbOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__SetHcbOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__SetHcbOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__SetHcbOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__SetHcbOptionsResponse(struct soap *soap, const char *tag, int id, const _cb__SetHcbOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__SetHcbOptionsResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cmn__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__SetHcbOptionsResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__SetHcbOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__SetHcbOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__SetHcbOptionsResponse * SOAP_FMAC4 soap_get__cb__SetHcbOptionsResponse(struct soap *soap, _cb__SetHcbOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__SetHcbOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__SetHcbOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__SetHcbOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__SetHcbOptionsResponse * SOAP_FMAC4 soap_in__cb__SetHcbOptionsResponse(struct soap *soap, const char *tag, _cb__SetHcbOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__SetHcbOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__SetHcbOptionsResponse, sizeof(_cb__SetHcbOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__SetHcbOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__SetHcbOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__SetHcbOptionsResponse*)a)->Status), "cmn:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__SetHcbOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__SetHcbOptionsResponse, 0, sizeof(_cb__SetHcbOptionsResponse), 0, soap_copy__cb__SetHcbOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__SetHcbOptionsResponse * SOAP_FMAC6 soap_new__cb__SetHcbOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__SetHcbOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__SetHcbOptionsResponse(struct soap *soap, _cb__SetHcbOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__SetHcbOptionsResponse * SOAP_FMAC4 soap_instantiate__cb__SetHcbOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__SetHcbOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__SetHcbOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__SetHcbOptionsResponse; + if (size) + *size = sizeof(_cb__SetHcbOptionsResponse); + ((_cb__SetHcbOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__SetHcbOptionsResponse[n]; + if (size) + *size = n * sizeof(_cb__SetHcbOptionsResponse); + for (int i = 0; i < n; i++) + ((_cb__SetHcbOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__SetHcbOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__SetHcbOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__SetHcbOptionsResponse %p -> %p\n", q, p)); + *(_cb__SetHcbOptionsResponse*)p = *(_cb__SetHcbOptionsResponse*)q; +} + +void _cb__SetHcbOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__HcbOptionsType(soap, &((_cb__SetHcbOptions*)this)->HcbOptions); + /* transient soap skipped */ +} + +void _cb__SetHcbOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__InterfaceHandleType(soap, &((_cb__SetHcbOptions*)this)->InterfaceHandle); + ((_cb__SetHcbOptions*)this)->HcbOptions = NULL; + /* transient soap skipped */ +} + +int _cb__SetHcbOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__SetHcbOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__SetHcbOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__SetHcbOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__SetHcbOptions(struct soap *soap, const char *tag, int id, const _cb__SetHcbOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__SetHcbOptions), type); + soap_out_net__InterfaceHandleType(soap, "cb:InterfaceHandle", -1, &(((_cb__SetHcbOptions*)a)->InterfaceHandle), ""); + soap_out_PointerTocb__HcbOptionsType(soap, "cb:HcbOptions", -1, &(((_cb__SetHcbOptions*)a)->HcbOptions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__SetHcbOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__SetHcbOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__SetHcbOptions * SOAP_FMAC4 soap_get__cb__SetHcbOptions(struct soap *soap, _cb__SetHcbOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__SetHcbOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__SetHcbOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__SetHcbOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__SetHcbOptions * SOAP_FMAC4 soap_in__cb__SetHcbOptions(struct soap *soap, const char *tag, _cb__SetHcbOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__SetHcbOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__SetHcbOptions, sizeof(_cb__SetHcbOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__SetHcbOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__SetHcbOptions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1, soap_flag_HcbOptions1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__InterfaceHandleType(soap, "cb:InterfaceHandle", &(((_cb__SetHcbOptions*)a)->InterfaceHandle), "net:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + if (soap_flag_HcbOptions1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__HcbOptionsType(soap, "cb:HcbOptions", &(((_cb__SetHcbOptions*)a)->HcbOptions), "cb:HcbOptionsType")) + { soap_flag_HcbOptions1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_InterfaceHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__SetHcbOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__SetHcbOptions, 0, sizeof(_cb__SetHcbOptions), 0, soap_copy__cb__SetHcbOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__SetHcbOptions * SOAP_FMAC6 soap_new__cb__SetHcbOptions(struct soap *soap, int n) +{ return soap_instantiate__cb__SetHcbOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__SetHcbOptions(struct soap *soap, _cb__SetHcbOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__SetHcbOptions * SOAP_FMAC4 soap_instantiate__cb__SetHcbOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__SetHcbOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__SetHcbOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__SetHcbOptions; + if (size) + *size = sizeof(_cb__SetHcbOptions); + ((_cb__SetHcbOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__SetHcbOptions[n]; + if (size) + *size = n * sizeof(_cb__SetHcbOptions); + for (int i = 0; i < n; i++) + ((_cb__SetHcbOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__SetHcbOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__SetHcbOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__SetHcbOptions %p -> %p\n", q, p)); + *(_cb__SetHcbOptions*)p = *(_cb__SetHcbOptions*)q; +} + +void _cb__CbQueryCapabilitiesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__CbQueryCapabilitiesResponse*)this)->MaxSupportedPolicies, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_cb__CbQueryCapabilitiesResponse*)this)->MaxSupportedFilters, SOAP_TYPE_unsignedInt); + soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(soap, &((_cb__CbQueryCapabilitiesResponse*)this)->Capabilities); + /* transient soap skipped */ +} + +void _cb__CbQueryCapabilitiesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbQueryCapabilitiesResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_cb__CbQueryCapabilitiesResponse*)this)->MaxSupportedPolicies); + soap_default_unsignedInt(soap, &((_cb__CbQueryCapabilitiesResponse*)this)->MaxSupportedFilters); + soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(soap, &((_cb__CbQueryCapabilitiesResponse*)this)->Capabilities); + /* transient soap skipped */ +} + +int _cb__CbQueryCapabilitiesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbQueryCapabilitiesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbQueryCapabilitiesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbQueryCapabilitiesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbQueryCapabilitiesResponse(struct soap *soap, const char *tag, int id, const _cb__CbQueryCapabilitiesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbQueryCapabilitiesResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbQueryCapabilitiesResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "cb:MaxSupportedPolicies", -1, &(((_cb__CbQueryCapabilitiesResponse*)a)->MaxSupportedPolicies), ""); + soap_out_unsignedInt(soap, "cb:MaxSupportedFilters", -1, &(((_cb__CbQueryCapabilitiesResponse*)a)->MaxSupportedFilters), ""); + soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(soap, "cb:Capabilities", -1, &(((_cb__CbQueryCapabilitiesResponse*)a)->Capabilities), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbQueryCapabilitiesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbQueryCapabilitiesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse * SOAP_FMAC4 soap_get__cb__CbQueryCapabilitiesResponse(struct soap *soap, _cb__CbQueryCapabilitiesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbQueryCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbQueryCapabilitiesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbQueryCapabilitiesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse * SOAP_FMAC4 soap_in__cb__CbQueryCapabilitiesResponse(struct soap *soap, const char *tag, _cb__CbQueryCapabilitiesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbQueryCapabilitiesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbQueryCapabilitiesResponse, sizeof(_cb__CbQueryCapabilitiesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbQueryCapabilitiesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbQueryCapabilitiesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_MaxSupportedPolicies1 = 1, soap_flag_MaxSupportedFilters1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbQueryCapabilitiesResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_MaxSupportedPolicies1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:MaxSupportedPolicies", &(((_cb__CbQueryCapabilitiesResponse*)a)->MaxSupportedPolicies), "xsd:unsignedInt")) + { soap_flag_MaxSupportedPolicies1--; + continue; + } + if (soap_flag_MaxSupportedFilters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:MaxSupportedFilters", &(((_cb__CbQueryCapabilitiesResponse*)a)->MaxSupportedFilters), "xsd:unsignedInt")) + { soap_flag_MaxSupportedFilters1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(soap, "cb:Capabilities", &(((_cb__CbQueryCapabilitiesResponse*)a)->Capabilities), "cb:CircuitBreakerCapabilitiesType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_MaxSupportedPolicies1 > 0 || soap_flag_MaxSupportedFilters1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbQueryCapabilitiesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbQueryCapabilitiesResponse, 0, sizeof(_cb__CbQueryCapabilitiesResponse), 0, soap_copy__cb__CbQueryCapabilitiesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbQueryCapabilitiesResponse * SOAP_FMAC6 soap_new__cb__CbQueryCapabilitiesResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbQueryCapabilitiesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbQueryCapabilitiesResponse(struct soap *soap, _cb__CbQueryCapabilitiesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__cb__CbQueryCapabilitiesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbQueryCapabilitiesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbQueryCapabilitiesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbQueryCapabilitiesResponse; + if (size) + *size = sizeof(_cb__CbQueryCapabilitiesResponse); + ((_cb__CbQueryCapabilitiesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbQueryCapabilitiesResponse[n]; + if (size) + *size = n * sizeof(_cb__CbQueryCapabilitiesResponse); + for (int i = 0; i < n; i++) + ((_cb__CbQueryCapabilitiesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbQueryCapabilitiesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbQueryCapabilitiesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbQueryCapabilitiesResponse %p -> %p\n", q, p)); + *(_cb__CbQueryCapabilitiesResponse*)p = *(_cb__CbQueryCapabilitiesResponse*)q; +} + +void _cb__CbQueryCapabilities::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__CbQueryCapabilities::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _cb__CbQueryCapabilities::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbQueryCapabilities); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbQueryCapabilities::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbQueryCapabilities(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbQueryCapabilities(struct soap *soap, const char *tag, int id, const _cb__CbQueryCapabilities *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbQueryCapabilities), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbQueryCapabilities::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbQueryCapabilities(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbQueryCapabilities * SOAP_FMAC4 soap_get__cb__CbQueryCapabilities(struct soap *soap, _cb__CbQueryCapabilities *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbQueryCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbQueryCapabilities::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbQueryCapabilities(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbQueryCapabilities * SOAP_FMAC4 soap_in__cb__CbQueryCapabilities(struct soap *soap, const char *tag, _cb__CbQueryCapabilities *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbQueryCapabilities *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbQueryCapabilities, sizeof(_cb__CbQueryCapabilities), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbQueryCapabilities) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbQueryCapabilities *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbQueryCapabilities *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbQueryCapabilities, 0, sizeof(_cb__CbQueryCapabilities), 0, soap_copy__cb__CbQueryCapabilities); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbQueryCapabilities * SOAP_FMAC6 soap_new__cb__CbQueryCapabilities(struct soap *soap, int n) +{ return soap_instantiate__cb__CbQueryCapabilities(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbQueryCapabilities(struct soap *soap, _cb__CbQueryCapabilities *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbQueryCapabilities * SOAP_FMAC4 soap_instantiate__cb__CbQueryCapabilities(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbQueryCapabilities(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbQueryCapabilities, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbQueryCapabilities; + if (size) + *size = sizeof(_cb__CbQueryCapabilities); + ((_cb__CbQueryCapabilities*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbQueryCapabilities[n]; + if (size) + *size = n * sizeof(_cb__CbQueryCapabilities); + for (int i = 0; i < n; i++) + ((_cb__CbQueryCapabilities*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbQueryCapabilities*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbQueryCapabilities(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbQueryCapabilities %p -> %p\n", q, p)); + *(_cb__CbQueryCapabilities*)p = *(_cb__CbQueryCapabilities*)q; +} + +void _cb__CbFilterEnumerateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(soap, &((_cb__CbFilterEnumerateResponse*)this)->Filters); + /* transient soap skipped */ +} + +void _cb__CbFilterEnumerateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbFilterEnumerateResponse*)this)->Status); + soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(soap, &((_cb__CbFilterEnumerateResponse*)this)->Filters); + /* transient soap skipped */ +} + +int _cb__CbFilterEnumerateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbFilterEnumerateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbFilterEnumerateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbFilterEnumerateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterEnumerateResponse(struct soap *soap, const char *tag, int id, const _cb__CbFilterEnumerateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbFilterEnumerateResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbFilterEnumerateResponse*)a)->Status), ""); + soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(soap, "cb:Filters", -1, &(((_cb__CbFilterEnumerateResponse*)a)->Filters), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbFilterEnumerateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbFilterEnumerateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbFilterEnumerateResponse * SOAP_FMAC4 soap_get__cb__CbFilterEnumerateResponse(struct soap *soap, _cb__CbFilterEnumerateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbFilterEnumerateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbFilterEnumerateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbFilterEnumerateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbFilterEnumerateResponse * SOAP_FMAC4 soap_in__cb__CbFilterEnumerateResponse(struct soap *soap, const char *tag, _cb__CbFilterEnumerateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbFilterEnumerateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbFilterEnumerateResponse, sizeof(_cb__CbFilterEnumerateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbFilterEnumerateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbFilterEnumerateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbFilterEnumerateResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(soap, "cb:Filters", &(((_cb__CbFilterEnumerateResponse*)a)->Filters), "cb:CircuitBreakerFilterInfoType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbFilterEnumerateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbFilterEnumerateResponse, 0, sizeof(_cb__CbFilterEnumerateResponse), 0, soap_copy__cb__CbFilterEnumerateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbFilterEnumerateResponse * SOAP_FMAC6 soap_new__cb__CbFilterEnumerateResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbFilterEnumerateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterEnumerateResponse(struct soap *soap, _cb__CbFilterEnumerateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbFilterEnumerateResponse * SOAP_FMAC4 soap_instantiate__cb__CbFilterEnumerateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbFilterEnumerateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbFilterEnumerateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbFilterEnumerateResponse; + if (size) + *size = sizeof(_cb__CbFilterEnumerateResponse); + ((_cb__CbFilterEnumerateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbFilterEnumerateResponse[n]; + if (size) + *size = n * sizeof(_cb__CbFilterEnumerateResponse); + for (int i = 0; i < n; i++) + ((_cb__CbFilterEnumerateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbFilterEnumerateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterEnumerateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbFilterEnumerateResponse %p -> %p\n", q, p)); + *(_cb__CbFilterEnumerateResponse*)p = *(_cb__CbFilterEnumerateResponse*)q; +} + +void _cb__CbFilterEnumerate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__CbFilterEnumerate::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _cb__CbFilterEnumerate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbFilterEnumerate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbFilterEnumerate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbFilterEnumerate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterEnumerate(struct soap *soap, const char *tag, int id, const _cb__CbFilterEnumerate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbFilterEnumerate), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbFilterEnumerate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbFilterEnumerate(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbFilterEnumerate * SOAP_FMAC4 soap_get__cb__CbFilterEnumerate(struct soap *soap, _cb__CbFilterEnumerate *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbFilterEnumerate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbFilterEnumerate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbFilterEnumerate(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbFilterEnumerate * SOAP_FMAC4 soap_in__cb__CbFilterEnumerate(struct soap *soap, const char *tag, _cb__CbFilterEnumerate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbFilterEnumerate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbFilterEnumerate, sizeof(_cb__CbFilterEnumerate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbFilterEnumerate) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbFilterEnumerate *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbFilterEnumerate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbFilterEnumerate, 0, sizeof(_cb__CbFilterEnumerate), 0, soap_copy__cb__CbFilterEnumerate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbFilterEnumerate * SOAP_FMAC6 soap_new__cb__CbFilterEnumerate(struct soap *soap, int n) +{ return soap_instantiate__cb__CbFilterEnumerate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterEnumerate(struct soap *soap, _cb__CbFilterEnumerate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbFilterEnumerate * SOAP_FMAC4 soap_instantiate__cb__CbFilterEnumerate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbFilterEnumerate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbFilterEnumerate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbFilterEnumerate; + if (size) + *size = sizeof(_cb__CbFilterEnumerate); + ((_cb__CbFilterEnumerate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbFilterEnumerate[n]; + if (size) + *size = n * sizeof(_cb__CbFilterEnumerate); + for (int i = 0; i < n; i++) + ((_cb__CbFilterEnumerate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbFilterEnumerate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterEnumerate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbFilterEnumerate %p -> %p\n", q, p)); + *(_cb__CbFilterEnumerate*)p = *(_cb__CbFilterEnumerate*)q; +} + +void _cb__CbFilterDeleteResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__CbFilterDeleteResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbFilterDeleteResponse*)this)->Status); + /* transient soap skipped */ +} + +int _cb__CbFilterDeleteResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbFilterDeleteResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbFilterDeleteResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbFilterDeleteResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterDeleteResponse(struct soap *soap, const char *tag, int id, const _cb__CbFilterDeleteResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbFilterDeleteResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbFilterDeleteResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbFilterDeleteResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbFilterDeleteResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbFilterDeleteResponse * SOAP_FMAC4 soap_get__cb__CbFilterDeleteResponse(struct soap *soap, _cb__CbFilterDeleteResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbFilterDeleteResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbFilterDeleteResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbFilterDeleteResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbFilterDeleteResponse * SOAP_FMAC4 soap_in__cb__CbFilterDeleteResponse(struct soap *soap, const char *tag, _cb__CbFilterDeleteResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbFilterDeleteResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbFilterDeleteResponse, sizeof(_cb__CbFilterDeleteResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbFilterDeleteResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbFilterDeleteResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbFilterDeleteResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbFilterDeleteResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbFilterDeleteResponse, 0, sizeof(_cb__CbFilterDeleteResponse), 0, soap_copy__cb__CbFilterDeleteResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbFilterDeleteResponse * SOAP_FMAC6 soap_new__cb__CbFilterDeleteResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbFilterDeleteResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterDeleteResponse(struct soap *soap, _cb__CbFilterDeleteResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbFilterDeleteResponse * SOAP_FMAC4 soap_instantiate__cb__CbFilterDeleteResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbFilterDeleteResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbFilterDeleteResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbFilterDeleteResponse; + if (size) + *size = sizeof(_cb__CbFilterDeleteResponse); + ((_cb__CbFilterDeleteResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbFilterDeleteResponse[n]; + if (size) + *size = n * sizeof(_cb__CbFilterDeleteResponse); + for (int i = 0; i < n; i++) + ((_cb__CbFilterDeleteResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbFilterDeleteResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterDeleteResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbFilterDeleteResponse %p -> %p\n", q, p)); + *(_cb__CbFilterDeleteResponse*)p = *(_cb__CbFilterDeleteResponse*)q; +} + +void _cb__CbFilterDelete::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__CbFilterDelete*)this)->FilterCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _cb__CbFilterDelete::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_cb__CbFilterDelete*)this)->FilterCreationHandle); + /* transient soap skipped */ +} + +int _cb__CbFilterDelete::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbFilterDelete); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbFilterDelete::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbFilterDelete(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterDelete(struct soap *soap, const char *tag, int id, const _cb__CbFilterDelete *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbFilterDelete), type); + soap_out_unsignedInt(soap, "cb:FilterCreationHandle", -1, &(((_cb__CbFilterDelete*)a)->FilterCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbFilterDelete::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbFilterDelete(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbFilterDelete * SOAP_FMAC4 soap_get__cb__CbFilterDelete(struct soap *soap, _cb__CbFilterDelete *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbFilterDelete(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbFilterDelete::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbFilterDelete(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbFilterDelete * SOAP_FMAC4 soap_in__cb__CbFilterDelete(struct soap *soap, const char *tag, _cb__CbFilterDelete *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbFilterDelete *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbFilterDelete, sizeof(_cb__CbFilterDelete), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbFilterDelete) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbFilterDelete *)a->soap_in(soap, tag, type); + } + } + short soap_flag_FilterCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_FilterCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:FilterCreationHandle", &(((_cb__CbFilterDelete*)a)->FilterCreationHandle), "xsd:unsignedInt")) + { soap_flag_FilterCreationHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_FilterCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbFilterDelete *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbFilterDelete, 0, sizeof(_cb__CbFilterDelete), 0, soap_copy__cb__CbFilterDelete); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbFilterDelete * SOAP_FMAC6 soap_new__cb__CbFilterDelete(struct soap *soap, int n) +{ return soap_instantiate__cb__CbFilterDelete(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterDelete(struct soap *soap, _cb__CbFilterDelete *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbFilterDelete * SOAP_FMAC4 soap_instantiate__cb__CbFilterDelete(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbFilterDelete(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbFilterDelete, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbFilterDelete; + if (size) + *size = sizeof(_cb__CbFilterDelete); + ((_cb__CbFilterDelete*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbFilterDelete[n]; + if (size) + *size = n * sizeof(_cb__CbFilterDelete); + for (int i = 0; i < n; i++) + ((_cb__CbFilterDelete*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbFilterDelete*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterDelete(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbFilterDelete %p -> %p\n", q, p)); + *(_cb__CbFilterDelete*)p = *(_cb__CbFilterDelete*)q; +} + +void _cb__CbFilterGetResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerFilterType(soap, &((_cb__CbFilterGetResponse*)this)->Filter); + /* transient soap skipped */ +} + +void _cb__CbFilterGetResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbFilterGetResponse*)this)->Status); + ((_cb__CbFilterGetResponse*)this)->Filter = NULL; + /* transient soap skipped */ +} + +int _cb__CbFilterGetResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbFilterGetResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbFilterGetResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbFilterGetResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterGetResponse(struct soap *soap, const char *tag, int id, const _cb__CbFilterGetResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbFilterGetResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbFilterGetResponse*)a)->Status), ""); + soap_out_PointerTocb__CircuitBreakerFilterType(soap, "cb:Filter", -1, &(((_cb__CbFilterGetResponse*)a)->Filter), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbFilterGetResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbFilterGetResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbFilterGetResponse * SOAP_FMAC4 soap_get__cb__CbFilterGetResponse(struct soap *soap, _cb__CbFilterGetResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbFilterGetResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbFilterGetResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbFilterGetResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbFilterGetResponse * SOAP_FMAC4 soap_in__cb__CbFilterGetResponse(struct soap *soap, const char *tag, _cb__CbFilterGetResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbFilterGetResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbFilterGetResponse, sizeof(_cb__CbFilterGetResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbFilterGetResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbFilterGetResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Filter1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbFilterGetResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Filter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerFilterType(soap, "cb:Filter", &(((_cb__CbFilterGetResponse*)a)->Filter), "cb:CircuitBreakerFilterType")) + { soap_flag_Filter1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Filter1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbFilterGetResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbFilterGetResponse, 0, sizeof(_cb__CbFilterGetResponse), 0, soap_copy__cb__CbFilterGetResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbFilterGetResponse * SOAP_FMAC6 soap_new__cb__CbFilterGetResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbFilterGetResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterGetResponse(struct soap *soap, _cb__CbFilterGetResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbFilterGetResponse * SOAP_FMAC4 soap_instantiate__cb__CbFilterGetResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbFilterGetResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbFilterGetResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbFilterGetResponse; + if (size) + *size = sizeof(_cb__CbFilterGetResponse); + ((_cb__CbFilterGetResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbFilterGetResponse[n]; + if (size) + *size = n * sizeof(_cb__CbFilterGetResponse); + for (int i = 0; i < n; i++) + ((_cb__CbFilterGetResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbFilterGetResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterGetResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbFilterGetResponse %p -> %p\n", q, p)); + *(_cb__CbFilterGetResponse*)p = *(_cb__CbFilterGetResponse*)q; +} + +void _cb__CbFilterGet::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__CbFilterGet*)this)->FilterCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _cb__CbFilterGet::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_cb__CbFilterGet*)this)->FilterCreationHandle); + /* transient soap skipped */ +} + +int _cb__CbFilterGet::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbFilterGet); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbFilterGet::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbFilterGet(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterGet(struct soap *soap, const char *tag, int id, const _cb__CbFilterGet *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbFilterGet), type); + soap_out_unsignedInt(soap, "cb:FilterCreationHandle", -1, &(((_cb__CbFilterGet*)a)->FilterCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbFilterGet::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbFilterGet(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbFilterGet * SOAP_FMAC4 soap_get__cb__CbFilterGet(struct soap *soap, _cb__CbFilterGet *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbFilterGet(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbFilterGet::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbFilterGet(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbFilterGet * SOAP_FMAC4 soap_in__cb__CbFilterGet(struct soap *soap, const char *tag, _cb__CbFilterGet *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbFilterGet *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbFilterGet, sizeof(_cb__CbFilterGet), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbFilterGet) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbFilterGet *)a->soap_in(soap, tag, type); + } + } + short soap_flag_FilterCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_FilterCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:FilterCreationHandle", &(((_cb__CbFilterGet*)a)->FilterCreationHandle), "xsd:unsignedInt")) + { soap_flag_FilterCreationHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_FilterCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbFilterGet *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbFilterGet, 0, sizeof(_cb__CbFilterGet), 0, soap_copy__cb__CbFilterGet); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbFilterGet * SOAP_FMAC6 soap_new__cb__CbFilterGet(struct soap *soap, int n) +{ return soap_instantiate__cb__CbFilterGet(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterGet(struct soap *soap, _cb__CbFilterGet *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbFilterGet * SOAP_FMAC4 soap_instantiate__cb__CbFilterGet(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbFilterGet(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbFilterGet, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbFilterGet; + if (size) + *size = sizeof(_cb__CbFilterGet); + ((_cb__CbFilterGet*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbFilterGet[n]; + if (size) + *size = n * sizeof(_cb__CbFilterGet); + for (int i = 0; i < n; i++) + ((_cb__CbFilterGet*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbFilterGet*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterGet(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbFilterGet %p -> %p\n", q, p)); + *(_cb__CbFilterGet*)p = *(_cb__CbFilterGet*)q; +} + +void _cb__CbFilterCreateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__CbFilterCreateResponse*)this)->FilterCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _cb__CbFilterCreateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbFilterCreateResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_cb__CbFilterCreateResponse*)this)->FilterCreationHandle); + /* transient soap skipped */ +} + +int _cb__CbFilterCreateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbFilterCreateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbFilterCreateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbFilterCreateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterCreateResponse(struct soap *soap, const char *tag, int id, const _cb__CbFilterCreateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbFilterCreateResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbFilterCreateResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "cb:FilterCreationHandle", -1, &(((_cb__CbFilterCreateResponse*)a)->FilterCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbFilterCreateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbFilterCreateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbFilterCreateResponse * SOAP_FMAC4 soap_get__cb__CbFilterCreateResponse(struct soap *soap, _cb__CbFilterCreateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbFilterCreateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbFilterCreateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbFilterCreateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbFilterCreateResponse * SOAP_FMAC4 soap_in__cb__CbFilterCreateResponse(struct soap *soap, const char *tag, _cb__CbFilterCreateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbFilterCreateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbFilterCreateResponse, sizeof(_cb__CbFilterCreateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbFilterCreateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbFilterCreateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_FilterCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbFilterCreateResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_FilterCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:FilterCreationHandle", &(((_cb__CbFilterCreateResponse*)a)->FilterCreationHandle), "xsd:unsignedInt")) + { soap_flag_FilterCreationHandle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_FilterCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbFilterCreateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbFilterCreateResponse, 0, sizeof(_cb__CbFilterCreateResponse), 0, soap_copy__cb__CbFilterCreateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbFilterCreateResponse * SOAP_FMAC6 soap_new__cb__CbFilterCreateResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbFilterCreateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterCreateResponse(struct soap *soap, _cb__CbFilterCreateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbFilterCreateResponse * SOAP_FMAC4 soap_instantiate__cb__CbFilterCreateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbFilterCreateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbFilterCreateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbFilterCreateResponse; + if (size) + *size = sizeof(_cb__CbFilterCreateResponse); + ((_cb__CbFilterCreateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbFilterCreateResponse[n]; + if (size) + *size = n * sizeof(_cb__CbFilterCreateResponse); + for (int i = 0; i < n; i++) + ((_cb__CbFilterCreateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbFilterCreateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterCreateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbFilterCreateResponse %p -> %p\n", q, p)); + *(_cb__CbFilterCreateResponse*)p = *(_cb__CbFilterCreateResponse*)q; +} + +void _cb__CbFilterCreate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerFilterType(soap, &((_cb__CbFilterCreate*)this)->Filter); + /* transient soap skipped */ +} + +void _cb__CbFilterCreate::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_cb__CbFilterCreate*)this)->Filter = NULL; + /* transient soap skipped */ +} + +int _cb__CbFilterCreate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbFilterCreate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbFilterCreate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbFilterCreate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbFilterCreate(struct soap *soap, const char *tag, int id, const _cb__CbFilterCreate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbFilterCreate), type); + soap_out_PointerTocb__CircuitBreakerFilterType(soap, "cb:Filter", -1, &(((_cb__CbFilterCreate*)a)->Filter), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbFilterCreate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbFilterCreate(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbFilterCreate * SOAP_FMAC4 soap_get__cb__CbFilterCreate(struct soap *soap, _cb__CbFilterCreate *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbFilterCreate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbFilterCreate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbFilterCreate(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbFilterCreate * SOAP_FMAC4 soap_in__cb__CbFilterCreate(struct soap *soap, const char *tag, _cb__CbFilterCreate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbFilterCreate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbFilterCreate, sizeof(_cb__CbFilterCreate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbFilterCreate) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbFilterCreate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Filter1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Filter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerFilterType(soap, "cb:Filter", &(((_cb__CbFilterCreate*)a)->Filter), "cb:CircuitBreakerFilterType")) + { soap_flag_Filter1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Filter1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbFilterCreate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbFilterCreate, 0, sizeof(_cb__CbFilterCreate), 0, soap_copy__cb__CbFilterCreate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbFilterCreate * SOAP_FMAC6 soap_new__cb__CbFilterCreate(struct soap *soap, int n) +{ return soap_instantiate__cb__CbFilterCreate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbFilterCreate(struct soap *soap, _cb__CbFilterCreate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbFilterCreate * SOAP_FMAC4 soap_instantiate__cb__CbFilterCreate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbFilterCreate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbFilterCreate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbFilterCreate; + if (size) + *size = sizeof(_cb__CbFilterCreate); + ((_cb__CbFilterCreate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbFilterCreate[n]; + if (size) + *size = n * sizeof(_cb__CbFilterCreate); + for (int i = 0; i < n; i++) + ((_cb__CbFilterCreate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbFilterCreate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbFilterCreate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbFilterCreate %p -> %p\n", q, p)); + *(_cb__CbFilterCreate*)p = *(_cb__CbFilterCreate*)q; +} + +void _cb__CbPolicyGetActiveStatisticsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__CbPolicyGetActiveStatisticsResponse*)this)->PolicyCreationHandle, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_cb__CbPolicyGetActiveStatisticsResponse*)this)->ActivationTime, SOAP_TYPE_cb__TimeType); + soap_embedded(soap, &((_cb__CbPolicyGetActiveStatisticsResponse*)this)->LastResetTime, SOAP_TYPE_cb__TimeType); + soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(soap, &((_cb__CbPolicyGetActiveStatisticsResponse*)this)->Statistics); + /* transient soap skipped */ +} + +void _cb__CbPolicyGetActiveStatisticsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbPolicyGetActiveStatisticsResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_cb__CbPolicyGetActiveStatisticsResponse*)this)->PolicyCreationHandle); + soap_default_cb__TimeType(soap, &((_cb__CbPolicyGetActiveStatisticsResponse*)this)->ActivationTime); + soap_default_cb__TimeType(soap, &((_cb__CbPolicyGetActiveStatisticsResponse*)this)->LastResetTime); + soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(soap, &((_cb__CbPolicyGetActiveStatisticsResponse*)this)->Statistics); + /* transient soap skipped */ +} + +int _cb__CbPolicyGetActiveStatisticsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyGetActiveStatisticsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyGetActiveStatisticsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, const char *tag, int id, const _cb__CbPolicyGetActiveStatisticsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "cb:PolicyCreationHandle", -1, &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->PolicyCreationHandle), ""); + soap_out_cb__TimeType(soap, "cb:ActivationTime", -1, &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->ActivationTime), ""); + soap_out_cb__TimeType(soap, "cb:LastResetTime", -1, &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->LastResetTime), ""); + soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(soap, "cb:Statistics", -1, &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->Statistics), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyGetActiveStatisticsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyGetActiveStatisticsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse * SOAP_FMAC4 soap_get__cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, _cb__CbPolicyGetActiveStatisticsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyGetActiveStatisticsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyGetActiveStatisticsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyGetActiveStatisticsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse * SOAP_FMAC4 soap_in__cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, const char *tag, _cb__CbPolicyGetActiveStatisticsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyGetActiveStatisticsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse, sizeof(_cb__CbPolicyGetActiveStatisticsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyGetActiveStatisticsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_PolicyCreationHandle1 = 1, soap_flag_ActivationTime1 = 1, soap_flag_LastResetTime1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_PolicyCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:PolicyCreationHandle", &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->PolicyCreationHandle), "xsd:unsignedInt")) + { soap_flag_PolicyCreationHandle1--; + continue; + } + if (soap_flag_ActivationTime1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__TimeType(soap, "cb:ActivationTime", &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->ActivationTime), "cb:TimeType")) + { soap_flag_ActivationTime1--; + continue; + } + if (soap_flag_LastResetTime1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__TimeType(soap, "cb:LastResetTime", &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->LastResetTime), "cb:TimeType")) + { soap_flag_LastResetTime1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(soap, "cb:Statistics", &(((_cb__CbPolicyGetActiveStatisticsResponse*)a)->Statistics), "cb:CircuitBreakerFilterStatisticsType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_PolicyCreationHandle1 > 0 || soap_flag_ActivationTime1 > 0 || soap_flag_LastResetTime1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyGetActiveStatisticsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse, 0, sizeof(_cb__CbPolicyGetActiveStatisticsResponse), 0, soap_copy__cb__CbPolicyGetActiveStatisticsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyGetActiveStatisticsResponse * SOAP_FMAC6 soap_new__cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyGetActiveStatisticsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, _cb__CbPolicyGetActiveStatisticsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyGetActiveStatisticsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyGetActiveStatisticsResponse; + if (size) + *size = sizeof(_cb__CbPolicyGetActiveStatisticsResponse); + ((_cb__CbPolicyGetActiveStatisticsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyGetActiveStatisticsResponse[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyGetActiveStatisticsResponse); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyGetActiveStatisticsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyGetActiveStatisticsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyGetActiveStatisticsResponse %p -> %p\n", q, p)); + *(_cb__CbPolicyGetActiveStatisticsResponse*)p = *(_cb__CbPolicyGetActiveStatisticsResponse*)q; +} + +void _cb__CbPolicyGetActiveStatistics::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__CbPolicyGetActiveStatistics*)this)->HardwareID, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_cb__CbPolicyGetActiveStatistics*)this)->ResetStatisticsOnRead, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _cb__CbPolicyGetActiveStatistics::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_cb__CbPolicyGetActiveStatistics*)this)->HardwareID); + soap_default_bool(soap, &((_cb__CbPolicyGetActiveStatistics*)this)->ResetStatisticsOnRead); + /* transient soap skipped */ +} + +int _cb__CbPolicyGetActiveStatistics::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyGetActiveStatistics); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyGetActiveStatistics::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyGetActiveStatistics(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetActiveStatistics(struct soap *soap, const char *tag, int id, const _cb__CbPolicyGetActiveStatistics *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyGetActiveStatistics), type); + soap_out_unsignedInt(soap, "cb:HardwareID", -1, &(((_cb__CbPolicyGetActiveStatistics*)a)->HardwareID), ""); + soap_out_bool(soap, "cb:ResetStatisticsOnRead", -1, &(((_cb__CbPolicyGetActiveStatistics*)a)->ResetStatisticsOnRead), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyGetActiveStatistics::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyGetActiveStatistics(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_get__cb__CbPolicyGetActiveStatistics(struct soap *soap, _cb__CbPolicyGetActiveStatistics *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyGetActiveStatistics(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyGetActiveStatistics::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyGetActiveStatistics(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_in__cb__CbPolicyGetActiveStatistics(struct soap *soap, const char *tag, _cb__CbPolicyGetActiveStatistics *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyGetActiveStatistics *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyGetActiveStatistics, sizeof(_cb__CbPolicyGetActiveStatistics), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyGetActiveStatistics) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyGetActiveStatistics *)a->soap_in(soap, tag, type); + } + } + short soap_flag_HardwareID1 = 1, soap_flag_ResetStatisticsOnRead1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_HardwareID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:HardwareID", &(((_cb__CbPolicyGetActiveStatistics*)a)->HardwareID), "xsd:unsignedInt")) + { soap_flag_HardwareID1--; + continue; + } + if (soap_flag_ResetStatisticsOnRead1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:ResetStatisticsOnRead", &(((_cb__CbPolicyGetActiveStatistics*)a)->ResetStatisticsOnRead), "xsd:boolean")) + { soap_flag_ResetStatisticsOnRead1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_HardwareID1 > 0 || soap_flag_ResetStatisticsOnRead1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyGetActiveStatistics *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyGetActiveStatistics, 0, sizeof(_cb__CbPolicyGetActiveStatistics), 0, soap_copy__cb__CbPolicyGetActiveStatistics); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyGetActiveStatistics * SOAP_FMAC6 soap_new__cb__CbPolicyGetActiveStatistics(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyGetActiveStatistics(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetActiveStatistics(struct soap *soap, _cb__CbPolicyGetActiveStatistics *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetActiveStatistics(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyGetActiveStatistics(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyGetActiveStatistics, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyGetActiveStatistics; + if (size) + *size = sizeof(_cb__CbPolicyGetActiveStatistics); + ((_cb__CbPolicyGetActiveStatistics*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyGetActiveStatistics[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyGetActiveStatistics); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyGetActiveStatistics*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyGetActiveStatistics*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetActiveStatistics(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyGetActiveStatistics %p -> %p\n", q, p)); + *(_cb__CbPolicyGetActiveStatistics*)p = *(_cb__CbPolicyGetActiveStatistics*)q; +} + +void _cb__CbPolicyGetEnabledResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, &((_cb__CbPolicyGetEnabledResponse*)this)->HwPolicies); + /* transient soap skipped */ +} + +void _cb__CbPolicyGetEnabledResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbPolicyGetEnabledResponse*)this)->Status); + soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, &((_cb__CbPolicyGetEnabledResponse*)this)->HwPolicies); + /* transient soap skipped */ +} + +int _cb__CbPolicyGetEnabledResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyGetEnabledResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyGetEnabledResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyGetEnabledResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetEnabledResponse(struct soap *soap, const char *tag, int id, const _cb__CbPolicyGetEnabledResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyGetEnabledResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbPolicyGetEnabledResponse*)a)->Status), ""); + soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, "cb:HwPolicies", -1, &(((_cb__CbPolicyGetEnabledResponse*)a)->HwPolicies), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyGetEnabledResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyGetEnabledResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse * SOAP_FMAC4 soap_get__cb__CbPolicyGetEnabledResponse(struct soap *soap, _cb__CbPolicyGetEnabledResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyGetEnabledResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyGetEnabledResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyGetEnabledResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse * SOAP_FMAC4 soap_in__cb__CbPolicyGetEnabledResponse(struct soap *soap, const char *tag, _cb__CbPolicyGetEnabledResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyGetEnabledResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyGetEnabledResponse, sizeof(_cb__CbPolicyGetEnabledResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyGetEnabledResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyGetEnabledResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbPolicyGetEnabledResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, "cb:HwPolicies", &(((_cb__CbPolicyGetEnabledResponse*)a)->HwPolicies), "cb:CircuitBreakerHardwarePolicyType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyGetEnabledResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyGetEnabledResponse, 0, sizeof(_cb__CbPolicyGetEnabledResponse), 0, soap_copy__cb__CbPolicyGetEnabledResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyGetEnabledResponse * SOAP_FMAC6 soap_new__cb__CbPolicyGetEnabledResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyGetEnabledResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetEnabledResponse(struct soap *soap, _cb__CbPolicyGetEnabledResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetEnabledResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyGetEnabledResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyGetEnabledResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyGetEnabledResponse; + if (size) + *size = sizeof(_cb__CbPolicyGetEnabledResponse); + ((_cb__CbPolicyGetEnabledResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyGetEnabledResponse[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyGetEnabledResponse); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyGetEnabledResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyGetEnabledResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetEnabledResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyGetEnabledResponse %p -> %p\n", q, p)); + *(_cb__CbPolicyGetEnabledResponse*)p = *(_cb__CbPolicyGetEnabledResponse*)q; +} + +void _cb__CbPolicyGetEnabled::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerApplicationType(soap, &((_cb__CbPolicyGetEnabled*)this)->AppType); + /* transient soap skipped */ +} + +void _cb__CbPolicyGetEnabled::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_cb__CbPolicyGetEnabled*)this)->AppType = NULL; + /* transient soap skipped */ +} + +int _cb__CbPolicyGetEnabled::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyGetEnabled); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyGetEnabled::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyGetEnabled(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetEnabled(struct soap *soap, const char *tag, int id, const _cb__CbPolicyGetEnabled *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyGetEnabled), type); + soap_out_PointerTocb__CircuitBreakerApplicationType(soap, "cb:AppType", -1, &(((_cb__CbPolicyGetEnabled*)a)->AppType), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyGetEnabled::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyGetEnabled(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_get__cb__CbPolicyGetEnabled(struct soap *soap, _cb__CbPolicyGetEnabled *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyGetEnabled(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyGetEnabled::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyGetEnabled(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_in__cb__CbPolicyGetEnabled(struct soap *soap, const char *tag, _cb__CbPolicyGetEnabled *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyGetEnabled *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyGetEnabled, sizeof(_cb__CbPolicyGetEnabled), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyGetEnabled) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyGetEnabled *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AppType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AppType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerApplicationType(soap, "cb:AppType", &(((_cb__CbPolicyGetEnabled*)a)->AppType), "cb:CircuitBreakerApplicationType")) + { soap_flag_AppType1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyGetEnabled *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyGetEnabled, 0, sizeof(_cb__CbPolicyGetEnabled), 0, soap_copy__cb__CbPolicyGetEnabled); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyGetEnabled * SOAP_FMAC6 soap_new__cb__CbPolicyGetEnabled(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyGetEnabled(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetEnabled(struct soap *soap, _cb__CbPolicyGetEnabled *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetEnabled(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyGetEnabled(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyGetEnabled, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyGetEnabled; + if (size) + *size = sizeof(_cb__CbPolicyGetEnabled); + ((_cb__CbPolicyGetEnabled*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyGetEnabled[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyGetEnabled); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyGetEnabled*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyGetEnabled*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetEnabled(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyGetEnabled %p -> %p\n", q, p)); + *(_cb__CbPolicyGetEnabled*)p = *(_cb__CbPolicyGetEnabled*)q; +} + +void _cb__CbPolicyDisableResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__CbPolicyDisableResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbPolicyDisableResponse*)this)->Status); + /* transient soap skipped */ +} + +int _cb__CbPolicyDisableResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyDisableResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyDisableResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyDisableResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyDisableResponse(struct soap *soap, const char *tag, int id, const _cb__CbPolicyDisableResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyDisableResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbPolicyDisableResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyDisableResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyDisableResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyDisableResponse * SOAP_FMAC4 soap_get__cb__CbPolicyDisableResponse(struct soap *soap, _cb__CbPolicyDisableResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyDisableResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyDisableResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyDisableResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyDisableResponse * SOAP_FMAC4 soap_in__cb__CbPolicyDisableResponse(struct soap *soap, const char *tag, _cb__CbPolicyDisableResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyDisableResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyDisableResponse, sizeof(_cb__CbPolicyDisableResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyDisableResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyDisableResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbPolicyDisableResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyDisableResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyDisableResponse, 0, sizeof(_cb__CbPolicyDisableResponse), 0, soap_copy__cb__CbPolicyDisableResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyDisableResponse * SOAP_FMAC6 soap_new__cb__CbPolicyDisableResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyDisableResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyDisableResponse(struct soap *soap, _cb__CbPolicyDisableResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyDisableResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyDisableResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyDisableResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyDisableResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyDisableResponse; + if (size) + *size = sizeof(_cb__CbPolicyDisableResponse); + ((_cb__CbPolicyDisableResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyDisableResponse[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyDisableResponse); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyDisableResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyDisableResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyDisableResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyDisableResponse %p -> %p\n", q, p)); + *(_cb__CbPolicyDisableResponse*)p = *(_cb__CbPolicyDisableResponse*)q; +} + +void _cb__CbPolicyDisable::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTounsignedInt(soap, &((_cb__CbPolicyDisable*)this)->HardwareID); + /* transient soap skipped */ +} + +void _cb__CbPolicyDisable::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_cb__CbPolicyDisable*)this)->HardwareID = NULL; + /* transient soap skipped */ +} + +int _cb__CbPolicyDisable::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyDisable); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyDisable::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyDisable(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyDisable(struct soap *soap, const char *tag, int id, const _cb__CbPolicyDisable *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyDisable), type); + soap_out_PointerTounsignedInt(soap, "cb:HardwareID", -1, &(((_cb__CbPolicyDisable*)a)->HardwareID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyDisable::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyDisable(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyDisable * SOAP_FMAC4 soap_get__cb__CbPolicyDisable(struct soap *soap, _cb__CbPolicyDisable *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyDisable(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyDisable::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyDisable(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyDisable * SOAP_FMAC4 soap_in__cb__CbPolicyDisable(struct soap *soap, const char *tag, _cb__CbPolicyDisable *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyDisable *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyDisable, sizeof(_cb__CbPolicyDisable), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyDisable) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyDisable *)a->soap_in(soap, tag, type); + } + } + short soap_flag_HardwareID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_HardwareID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedInt(soap, "cb:HardwareID", &(((_cb__CbPolicyDisable*)a)->HardwareID), "xsd:unsignedInt")) + { soap_flag_HardwareID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyDisable *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyDisable, 0, sizeof(_cb__CbPolicyDisable), 0, soap_copy__cb__CbPolicyDisable); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyDisable * SOAP_FMAC6 soap_new__cb__CbPolicyDisable(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyDisable(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyDisable(struct soap *soap, _cb__CbPolicyDisable *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyDisable * SOAP_FMAC4 soap_instantiate__cb__CbPolicyDisable(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyDisable(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyDisable, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyDisable; + if (size) + *size = sizeof(_cb__CbPolicyDisable); + ((_cb__CbPolicyDisable*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyDisable[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyDisable); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyDisable*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyDisable*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyDisable(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyDisable %p -> %p\n", q, p)); + *(_cb__CbPolicyDisable*)p = *(_cb__CbPolicyDisable*)q; +} + +void _cb__CbPolicyEnableResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, &((_cb__CbPolicyEnableResponse*)this)->ActivePolicies); + /* transient soap skipped */ +} + +void _cb__CbPolicyEnableResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbPolicyEnableResponse*)this)->Status); + soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, &((_cb__CbPolicyEnableResponse*)this)->ActivePolicies); + /* transient soap skipped */ +} + +int _cb__CbPolicyEnableResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyEnableResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyEnableResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyEnableResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyEnableResponse(struct soap *soap, const char *tag, int id, const _cb__CbPolicyEnableResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyEnableResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbPolicyEnableResponse*)a)->Status), ""); + soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, "cb:ActivePolicies", -1, &(((_cb__CbPolicyEnableResponse*)a)->ActivePolicies), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyEnableResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyEnableResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnableResponse * SOAP_FMAC4 soap_get__cb__CbPolicyEnableResponse(struct soap *soap, _cb__CbPolicyEnableResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyEnableResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyEnableResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyEnableResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnableResponse * SOAP_FMAC4 soap_in__cb__CbPolicyEnableResponse(struct soap *soap, const char *tag, _cb__CbPolicyEnableResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyEnableResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyEnableResponse, sizeof(_cb__CbPolicyEnableResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyEnableResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyEnableResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbPolicyEnableResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, "cb:ActivePolicies", &(((_cb__CbPolicyEnableResponse*)a)->ActivePolicies), "cb:CircuitBreakerHardwarePolicyType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyEnableResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyEnableResponse, 0, sizeof(_cb__CbPolicyEnableResponse), 0, soap_copy__cb__CbPolicyEnableResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyEnableResponse * SOAP_FMAC6 soap_new__cb__CbPolicyEnableResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyEnableResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyEnableResponse(struct soap *soap, _cb__CbPolicyEnableResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyEnableResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyEnableResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyEnableResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyEnableResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyEnableResponse; + if (size) + *size = sizeof(_cb__CbPolicyEnableResponse); + ((_cb__CbPolicyEnableResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyEnableResponse[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyEnableResponse); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyEnableResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyEnableResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyEnableResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyEnableResponse %p -> %p\n", q, p)); + *(_cb__CbPolicyEnableResponse*)p = *(_cb__CbPolicyEnableResponse*)q; +} + +void _cb__CbPolicyEnable::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, &((_cb__CbPolicyEnable*)this)->EnablePolicies); + /* transient soap skipped */ +} + +void _cb__CbPolicyEnable::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, &((_cb__CbPolicyEnable*)this)->EnablePolicies); + /* transient soap skipped */ +} + +int _cb__CbPolicyEnable::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyEnable); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyEnable::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyEnable(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyEnable(struct soap *soap, const char *tag, int id, const _cb__CbPolicyEnable *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyEnable), type); + soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, "cb:EnablePolicies", -1, &(((_cb__CbPolicyEnable*)a)->EnablePolicies), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyEnable::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyEnable(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnable * SOAP_FMAC4 soap_get__cb__CbPolicyEnable(struct soap *soap, _cb__CbPolicyEnable *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyEnable(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyEnable::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyEnable(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnable * SOAP_FMAC4 soap_in__cb__CbPolicyEnable(struct soap *soap, const char *tag, _cb__CbPolicyEnable *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyEnable *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyEnable, sizeof(_cb__CbPolicyEnable), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyEnable) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyEnable *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, "cb:EnablePolicies", &(((_cb__CbPolicyEnable*)a)->EnablePolicies), "cb:CircuitBreakerHardwarePolicyType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyEnable *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyEnable, 0, sizeof(_cb__CbPolicyEnable), 0, soap_copy__cb__CbPolicyEnable); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyEnable * SOAP_FMAC6 soap_new__cb__CbPolicyEnable(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyEnable(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyEnable(struct soap *soap, _cb__CbPolicyEnable *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyEnable * SOAP_FMAC4 soap_instantiate__cb__CbPolicyEnable(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyEnable(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyEnable, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyEnable; + if (size) + *size = sizeof(_cb__CbPolicyEnable); + ((_cb__CbPolicyEnable*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyEnable[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyEnable); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyEnable*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyEnable*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyEnable(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyEnable %p -> %p\n", q, p)); + *(_cb__CbPolicyEnable*)p = *(_cb__CbPolicyEnable*)q; +} + +void _cb__CbPolicyEnumerateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(soap, &((_cb__CbPolicyEnumerateResponse*)this)->Policies); + /* transient soap skipped */ +} + +void _cb__CbPolicyEnumerateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbPolicyEnumerateResponse*)this)->Status); + soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(soap, &((_cb__CbPolicyEnumerateResponse*)this)->Policies); + /* transient soap skipped */ +} + +int _cb__CbPolicyEnumerateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyEnumerateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyEnumerateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyEnumerateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyEnumerateResponse(struct soap *soap, const char *tag, int id, const _cb__CbPolicyEnumerateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyEnumerateResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbPolicyEnumerateResponse*)a)->Status), ""); + soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(soap, "cb:Policies", -1, &(((_cb__CbPolicyEnumerateResponse*)a)->Policies), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyEnumerateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyEnumerateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse * SOAP_FMAC4 soap_get__cb__CbPolicyEnumerateResponse(struct soap *soap, _cb__CbPolicyEnumerateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyEnumerateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyEnumerateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyEnumerateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse * SOAP_FMAC4 soap_in__cb__CbPolicyEnumerateResponse(struct soap *soap, const char *tag, _cb__CbPolicyEnumerateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyEnumerateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyEnumerateResponse, sizeof(_cb__CbPolicyEnumerateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyEnumerateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyEnumerateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbPolicyEnumerateResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(soap, "cb:Policies", &(((_cb__CbPolicyEnumerateResponse*)a)->Policies), "cb:CircuitBreakerPolicyInfoType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyEnumerateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyEnumerateResponse, 0, sizeof(_cb__CbPolicyEnumerateResponse), 0, soap_copy__cb__CbPolicyEnumerateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyEnumerateResponse * SOAP_FMAC6 soap_new__cb__CbPolicyEnumerateResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyEnumerateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyEnumerateResponse(struct soap *soap, _cb__CbPolicyEnumerateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyEnumerateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyEnumerateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyEnumerateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyEnumerateResponse; + if (size) + *size = sizeof(_cb__CbPolicyEnumerateResponse); + ((_cb__CbPolicyEnumerateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyEnumerateResponse[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyEnumerateResponse); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyEnumerateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyEnumerateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyEnumerateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyEnumerateResponse %p -> %p\n", q, p)); + *(_cb__CbPolicyEnumerateResponse*)p = *(_cb__CbPolicyEnumerateResponse*)q; +} + +void _cb__CbPolicyEnumerate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__CbPolicyEnumerate::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _cb__CbPolicyEnumerate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyEnumerate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyEnumerate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyEnumerate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyEnumerate(struct soap *soap, const char *tag, int id, const _cb__CbPolicyEnumerate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyEnumerate), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyEnumerate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyEnumerate(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnumerate * SOAP_FMAC4 soap_get__cb__CbPolicyEnumerate(struct soap *soap, _cb__CbPolicyEnumerate *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyEnumerate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyEnumerate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyEnumerate(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnumerate * SOAP_FMAC4 soap_in__cb__CbPolicyEnumerate(struct soap *soap, const char *tag, _cb__CbPolicyEnumerate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyEnumerate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyEnumerate, sizeof(_cb__CbPolicyEnumerate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyEnumerate) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyEnumerate *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyEnumerate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyEnumerate, 0, sizeof(_cb__CbPolicyEnumerate), 0, soap_copy__cb__CbPolicyEnumerate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyEnumerate * SOAP_FMAC6 soap_new__cb__CbPolicyEnumerate(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyEnumerate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyEnumerate(struct soap *soap, _cb__CbPolicyEnumerate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyEnumerate * SOAP_FMAC4 soap_instantiate__cb__CbPolicyEnumerate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyEnumerate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyEnumerate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyEnumerate; + if (size) + *size = sizeof(_cb__CbPolicyEnumerate); + ((_cb__CbPolicyEnumerate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyEnumerate[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyEnumerate); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyEnumerate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyEnumerate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyEnumerate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyEnumerate %p -> %p\n", q, p)); + *(_cb__CbPolicyEnumerate*)p = *(_cb__CbPolicyEnumerate*)q; +} + +void _cb__CbPolicyDeleteResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _cb__CbPolicyDeleteResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbPolicyDeleteResponse*)this)->Status); + /* transient soap skipped */ +} + +int _cb__CbPolicyDeleteResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyDeleteResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyDeleteResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyDeleteResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyDeleteResponse(struct soap *soap, const char *tag, int id, const _cb__CbPolicyDeleteResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyDeleteResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbPolicyDeleteResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyDeleteResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyDeleteResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyDeleteResponse * SOAP_FMAC4 soap_get__cb__CbPolicyDeleteResponse(struct soap *soap, _cb__CbPolicyDeleteResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyDeleteResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyDeleteResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyDeleteResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyDeleteResponse * SOAP_FMAC4 soap_in__cb__CbPolicyDeleteResponse(struct soap *soap, const char *tag, _cb__CbPolicyDeleteResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyDeleteResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyDeleteResponse, sizeof(_cb__CbPolicyDeleteResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyDeleteResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyDeleteResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbPolicyDeleteResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyDeleteResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyDeleteResponse, 0, sizeof(_cb__CbPolicyDeleteResponse), 0, soap_copy__cb__CbPolicyDeleteResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyDeleteResponse * SOAP_FMAC6 soap_new__cb__CbPolicyDeleteResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyDeleteResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyDeleteResponse(struct soap *soap, _cb__CbPolicyDeleteResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyDeleteResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyDeleteResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyDeleteResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyDeleteResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyDeleteResponse; + if (size) + *size = sizeof(_cb__CbPolicyDeleteResponse); + ((_cb__CbPolicyDeleteResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyDeleteResponse[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyDeleteResponse); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyDeleteResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyDeleteResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyDeleteResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyDeleteResponse %p -> %p\n", q, p)); + *(_cb__CbPolicyDeleteResponse*)p = *(_cb__CbPolicyDeleteResponse*)q; +} + +void _cb__CbPolicyDelete::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__CbPolicyDelete*)this)->PolicyCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _cb__CbPolicyDelete::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_cb__CbPolicyDelete*)this)->PolicyCreationHandle); + /* transient soap skipped */ +} + +int _cb__CbPolicyDelete::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyDelete); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyDelete::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyDelete(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyDelete(struct soap *soap, const char *tag, int id, const _cb__CbPolicyDelete *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyDelete), type); + soap_out_unsignedInt(soap, "cb:PolicyCreationHandle", -1, &(((_cb__CbPolicyDelete*)a)->PolicyCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyDelete::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyDelete(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyDelete * SOAP_FMAC4 soap_get__cb__CbPolicyDelete(struct soap *soap, _cb__CbPolicyDelete *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyDelete(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyDelete::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyDelete(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyDelete * SOAP_FMAC4 soap_in__cb__CbPolicyDelete(struct soap *soap, const char *tag, _cb__CbPolicyDelete *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyDelete *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyDelete, sizeof(_cb__CbPolicyDelete), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyDelete) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyDelete *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PolicyCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PolicyCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:PolicyCreationHandle", &(((_cb__CbPolicyDelete*)a)->PolicyCreationHandle), "xsd:unsignedInt")) + { soap_flag_PolicyCreationHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PolicyCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyDelete *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyDelete, 0, sizeof(_cb__CbPolicyDelete), 0, soap_copy__cb__CbPolicyDelete); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyDelete * SOAP_FMAC6 soap_new__cb__CbPolicyDelete(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyDelete(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyDelete(struct soap *soap, _cb__CbPolicyDelete *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyDelete * SOAP_FMAC4 soap_instantiate__cb__CbPolicyDelete(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyDelete(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyDelete, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyDelete; + if (size) + *size = sizeof(_cb__CbPolicyDelete); + ((_cb__CbPolicyDelete*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyDelete[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyDelete); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyDelete*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyDelete*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyDelete(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyDelete %p -> %p\n", q, p)); + *(_cb__CbPolicyDelete*)p = *(_cb__CbPolicyDelete*)q; +} + +void _cb__CbPolicyGetResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerPolicyType(soap, &((_cb__CbPolicyGetResponse*)this)->Policy); + /* transient soap skipped */ +} + +void _cb__CbPolicyGetResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbPolicyGetResponse*)this)->Status); + ((_cb__CbPolicyGetResponse*)this)->Policy = NULL; + /* transient soap skipped */ +} + +int _cb__CbPolicyGetResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyGetResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyGetResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyGetResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGetResponse(struct soap *soap, const char *tag, int id, const _cb__CbPolicyGetResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyGetResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbPolicyGetResponse*)a)->Status), ""); + soap_out_PointerTocb__CircuitBreakerPolicyType(soap, "cb:Policy", -1, &(((_cb__CbPolicyGetResponse*)a)->Policy), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyGetResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyGetResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetResponse * SOAP_FMAC4 soap_get__cb__CbPolicyGetResponse(struct soap *soap, _cb__CbPolicyGetResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyGetResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyGetResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyGetResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetResponse * SOAP_FMAC4 soap_in__cb__CbPolicyGetResponse(struct soap *soap, const char *tag, _cb__CbPolicyGetResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyGetResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyGetResponse, sizeof(_cb__CbPolicyGetResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyGetResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyGetResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Policy1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbPolicyGetResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Policy1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerPolicyType(soap, "cb:Policy", &(((_cb__CbPolicyGetResponse*)a)->Policy), "cb:CircuitBreakerPolicyType")) + { soap_flag_Policy1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Policy1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyGetResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyGetResponse, 0, sizeof(_cb__CbPolicyGetResponse), 0, soap_copy__cb__CbPolicyGetResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyGetResponse * SOAP_FMAC6 soap_new__cb__CbPolicyGetResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyGetResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGetResponse(struct soap *soap, _cb__CbPolicyGetResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyGetResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGetResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyGetResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyGetResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyGetResponse; + if (size) + *size = sizeof(_cb__CbPolicyGetResponse); + ((_cb__CbPolicyGetResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyGetResponse[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyGetResponse); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyGetResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyGetResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGetResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyGetResponse %p -> %p\n", q, p)); + *(_cb__CbPolicyGetResponse*)p = *(_cb__CbPolicyGetResponse*)q; +} + +void _cb__CbPolicyGet::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__CbPolicyGet*)this)->PolicyCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _cb__CbPolicyGet::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_cb__CbPolicyGet*)this)->PolicyCreationHandle); + /* transient soap skipped */ +} + +int _cb__CbPolicyGet::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyGet); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyGet::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyGet(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyGet(struct soap *soap, const char *tag, int id, const _cb__CbPolicyGet *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyGet), type); + soap_out_unsignedInt(soap, "cb:PolicyCreationHandle", -1, &(((_cb__CbPolicyGet*)a)->PolicyCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyGet::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyGet(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyGet * SOAP_FMAC4 soap_get__cb__CbPolicyGet(struct soap *soap, _cb__CbPolicyGet *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyGet(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyGet::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyGet(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyGet * SOAP_FMAC4 soap_in__cb__CbPolicyGet(struct soap *soap, const char *tag, _cb__CbPolicyGet *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyGet *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyGet, sizeof(_cb__CbPolicyGet), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyGet) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyGet *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PolicyCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PolicyCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:PolicyCreationHandle", &(((_cb__CbPolicyGet*)a)->PolicyCreationHandle), "xsd:unsignedInt")) + { soap_flag_PolicyCreationHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PolicyCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyGet *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyGet, 0, sizeof(_cb__CbPolicyGet), 0, soap_copy__cb__CbPolicyGet); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyGet * SOAP_FMAC6 soap_new__cb__CbPolicyGet(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyGet(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyGet(struct soap *soap, _cb__CbPolicyGet *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyGet * SOAP_FMAC4 soap_instantiate__cb__CbPolicyGet(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyGet(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyGet, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyGet; + if (size) + *size = sizeof(_cb__CbPolicyGet); + ((_cb__CbPolicyGet*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyGet[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyGet); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyGet*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyGet*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyGet(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyGet %p -> %p\n", q, p)); + *(_cb__CbPolicyGet*)p = *(_cb__CbPolicyGet*)q; +} + +void _cb__CbPolicyCreateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_cb__CbPolicyCreateResponse*)this)->PolicyCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _cb__CbPolicyCreateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__PT_USCORESTATUS(soap, &((_cb__CbPolicyCreateResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_cb__CbPolicyCreateResponse*)this)->PolicyCreationHandle); + /* transient soap skipped */ +} + +int _cb__CbPolicyCreateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyCreateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyCreateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyCreateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyCreateResponse(struct soap *soap, const char *tag, int id, const _cb__CbPolicyCreateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyCreateResponse), type); + soap_element_result(soap, "cb:Status"); + soap_out_cb__PT_USCORESTATUS(soap, "cb:Status", -1, &(((_cb__CbPolicyCreateResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "cb:PolicyCreationHandle", -1, &(((_cb__CbPolicyCreateResponse*)a)->PolicyCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyCreateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyCreateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyCreateResponse * SOAP_FMAC4 soap_get__cb__CbPolicyCreateResponse(struct soap *soap, _cb__CbPolicyCreateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyCreateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyCreateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyCreateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyCreateResponse * SOAP_FMAC4 soap_in__cb__CbPolicyCreateResponse(struct soap *soap, const char *tag, _cb__CbPolicyCreateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyCreateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyCreateResponse, sizeof(_cb__CbPolicyCreateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyCreateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyCreateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_PolicyCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__PT_USCORESTATUS(soap, "cb:Status", &(((_cb__CbPolicyCreateResponse*)a)->Status), "cb:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_PolicyCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:PolicyCreationHandle", &(((_cb__CbPolicyCreateResponse*)a)->PolicyCreationHandle), "xsd:unsignedInt")) + { soap_flag_PolicyCreationHandle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "cb:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_PolicyCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyCreateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyCreateResponse, 0, sizeof(_cb__CbPolicyCreateResponse), 0, soap_copy__cb__CbPolicyCreateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyCreateResponse * SOAP_FMAC6 soap_new__cb__CbPolicyCreateResponse(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyCreateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyCreateResponse(struct soap *soap, _cb__CbPolicyCreateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyCreateResponse * SOAP_FMAC4 soap_instantiate__cb__CbPolicyCreateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyCreateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyCreateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyCreateResponse; + if (size) + *size = sizeof(_cb__CbPolicyCreateResponse); + ((_cb__CbPolicyCreateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyCreateResponse[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyCreateResponse); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyCreateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyCreateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyCreateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyCreateResponse %p -> %p\n", q, p)); + *(_cb__CbPolicyCreateResponse*)p = *(_cb__CbPolicyCreateResponse*)q; +} + +void _cb__CbPolicyCreate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerPolicyType(soap, &((_cb__CbPolicyCreate*)this)->Policy); + /* transient soap skipped */ +} + +void _cb__CbPolicyCreate::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_cb__CbPolicyCreate*)this)->Policy = NULL; + /* transient soap skipped */ +} + +int _cb__CbPolicyCreate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__cb__CbPolicyCreate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _cb__CbPolicyCreate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__cb__CbPolicyCreate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__CbPolicyCreate(struct soap *soap, const char *tag, int id, const _cb__CbPolicyCreate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__cb__CbPolicyCreate), type); + soap_out_PointerTocb__CircuitBreakerPolicyType(soap, "cb:Policy", -1, &(((_cb__CbPolicyCreate*)a)->Policy), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_cb__CbPolicyCreate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__cb__CbPolicyCreate(soap, this, tag, type); +} + +SOAP_FMAC3 _cb__CbPolicyCreate * SOAP_FMAC4 soap_get__cb__CbPolicyCreate(struct soap *soap, _cb__CbPolicyCreate *p, const char *tag, const char *type) +{ + if ((p = soap_in__cb__CbPolicyCreate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_cb__CbPolicyCreate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__cb__CbPolicyCreate(soap, tag, this, type); +} + +SOAP_FMAC3 _cb__CbPolicyCreate * SOAP_FMAC4 soap_in__cb__CbPolicyCreate(struct soap *soap, const char *tag, _cb__CbPolicyCreate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_cb__CbPolicyCreate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__cb__CbPolicyCreate, sizeof(_cb__CbPolicyCreate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__cb__CbPolicyCreate) + { soap_revert(soap); + *soap->id = '\0'; + return (_cb__CbPolicyCreate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Policy1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Policy1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerPolicyType(soap, "cb:Policy", &(((_cb__CbPolicyCreate*)a)->Policy), "cb:CircuitBreakerPolicyType")) + { soap_flag_Policy1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Policy1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_cb__CbPolicyCreate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__cb__CbPolicyCreate, 0, sizeof(_cb__CbPolicyCreate), 0, soap_copy__cb__CbPolicyCreate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _cb__CbPolicyCreate * SOAP_FMAC6 soap_new__cb__CbPolicyCreate(struct soap *soap, int n) +{ return soap_instantiate__cb__CbPolicyCreate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__cb__CbPolicyCreate(struct soap *soap, _cb__CbPolicyCreate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _cb__CbPolicyCreate * SOAP_FMAC4 soap_instantiate__cb__CbPolicyCreate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__cb__CbPolicyCreate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__cb__CbPolicyCreate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _cb__CbPolicyCreate; + if (size) + *size = sizeof(_cb__CbPolicyCreate); + ((_cb__CbPolicyCreate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _cb__CbPolicyCreate[n]; + if (size) + *size = n * sizeof(_cb__CbPolicyCreate); + for (int i = 0; i < n; i++) + ((_cb__CbPolicyCreate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_cb__CbPolicyCreate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__cb__CbPolicyCreate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _cb__CbPolicyCreate %p -> %p\n", q, p)); + *(_cb__CbPolicyCreate*)p = *(_cb__CbPolicyCreate*)q; +} + +void cb__HcbOptionsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__TimedCounterType(soap, &((cb__HcbOptionsType*)this)->FastConnectionRate); + soap_serialize_PointerTocb__TimedCounterType(soap, &((cb__HcbOptionsType*)this)->SlowConnectionRate); + soap_embedded(soap, &((cb__HcbOptionsType*)this)->BlockAll, SOAP_TYPE_bool); + soap_embedded(soap, &((cb__HcbOptionsType*)this)->BlockOffensivePort, SOAP_TYPE_bool); + soap_serialize_PointerTounsignedInt(soap, &((cb__HcbOptionsType*)this)->PolicyCreationHandle); + soap_embedded(soap, &((cb__HcbOptionsType*)this)->EncounterTimeout, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void cb__HcbOptionsType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__HcbOptionsType*)this)->FastConnectionRate = NULL; + ((cb__HcbOptionsType*)this)->SlowConnectionRate = NULL; + soap_default_bool(soap, &((cb__HcbOptionsType*)this)->BlockAll); + soap_default_bool(soap, &((cb__HcbOptionsType*)this)->BlockOffensivePort); + ((cb__HcbOptionsType*)this)->PolicyCreationHandle = NULL; + soap_default_unsignedShort(soap, &((cb__HcbOptionsType*)this)->EncounterTimeout); + /* transient soap skipped */ +} + +int cb__HcbOptionsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__HcbOptionsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__HcbOptionsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__HcbOptionsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__HcbOptionsType(struct soap *soap, const char *tag, int id, const cb__HcbOptionsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__HcbOptionsType), type); + soap_out_PointerTocb__TimedCounterType(soap, "cb:FastConnectionRate", -1, &(((cb__HcbOptionsType*)a)->FastConnectionRate), ""); + soap_out_PointerTocb__TimedCounterType(soap, "cb:SlowConnectionRate", -1, &(((cb__HcbOptionsType*)a)->SlowConnectionRate), ""); + soap_out_bool(soap, "cb:BlockAll", -1, &(((cb__HcbOptionsType*)a)->BlockAll), ""); + soap_out_bool(soap, "cb:BlockOffensivePort", -1, &(((cb__HcbOptionsType*)a)->BlockOffensivePort), ""); + soap_out_PointerTounsignedInt(soap, "cb:PolicyCreationHandle", -1, &(((cb__HcbOptionsType*)a)->PolicyCreationHandle), ""); + soap_out_unsignedShort(soap, "cb:EncounterTimeout", -1, &(((cb__HcbOptionsType*)a)->EncounterTimeout), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__HcbOptionsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__HcbOptionsType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__HcbOptionsType * SOAP_FMAC4 soap_get_cb__HcbOptionsType(struct soap *soap, cb__HcbOptionsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__HcbOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__HcbOptionsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__HcbOptionsType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__HcbOptionsType * SOAP_FMAC4 soap_in_cb__HcbOptionsType(struct soap *soap, const char *tag, cb__HcbOptionsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__HcbOptionsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__HcbOptionsType, sizeof(cb__HcbOptionsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__HcbOptionsType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__HcbOptionsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_FastConnectionRate1 = 1, soap_flag_SlowConnectionRate1 = 1, soap_flag_BlockAll1 = 1, soap_flag_BlockOffensivePort1 = 1, soap_flag_PolicyCreationHandle1 = 1, soap_flag_EncounterTimeout1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_FastConnectionRate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__TimedCounterType(soap, "cb:FastConnectionRate", &(((cb__HcbOptionsType*)a)->FastConnectionRate), "cb:TimedCounterType")) + { soap_flag_FastConnectionRate1--; + continue; + } + if (soap_flag_SlowConnectionRate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__TimedCounterType(soap, "cb:SlowConnectionRate", &(((cb__HcbOptionsType*)a)->SlowConnectionRate), "cb:TimedCounterType")) + { soap_flag_SlowConnectionRate1--; + continue; + } + if (soap_flag_BlockAll1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:BlockAll", &(((cb__HcbOptionsType*)a)->BlockAll), "xsd:boolean")) + { soap_flag_BlockAll1--; + continue; + } + if (soap_flag_BlockOffensivePort1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:BlockOffensivePort", &(((cb__HcbOptionsType*)a)->BlockOffensivePort), "xsd:boolean")) + { soap_flag_BlockOffensivePort1--; + continue; + } + if (soap_flag_PolicyCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedInt(soap, "cb:PolicyCreationHandle", &(((cb__HcbOptionsType*)a)->PolicyCreationHandle), "xsd:unsignedInt")) + { soap_flag_PolicyCreationHandle1--; + continue; + } + if (soap_flag_EncounterTimeout1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:EncounterTimeout", &(((cb__HcbOptionsType*)a)->EncounterTimeout), "xsd:unsignedShort")) + { soap_flag_EncounterTimeout1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_BlockAll1 > 0 || soap_flag_BlockOffensivePort1 > 0 || soap_flag_EncounterTimeout1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__HcbOptionsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__HcbOptionsType, 0, sizeof(cb__HcbOptionsType), 0, soap_copy_cb__HcbOptionsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__HcbOptionsType * SOAP_FMAC6 soap_new_cb__HcbOptionsType(struct soap *soap, int n) +{ return soap_instantiate_cb__HcbOptionsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__HcbOptionsType(struct soap *soap, cb__HcbOptionsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__HcbOptionsType * SOAP_FMAC4 soap_instantiate_cb__HcbOptionsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__HcbOptionsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__HcbOptionsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__HcbOptionsType; + if (size) + *size = sizeof(cb__HcbOptionsType); + ((cb__HcbOptionsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__HcbOptionsType[n]; + if (size) + *size = n * sizeof(cb__HcbOptionsType); + for (int i = 0; i < n; i++) + ((cb__HcbOptionsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__HcbOptionsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__HcbOptionsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__HcbOptionsType %p -> %p\n", q, p)); + *(cb__HcbOptionsType*)p = *(cb__HcbOptionsType*)q; +} + +void cb__BlockedPortInfoType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__BlockedPortInfoType*)this)->PortBlocked, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__BlockedPortInfoType*)this)->ProtocolBlocked, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void cb__BlockedPortInfoType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedShort(soap, &((cb__BlockedPortInfoType*)this)->PortBlocked); + soap_default_unsignedShort(soap, &((cb__BlockedPortInfoType*)this)->ProtocolBlocked); + /* transient soap skipped */ +} + +int cb__BlockedPortInfoType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__BlockedPortInfoType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__BlockedPortInfoType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__BlockedPortInfoType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__BlockedPortInfoType(struct soap *soap, const char *tag, int id, const cb__BlockedPortInfoType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__BlockedPortInfoType), type); + soap_out_unsignedShort(soap, "cb:PortBlocked", -1, &(((cb__BlockedPortInfoType*)a)->PortBlocked), ""); + soap_out_unsignedShort(soap, "cb:ProtocolBlocked", -1, &(((cb__BlockedPortInfoType*)a)->ProtocolBlocked), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__BlockedPortInfoType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__BlockedPortInfoType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__BlockedPortInfoType * SOAP_FMAC4 soap_get_cb__BlockedPortInfoType(struct soap *soap, cb__BlockedPortInfoType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__BlockedPortInfoType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__BlockedPortInfoType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__BlockedPortInfoType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__BlockedPortInfoType * SOAP_FMAC4 soap_in_cb__BlockedPortInfoType(struct soap *soap, const char *tag, cb__BlockedPortInfoType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__BlockedPortInfoType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__BlockedPortInfoType, sizeof(cb__BlockedPortInfoType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__BlockedPortInfoType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__BlockedPortInfoType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PortBlocked1 = 1, soap_flag_ProtocolBlocked1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PortBlocked1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:PortBlocked", &(((cb__BlockedPortInfoType*)a)->PortBlocked), "xsd:unsignedShort")) + { soap_flag_PortBlocked1--; + continue; + } + if (soap_flag_ProtocolBlocked1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:ProtocolBlocked", &(((cb__BlockedPortInfoType*)a)->ProtocolBlocked), "xsd:unsignedShort")) + { soap_flag_ProtocolBlocked1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PortBlocked1 > 0 || soap_flag_ProtocolBlocked1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__BlockedPortInfoType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__BlockedPortInfoType, 0, sizeof(cb__BlockedPortInfoType), 0, soap_copy_cb__BlockedPortInfoType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__BlockedPortInfoType * SOAP_FMAC6 soap_new_cb__BlockedPortInfoType(struct soap *soap, int n) +{ return soap_instantiate_cb__BlockedPortInfoType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__BlockedPortInfoType(struct soap *soap, cb__BlockedPortInfoType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__BlockedPortInfoType * SOAP_FMAC4 soap_instantiate_cb__BlockedPortInfoType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__BlockedPortInfoType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__BlockedPortInfoType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__BlockedPortInfoType; + if (size) + *size = sizeof(cb__BlockedPortInfoType); + ((cb__BlockedPortInfoType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__BlockedPortInfoType[n]; + if (size) + *size = n * sizeof(cb__BlockedPortInfoType); + for (int i = 0; i < n; i++) + ((cb__BlockedPortInfoType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__BlockedPortInfoType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__BlockedPortInfoType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__BlockedPortInfoType %p -> %p\n", q, p)); + *(cb__BlockedPortInfoType*)p = *(cb__BlockedPortInfoType*)q; +} + +void cb__TimedCounterType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__TimedCounterType*)this)->Threshold, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((cb__TimedCounterType*)this)->ClearTime, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void cb__TimedCounterType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((cb__TimedCounterType*)this)->Threshold); + soap_default_unsignedInt(soap, &((cb__TimedCounterType*)this)->ClearTime); + /* transient soap skipped */ +} + +int cb__TimedCounterType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__TimedCounterType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__TimedCounterType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__TimedCounterType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__TimedCounterType(struct soap *soap, const char *tag, int id, const cb__TimedCounterType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__TimedCounterType), type); + soap_out_unsignedInt(soap, "cb:Threshold", -1, &(((cb__TimedCounterType*)a)->Threshold), ""); + soap_out_unsignedInt(soap, "cb:ClearTime", -1, &(((cb__TimedCounterType*)a)->ClearTime), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__TimedCounterType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__TimedCounterType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__TimedCounterType * SOAP_FMAC4 soap_get_cb__TimedCounterType(struct soap *soap, cb__TimedCounterType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__TimedCounterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__TimedCounterType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__TimedCounterType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__TimedCounterType * SOAP_FMAC4 soap_in_cb__TimedCounterType(struct soap *soap, const char *tag, cb__TimedCounterType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__TimedCounterType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__TimedCounterType, sizeof(cb__TimedCounterType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__TimedCounterType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__TimedCounterType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Threshold1 = 1, soap_flag_ClearTime1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Threshold1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:Threshold", &(((cb__TimedCounterType*)a)->Threshold), "xsd:unsignedInt")) + { soap_flag_Threshold1--; + continue; + } + if (soap_flag_ClearTime1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:ClearTime", &(((cb__TimedCounterType*)a)->ClearTime), "xsd:unsignedInt")) + { soap_flag_ClearTime1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Threshold1 > 0 || soap_flag_ClearTime1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__TimedCounterType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__TimedCounterType, 0, sizeof(cb__TimedCounterType), 0, soap_copy_cb__TimedCounterType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__TimedCounterType * SOAP_FMAC6 soap_new_cb__TimedCounterType(struct soap *soap, int n) +{ return soap_instantiate_cb__TimedCounterType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__TimedCounterType(struct soap *soap, cb__TimedCounterType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__TimedCounterType * SOAP_FMAC4 soap_instantiate_cb__TimedCounterType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__TimedCounterType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__TimedCounterType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__TimedCounterType; + if (size) + *size = sizeof(cb__TimedCounterType); + ((cb__TimedCounterType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__TimedCounterType[n]; + if (size) + *size = n * sizeof(cb__TimedCounterType); + for (int i = 0; i < n; i++) + ((cb__TimedCounterType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__TimedCounterType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__TimedCounterType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__TimedCounterType %p -> %p\n", q, p)); + *(cb__TimedCounterType*)p = *(cb__TimedCounterType*)q; +} + +void cb__CircuitBreakerHardwarePolicyType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerHardwarePolicyType*)this)->HardwareID, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((cb__CircuitBreakerHardwarePolicyType*)this)->PolicyCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void cb__CircuitBreakerHardwarePolicyType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((cb__CircuitBreakerHardwarePolicyType*)this)->HardwareID); + soap_default_unsignedInt(soap, &((cb__CircuitBreakerHardwarePolicyType*)this)->PolicyCreationHandle); + /* transient soap skipped */ +} + +int cb__CircuitBreakerHardwarePolicyType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerHardwarePolicyType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerHardwarePolicyType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerHardwarePolicyType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType), type); + soap_out_unsignedInt(soap, "cb:HardwareID", -1, &(((cb__CircuitBreakerHardwarePolicyType*)a)->HardwareID), ""); + soap_out_unsignedInt(soap, "cb:PolicyCreationHandle", -1, &(((cb__CircuitBreakerHardwarePolicyType*)a)->PolicyCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerHardwarePolicyType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerHardwarePolicyType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_get_cb__CircuitBreakerHardwarePolicyType(struct soap *soap, cb__CircuitBreakerHardwarePolicyType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerHardwarePolicyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerHardwarePolicyType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerHardwarePolicyType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_in_cb__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, cb__CircuitBreakerHardwarePolicyType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerHardwarePolicyType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType, sizeof(cb__CircuitBreakerHardwarePolicyType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerHardwarePolicyType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_HardwareID1 = 1, soap_flag_PolicyCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_HardwareID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:HardwareID", &(((cb__CircuitBreakerHardwarePolicyType*)a)->HardwareID), "xsd:unsignedInt")) + { soap_flag_HardwareID1--; + continue; + } + if (soap_flag_PolicyCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:PolicyCreationHandle", &(((cb__CircuitBreakerHardwarePolicyType*)a)->PolicyCreationHandle), "xsd:unsignedInt")) + { soap_flag_PolicyCreationHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_HardwareID1 > 0 || soap_flag_PolicyCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerHardwarePolicyType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType, 0, sizeof(cb__CircuitBreakerHardwarePolicyType), 0, soap_copy_cb__CircuitBreakerHardwarePolicyType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerHardwarePolicyType * SOAP_FMAC6 soap_new_cb__CircuitBreakerHardwarePolicyType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerHardwarePolicyType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerHardwarePolicyType(struct soap *soap, cb__CircuitBreakerHardwarePolicyType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerHardwarePolicyType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerHardwarePolicyType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerHardwarePolicyType; + if (size) + *size = sizeof(cb__CircuitBreakerHardwarePolicyType); + ((cb__CircuitBreakerHardwarePolicyType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerHardwarePolicyType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerHardwarePolicyType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerHardwarePolicyType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerHardwarePolicyType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerHardwarePolicyType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerHardwarePolicyType %p -> %p\n", q, p)); + *(cb__CircuitBreakerHardwarePolicyType*)p = *(cb__CircuitBreakerHardwarePolicyType*)q; +} + +void cb__CircuitBreakerFilterStatisticsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerFilterStatisticsType*)this)->FilterCreationHandle, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((cb__CircuitBreakerFilterStatisticsType*)this)->ReadCount, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((cb__CircuitBreakerFilterStatisticsType*)this)->FilterMatched, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void cb__CircuitBreakerFilterStatisticsType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((cb__CircuitBreakerFilterStatisticsType*)this)->FilterCreationHandle); + soap_default_unsignedInt(soap, &((cb__CircuitBreakerFilterStatisticsType*)this)->ReadCount); + soap_default_bool(soap, &((cb__CircuitBreakerFilterStatisticsType*)this)->FilterMatched); + /* transient soap skipped */ +} + +int cb__CircuitBreakerFilterStatisticsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerFilterStatisticsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerFilterStatisticsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterStatisticsType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerFilterStatisticsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType), type); + soap_out_unsignedInt(soap, "cb:FilterCreationHandle", -1, &(((cb__CircuitBreakerFilterStatisticsType*)a)->FilterCreationHandle), ""); + soap_out_unsignedInt(soap, "cb:ReadCount", -1, &(((cb__CircuitBreakerFilterStatisticsType*)a)->ReadCount), ""); + soap_out_bool(soap, "cb:FilterMatched", -1, &(((cb__CircuitBreakerFilterStatisticsType*)a)->FilterMatched), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerFilterStatisticsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerFilterStatisticsType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterStatisticsType(struct soap *soap, cb__CircuitBreakerFilterStatisticsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerFilterStatisticsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerFilterStatisticsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerFilterStatisticsType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterStatisticsType(struct soap *soap, const char *tag, cb__CircuitBreakerFilterStatisticsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerFilterStatisticsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType, sizeof(cb__CircuitBreakerFilterStatisticsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerFilterStatisticsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_FilterCreationHandle1 = 1, soap_flag_ReadCount1 = 1, soap_flag_FilterMatched1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_FilterCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:FilterCreationHandle", &(((cb__CircuitBreakerFilterStatisticsType*)a)->FilterCreationHandle), "xsd:unsignedInt")) + { soap_flag_FilterCreationHandle1--; + continue; + } + if (soap_flag_ReadCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:ReadCount", &(((cb__CircuitBreakerFilterStatisticsType*)a)->ReadCount), "xsd:unsignedInt")) + { soap_flag_ReadCount1--; + continue; + } + if (soap_flag_FilterMatched1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:FilterMatched", &(((cb__CircuitBreakerFilterStatisticsType*)a)->FilterMatched), "xsd:boolean")) + { soap_flag_FilterMatched1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_FilterCreationHandle1 > 0 || soap_flag_ReadCount1 > 0 || soap_flag_FilterMatched1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerFilterStatisticsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType, 0, sizeof(cb__CircuitBreakerFilterStatisticsType), 0, soap_copy_cb__CircuitBreakerFilterStatisticsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerFilterStatisticsType * SOAP_FMAC6 soap_new_cb__CircuitBreakerFilterStatisticsType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerFilterStatisticsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerFilterStatisticsType(struct soap *soap, cb__CircuitBreakerFilterStatisticsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerFilterStatisticsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerFilterStatisticsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerFilterStatisticsType; + if (size) + *size = sizeof(cb__CircuitBreakerFilterStatisticsType); + ((cb__CircuitBreakerFilterStatisticsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerFilterStatisticsType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerFilterStatisticsType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerFilterStatisticsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerFilterStatisticsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerFilterStatisticsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerFilterStatisticsType %p -> %p\n", q, p)); + *(cb__CircuitBreakerFilterStatisticsType*)p = *(cb__CircuitBreakerFilterStatisticsType*)q; +} + +void cb__CircuitBreakerCapabilitiesType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->HardwareDescription, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->HardwareDescription); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->HardwareID, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREMaxTxFilters, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREMaxTxCounters, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREMaxRxFilters, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREMaxRxCounters, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREAntiSpoofingCapable, SOAP_TYPE_bool); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREMaxTxFilters, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREMaxTxCounters, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREMaxRxFilters, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREMaxRxCounters, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREAntiSpoofingCapable, SOAP_TYPE_bool); + soap_embedded(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCORETo_USCOREIPv4_USCORERatio, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void cb__CircuitBreakerCapabilitiesType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->HardwareDescription); + soap_default_unsignedInt(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->HardwareID); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREMaxTxFilters); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREMaxTxCounters); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREMaxRxFilters); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREMaxRxCounters); + soap_default_bool(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv4_USCOREAntiSpoofingCapable); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREMaxTxFilters); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREMaxTxCounters); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREMaxRxFilters); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREMaxRxCounters); + soap_default_bool(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCOREAntiSpoofingCapable); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerCapabilitiesType*)this)->IPv6_USCORETo_USCOREIPv4_USCORERatio); + /* transient soap skipped */ +} + +int cb__CircuitBreakerCapabilitiesType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerCapabilitiesType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerCapabilitiesType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerCapabilitiesType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerCapabilitiesType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerCapabilitiesType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerCapabilitiesType), type); + soap_out_std__string(soap, "cb:HardwareDescription", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->HardwareDescription), ""); + soap_out_unsignedInt(soap, "cb:HardwareID", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->HardwareID), ""); + soap_out_unsignedShort(soap, "cb:IPv4_MaxTxFilters", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREMaxTxFilters), ""); + soap_out_unsignedShort(soap, "cb:IPv4_MaxTxCounters", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREMaxTxCounters), ""); + soap_out_unsignedShort(soap, "cb:IPv4_MaxRxFilters", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREMaxRxFilters), ""); + soap_out_unsignedShort(soap, "cb:IPv4_MaxRxCounters", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREMaxRxCounters), ""); + soap_out_bool(soap, "cb:IPv4_AntiSpoofingCapable", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREAntiSpoofingCapable), ""); + soap_out_unsignedShort(soap, "cb:IPv6_MaxTxFilters", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREMaxTxFilters), ""); + soap_out_unsignedShort(soap, "cb:IPv6_MaxTxCounters", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREMaxTxCounters), ""); + soap_out_unsignedShort(soap, "cb:IPv6_MaxRxFilters", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREMaxRxFilters), ""); + soap_out_unsignedShort(soap, "cb:IPv6_MaxRxCounters", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREMaxRxCounters), ""); + soap_out_bool(soap, "cb:IPv6_AntiSpoofingCapable", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREAntiSpoofingCapable), ""); + soap_out_unsignedShort(soap, "cb:IPv6_To_IPv4_Ratio", -1, &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCORETo_USCOREIPv4_USCORERatio), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerCapabilitiesType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerCapabilitiesType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType * SOAP_FMAC4 soap_get_cb__CircuitBreakerCapabilitiesType(struct soap *soap, cb__CircuitBreakerCapabilitiesType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerCapabilitiesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerCapabilitiesType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerCapabilitiesType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType * SOAP_FMAC4 soap_in_cb__CircuitBreakerCapabilitiesType(struct soap *soap, const char *tag, cb__CircuitBreakerCapabilitiesType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerCapabilitiesType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerCapabilitiesType, sizeof(cb__CircuitBreakerCapabilitiesType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerCapabilitiesType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerCapabilitiesType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_HardwareDescription1 = 1, soap_flag_HardwareID1 = 1, soap_flag_IPv4_USCOREMaxTxFilters1 = 1, soap_flag_IPv4_USCOREMaxTxCounters1 = 1, soap_flag_IPv4_USCOREMaxRxFilters1 = 1, soap_flag_IPv4_USCOREMaxRxCounters1 = 1, soap_flag_IPv4_USCOREAntiSpoofingCapable1 = 1, soap_flag_IPv6_USCOREMaxTxFilters1 = 1, soap_flag_IPv6_USCOREMaxTxCounters1 = 1, soap_flag_IPv6_USCOREMaxRxFilters1 = 1, soap_flag_IPv6_USCOREMaxRxCounters1 = 1, soap_flag_IPv6_USCOREAntiSpoofingCapable1 = 1, soap_flag_IPv6_USCORETo_USCOREIPv4_USCORERatio1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_HardwareDescription1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "cb:HardwareDescription", &(((cb__CircuitBreakerCapabilitiesType*)a)->HardwareDescription), "xsd:string")) + { soap_flag_HardwareDescription1--; + continue; + } + if (soap_flag_HardwareID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:HardwareID", &(((cb__CircuitBreakerCapabilitiesType*)a)->HardwareID), "xsd:unsignedInt")) + { soap_flag_HardwareID1--; + continue; + } + if (soap_flag_IPv4_USCOREMaxTxFilters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:IPv4_MaxTxFilters", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREMaxTxFilters), "xsd:unsignedShort")) + { soap_flag_IPv4_USCOREMaxTxFilters1--; + continue; + } + if (soap_flag_IPv4_USCOREMaxTxCounters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:IPv4_MaxTxCounters", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREMaxTxCounters), "xsd:unsignedShort")) + { soap_flag_IPv4_USCOREMaxTxCounters1--; + continue; + } + if (soap_flag_IPv4_USCOREMaxRxFilters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:IPv4_MaxRxFilters", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREMaxRxFilters), "xsd:unsignedShort")) + { soap_flag_IPv4_USCOREMaxRxFilters1--; + continue; + } + if (soap_flag_IPv4_USCOREMaxRxCounters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:IPv4_MaxRxCounters", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREMaxRxCounters), "xsd:unsignedShort")) + { soap_flag_IPv4_USCOREMaxRxCounters1--; + continue; + } + if (soap_flag_IPv4_USCOREAntiSpoofingCapable1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:IPv4_AntiSpoofingCapable", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv4_USCOREAntiSpoofingCapable), "xsd:boolean")) + { soap_flag_IPv4_USCOREAntiSpoofingCapable1--; + continue; + } + if (soap_flag_IPv6_USCOREMaxTxFilters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:IPv6_MaxTxFilters", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREMaxTxFilters), "xsd:unsignedShort")) + { soap_flag_IPv6_USCOREMaxTxFilters1--; + continue; + } + if (soap_flag_IPv6_USCOREMaxTxCounters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:IPv6_MaxTxCounters", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREMaxTxCounters), "xsd:unsignedShort")) + { soap_flag_IPv6_USCOREMaxTxCounters1--; + continue; + } + if (soap_flag_IPv6_USCOREMaxRxFilters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:IPv6_MaxRxFilters", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREMaxRxFilters), "xsd:unsignedShort")) + { soap_flag_IPv6_USCOREMaxRxFilters1--; + continue; + } + if (soap_flag_IPv6_USCOREMaxRxCounters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:IPv6_MaxRxCounters", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREMaxRxCounters), "xsd:unsignedShort")) + { soap_flag_IPv6_USCOREMaxRxCounters1--; + continue; + } + if (soap_flag_IPv6_USCOREAntiSpoofingCapable1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:IPv6_AntiSpoofingCapable", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCOREAntiSpoofingCapable), "xsd:boolean")) + { soap_flag_IPv6_USCOREAntiSpoofingCapable1--; + continue; + } + if (soap_flag_IPv6_USCORETo_USCOREIPv4_USCORERatio1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:IPv6_To_IPv4_Ratio", &(((cb__CircuitBreakerCapabilitiesType*)a)->IPv6_USCORETo_USCOREIPv4_USCORERatio), "xsd:unsignedShort")) + { soap_flag_IPv6_USCORETo_USCOREIPv4_USCORERatio1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_HardwareDescription1 > 0 || soap_flag_HardwareID1 > 0 || soap_flag_IPv4_USCOREMaxTxFilters1 > 0 || soap_flag_IPv4_USCOREMaxTxCounters1 > 0 || soap_flag_IPv4_USCOREMaxRxFilters1 > 0 || soap_flag_IPv4_USCOREMaxRxCounters1 > 0 || soap_flag_IPv4_USCOREAntiSpoofingCapable1 > 0 || soap_flag_IPv6_USCOREMaxTxFilters1 > 0 || soap_flag_IPv6_USCOREMaxTxCounters1 > 0 || soap_flag_IPv6_USCOREMaxRxFilters1 > 0 || soap_flag_IPv6_USCOREMaxRxCounters1 > 0 || soap_flag_IPv6_USCOREAntiSpoofingCapable1 > 0 || soap_flag_IPv6_USCORETo_USCOREIPv4_USCORERatio1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerCapabilitiesType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerCapabilitiesType, 0, sizeof(cb__CircuitBreakerCapabilitiesType), 0, soap_copy_cb__CircuitBreakerCapabilitiesType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerCapabilitiesType * SOAP_FMAC6 soap_new_cb__CircuitBreakerCapabilitiesType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerCapabilitiesType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerCapabilitiesType(struct soap *soap, cb__CircuitBreakerCapabilitiesType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerCapabilitiesType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerCapabilitiesType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerCapabilitiesType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerCapabilitiesType; + if (size) + *size = sizeof(cb__CircuitBreakerCapabilitiesType); + ((cb__CircuitBreakerCapabilitiesType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerCapabilitiesType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerCapabilitiesType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerCapabilitiesType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerCapabilitiesType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerCapabilitiesType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerCapabilitiesType %p -> %p\n", q, p)); + *(cb__CircuitBreakerCapabilitiesType*)p = *(cb__CircuitBreakerCapabilitiesType*)q; +} + +void cb__CircuitBreakerFilterInfoType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerFilterType(soap, &((cb__CircuitBreakerFilterInfoType*)this)->Filter); + soap_embedded(soap, &((cb__CircuitBreakerFilterInfoType*)this)->FilterCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void cb__CircuitBreakerFilterInfoType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerFilterInfoType*)this)->Filter = NULL; + soap_default_unsignedInt(soap, &((cb__CircuitBreakerFilterInfoType*)this)->FilterCreationHandle); + /* transient soap skipped */ +} + +int cb__CircuitBreakerFilterInfoType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerFilterInfoType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerFilterInfoType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerFilterInfoType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterInfoType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerFilterInfoType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerFilterInfoType), type); + soap_out_PointerTocb__CircuitBreakerFilterType(soap, "cb:Filter", -1, &(((cb__CircuitBreakerFilterInfoType*)a)->Filter), ""); + soap_out_unsignedInt(soap, "cb:FilterCreationHandle", -1, &(((cb__CircuitBreakerFilterInfoType*)a)->FilterCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerFilterInfoType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerFilterInfoType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterInfoType(struct soap *soap, cb__CircuitBreakerFilterInfoType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerFilterInfoType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerFilterInfoType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerFilterInfoType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterInfoType(struct soap *soap, const char *tag, cb__CircuitBreakerFilterInfoType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerFilterInfoType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerFilterInfoType, sizeof(cb__CircuitBreakerFilterInfoType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerFilterInfoType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerFilterInfoType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Filter1 = 1, soap_flag_FilterCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Filter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerFilterType(soap, "cb:Filter", &(((cb__CircuitBreakerFilterInfoType*)a)->Filter), "cb:CircuitBreakerFilterType")) + { soap_flag_Filter1--; + continue; + } + if (soap_flag_FilterCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:FilterCreationHandle", &(((cb__CircuitBreakerFilterInfoType*)a)->FilterCreationHandle), "xsd:unsignedInt")) + { soap_flag_FilterCreationHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Filter1 > 0 || soap_flag_FilterCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerFilterInfoType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerFilterInfoType, 0, sizeof(cb__CircuitBreakerFilterInfoType), 0, soap_copy_cb__CircuitBreakerFilterInfoType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerFilterInfoType * SOAP_FMAC6 soap_new_cb__CircuitBreakerFilterInfoType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerFilterInfoType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerFilterInfoType(struct soap *soap, cb__CircuitBreakerFilterInfoType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerFilterInfoType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerFilterInfoType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerFilterInfoType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerFilterInfoType; + if (size) + *size = sizeof(cb__CircuitBreakerFilterInfoType); + ((cb__CircuitBreakerFilterInfoType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerFilterInfoType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerFilterInfoType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerFilterInfoType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerFilterInfoType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerFilterInfoType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerFilterInfoType %p -> %p\n", q, p)); + *(cb__CircuitBreakerFilterInfoType*)p = *(cb__CircuitBreakerFilterInfoType*)q; +} + +void cb__CircuitBreakerFilterType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerFilterType*)this)->FilterProfileData, SOAP_TYPE_unsignedInt); + soap_serialize_PointerTocb__CircuitBreakerPacketType(soap, &((cb__CircuitBreakerFilterType*)this)->FilterPacket); + soap_embedded(soap, &((cb__CircuitBreakerFilterType*)this)->ActionEventOnMatch, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void cb__CircuitBreakerFilterType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerFilterType*)this)->FilterName = NULL; + soap_default_cb__CircuitBreakerFilterDirectionType(soap, &((cb__CircuitBreakerFilterType*)this)->FilterDirection); + soap_default_cb__CircuitBreakerProfileType(soap, &((cb__CircuitBreakerFilterType*)this)->FilterProfile); + soap_default_unsignedInt(soap, &((cb__CircuitBreakerFilterType*)this)->FilterProfileData); + ((cb__CircuitBreakerFilterType*)this)->FilterPacket = NULL; + soap_default_bool(soap, &((cb__CircuitBreakerFilterType*)this)->ActionEventOnMatch); + /* transient soap skipped */ +} + +int cb__CircuitBreakerFilterType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerFilterType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerFilterType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerFilterType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerFilterType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerFilterType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerFilterType), type); + soap_outliteral(soap, "cb:FilterName", &(((cb__CircuitBreakerFilterType*)a)->FilterName), NULL); + soap_out_cb__CircuitBreakerFilterDirectionType(soap, "cb:FilterDirection", -1, &(((cb__CircuitBreakerFilterType*)a)->FilterDirection), ""); + soap_out_cb__CircuitBreakerProfileType(soap, "cb:FilterProfile", -1, &(((cb__CircuitBreakerFilterType*)a)->FilterProfile), ""); + soap_out_unsignedInt(soap, "cb:FilterProfileData", -1, &(((cb__CircuitBreakerFilterType*)a)->FilterProfileData), ""); + soap_out_PointerTocb__CircuitBreakerPacketType(soap, "cb:FilterPacket", -1, &(((cb__CircuitBreakerFilterType*)a)->FilterPacket), ""); + soap_out_bool(soap, "cb:ActionEventOnMatch", -1, &(((cb__CircuitBreakerFilterType*)a)->ActionEventOnMatch), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerFilterType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerFilterType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterType * SOAP_FMAC4 soap_get_cb__CircuitBreakerFilterType(struct soap *soap, cb__CircuitBreakerFilterType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerFilterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerFilterType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerFilterType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterType * SOAP_FMAC4 soap_in_cb__CircuitBreakerFilterType(struct soap *soap, const char *tag, cb__CircuitBreakerFilterType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerFilterType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerFilterType, sizeof(cb__CircuitBreakerFilterType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerFilterType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerFilterType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_FilterName1 = 1, soap_flag_FilterDirection1 = 1, soap_flag_FilterProfile1 = 1, soap_flag_FilterProfileData1 = 1, soap_flag_FilterPacket1 = 1, soap_flag_ActionEventOnMatch1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_FilterName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_inliteral(soap, "cb:FilterName", &(((cb__CircuitBreakerFilterType*)a)->FilterName))) + { soap_flag_FilterName1--; + continue; + } + if (soap_flag_FilterDirection1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__CircuitBreakerFilterDirectionType(soap, "cb:FilterDirection", &(((cb__CircuitBreakerFilterType*)a)->FilterDirection), "cb:CircuitBreakerFilterDirectionType")) + { soap_flag_FilterDirection1--; + continue; + } + if (soap_flag_FilterProfile1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__CircuitBreakerProfileType(soap, "cb:FilterProfile", &(((cb__CircuitBreakerFilterType*)a)->FilterProfile), "cb:CircuitBreakerProfileType")) + { soap_flag_FilterProfile1--; + continue; + } + if (soap_flag_FilterProfileData1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:FilterProfileData", &(((cb__CircuitBreakerFilterType*)a)->FilterProfileData), "xsd:unsignedInt")) + { soap_flag_FilterProfileData1--; + continue; + } + if (soap_flag_FilterPacket1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerPacketType(soap, "cb:FilterPacket", &(((cb__CircuitBreakerFilterType*)a)->FilterPacket), "cb:CircuitBreakerPacketType")) + { soap_flag_FilterPacket1--; + continue; + } + if (soap_flag_ActionEventOnMatch1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:ActionEventOnMatch", &(((cb__CircuitBreakerFilterType*)a)->ActionEventOnMatch), "xsd:boolean")) + { soap_flag_ActionEventOnMatch1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_FilterDirection1 > 0 || soap_flag_FilterProfile1 > 0 || soap_flag_FilterProfileData1 > 0 || soap_flag_FilterPacket1 > 0 || soap_flag_ActionEventOnMatch1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerFilterType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerFilterType, 0, sizeof(cb__CircuitBreakerFilterType), 0, soap_copy_cb__CircuitBreakerFilterType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerFilterType * SOAP_FMAC6 soap_new_cb__CircuitBreakerFilterType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerFilterType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerFilterType(struct soap *soap, cb__CircuitBreakerFilterType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerFilterType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerFilterType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerFilterType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerFilterType; + if (size) + *size = sizeof(cb__CircuitBreakerFilterType); + ((cb__CircuitBreakerFilterType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerFilterType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerFilterType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerFilterType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerFilterType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerFilterType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerFilterType %p -> %p\n", q, p)); + *(cb__CircuitBreakerFilterType*)p = *(cb__CircuitBreakerFilterType*)q; +} + +void cb__CircuitBreakerPacketType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__cb__union_CircuitBreakerPacketType(soap, ((cb__CircuitBreakerPacketType*)this)->__union_CircuitBreakerPacketType, &((cb__CircuitBreakerPacketType*)this)->union_CircuitBreakerPacketType); + /* transient soap skipped */ +} + +void cb__CircuitBreakerPacketType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerPacketType*)this)->__union_CircuitBreakerPacketType = 0; + /* transient soap skipped */ +} + +int cb__CircuitBreakerPacketType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerPacketType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerPacketType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerPacketType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerPacketType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerPacketType), type); + soap_out__cb__union_CircuitBreakerPacketType(soap, ((cb__CircuitBreakerPacketType*)a)->__union_CircuitBreakerPacketType, &((cb__CircuitBreakerPacketType*)a)->union_CircuitBreakerPacketType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerPacketType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerPacketType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketType(struct soap *soap, cb__CircuitBreakerPacketType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerPacketType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerPacketType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerPacketType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerPacketType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerPacketType, sizeof(cb__CircuitBreakerPacketType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerPacketType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerPacketType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_CircuitBreakerPacketType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_CircuitBreakerPacketType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__cb__union_CircuitBreakerPacketType(soap, &((cb__CircuitBreakerPacketType*)a)->__union_CircuitBreakerPacketType, &((cb__CircuitBreakerPacketType*)a)->union_CircuitBreakerPacketType)) + { soap_flag_union_CircuitBreakerPacketType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_CircuitBreakerPacketType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerPacketType, 0, sizeof(cb__CircuitBreakerPacketType), 0, soap_copy_cb__CircuitBreakerPacketType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerPacketType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerPacketType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketType(struct soap *soap, cb__CircuitBreakerPacketType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerPacketType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerPacketType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerPacketType; + if (size) + *size = sizeof(cb__CircuitBreakerPacketType); + ((cb__CircuitBreakerPacketType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerPacketType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerPacketType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerPacketType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerPacketType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerPacketType %p -> %p\n", q, p)); + *(cb__CircuitBreakerPacketType*)p = *(cb__CircuitBreakerPacketType*)q; +} + +void cb__CircuitBreakerPacketETHType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerPacketETHType*)this)->EthernetFrameType, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void cb__CircuitBreakerPacketETHType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedShort(soap, &((cb__CircuitBreakerPacketETHType*)this)->EthernetFrameType); + /* transient soap skipped */ +} + +int cb__CircuitBreakerPacketETHType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerPacketETHType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerPacketETHType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerPacketETHType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketETHType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerPacketETHType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerPacketETHType), type); + soap_out_unsignedShort(soap, "cb:EthernetFrameType", -1, &(((cb__CircuitBreakerPacketETHType*)a)->EthernetFrameType), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerPacketETHType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerPacketETHType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketETHType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketETHType(struct soap *soap, cb__CircuitBreakerPacketETHType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerPacketETHType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerPacketETHType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerPacketETHType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketETHType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketETHType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketETHType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerPacketETHType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerPacketETHType, sizeof(cb__CircuitBreakerPacketETHType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerPacketETHType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerPacketETHType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_EthernetFrameType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_EthernetFrameType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:EthernetFrameType", &(((cb__CircuitBreakerPacketETHType*)a)->EthernetFrameType), "xsd:unsignedShort")) + { soap_flag_EthernetFrameType1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_EthernetFrameType1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketETHType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerPacketETHType, 0, sizeof(cb__CircuitBreakerPacketETHType), 0, soap_copy_cb__CircuitBreakerPacketETHType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerPacketETHType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketETHType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerPacketETHType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketETHType(struct soap *soap, cb__CircuitBreakerPacketETHType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketETHType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketETHType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerPacketETHType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerPacketETHType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerPacketETHType; + if (size) + *size = sizeof(cb__CircuitBreakerPacketETHType); + ((cb__CircuitBreakerPacketETHType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerPacketETHType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerPacketETHType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerPacketETHType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerPacketETHType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketETHType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerPacketETHType %p -> %p\n", q, p)); + *(cb__CircuitBreakerPacketETHType*)p = *(cb__CircuitBreakerPacketETHType*)q; +} + +void cb__CircuitBreakerPacketIPType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerIPPacketType(soap, &((cb__CircuitBreakerPacketIPType*)this)->IPPacket); + soap_serialize_PointerTounsignedShort(soap, &((cb__CircuitBreakerPacketIPType*)this)->NextProtocol); + /* transient soap skipped */ +} + +void cb__CircuitBreakerPacketIPType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerPacketIPType*)this)->IPPacket = NULL; + ((cb__CircuitBreakerPacketIPType*)this)->NextProtocol = NULL; + /* transient soap skipped */ +} + +int cb__CircuitBreakerPacketIPType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerPacketIPType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerPacketIPType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerPacketIPType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketIPType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerPacketIPType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerPacketIPType), type); + soap_out_PointerTocb__CircuitBreakerIPPacketType(soap, "cb:IPPacket", -1, &(((cb__CircuitBreakerPacketIPType*)a)->IPPacket), ""); + soap_out_PointerTounsignedShort(soap, "cb:NextProtocol", -1, &(((cb__CircuitBreakerPacketIPType*)a)->NextProtocol), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerPacketIPType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerPacketIPType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketIPType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketIPType(struct soap *soap, cb__CircuitBreakerPacketIPType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerPacketIPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerPacketIPType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerPacketIPType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketIPType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketIPType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketIPType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerPacketIPType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerPacketIPType, sizeof(cb__CircuitBreakerPacketIPType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerPacketIPType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerPacketIPType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_IPPacket1 = 1, soap_flag_NextProtocol1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_IPPacket1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerIPPacketType(soap, "cb:IPPacket", &(((cb__CircuitBreakerPacketIPType*)a)->IPPacket), "cb:CircuitBreakerIPPacketType")) + { soap_flag_IPPacket1--; + continue; + } + if (soap_flag_NextProtocol1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedShort(soap, "cb:NextProtocol", &(((cb__CircuitBreakerPacketIPType*)a)->NextProtocol), "xsd:unsignedShort")) + { soap_flag_NextProtocol1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_IPPacket1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketIPType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerPacketIPType, 0, sizeof(cb__CircuitBreakerPacketIPType), 0, soap_copy_cb__CircuitBreakerPacketIPType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerPacketIPType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketIPType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerPacketIPType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketIPType(struct soap *soap, cb__CircuitBreakerPacketIPType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketIPType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketIPType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerPacketIPType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerPacketIPType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerPacketIPType; + if (size) + *size = sizeof(cb__CircuitBreakerPacketIPType); + ((cb__CircuitBreakerPacketIPType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerPacketIPType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerPacketIPType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerPacketIPType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerPacketIPType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketIPType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerPacketIPType %p -> %p\n", q, p)); + *(cb__CircuitBreakerPacketIPType*)p = *(cb__CircuitBreakerPacketIPType*)q; +} + +void cb__CircuitBreakerPacketTCPType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(soap, &((cb__CircuitBreakerPacketTCPType*)this)->TCPFlags); + soap_serialize_PointerTocb__CircuitBreakerIPPacketType(soap, &((cb__CircuitBreakerPacketUDPType*)this)->IPPacket); + soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortType(soap, &((cb__CircuitBreakerPacketUDPType*)this)->IPLayeredPort); + /* transient soap skipped */ +} + +void cb__CircuitBreakerPacketTCPType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerPacketTCPType*)this)->TCPFlags = NULL; + ((cb__CircuitBreakerPacketUDPType*)this)->IPPacket = NULL; + ((cb__CircuitBreakerPacketUDPType*)this)->IPLayeredPort = NULL; + /* transient soap skipped */ +} + +int cb__CircuitBreakerPacketTCPType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerPacketTCPType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerPacketTCPType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerPacketTCPType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketTCPType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerPacketTCPType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerPacketTCPType), "cb:CircuitBreakerPacketTCPType"); + soap_out_PointerTocb__CircuitBreakerIPPacketType(soap, "cb:IPPacket", -1, &(((cb__CircuitBreakerPacketUDPType*)a)->IPPacket), ""); + soap_out_PointerTocb__CircuitBreakerIPLayeredPortType(soap, "cb:IPLayeredPort", -1, &(((cb__CircuitBreakerPacketUDPType*)a)->IPLayeredPort), ""); + /* transient soap skipped */ + soap_out_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(soap, "cb:TCPFlags", -1, &(((cb__CircuitBreakerPacketTCPType*)a)->TCPFlags), ""); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerPacketTCPType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerPacketTCPType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketTCPType(struct soap *soap, cb__CircuitBreakerPacketTCPType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerPacketTCPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerPacketTCPType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerPacketTCPType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketTCPType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketTCPType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerPacketTCPType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerPacketTCPType, sizeof(cb__CircuitBreakerPacketTCPType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerPacketTCPType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerPacketTCPType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_IPPacket2 = 1, soap_flag_IPLayeredPort2 = 1, soap_flag_TCPFlags1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_IPPacket2 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerIPPacketType(soap, "cb:IPPacket", &(((cb__CircuitBreakerPacketUDPType*)a)->IPPacket), "cb:CircuitBreakerIPPacketType")) + { soap_flag_IPPacket2--; + continue; + } + if (soap_flag_IPLayeredPort2 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerIPLayeredPortType(soap, "cb:IPLayeredPort", &(((cb__CircuitBreakerPacketUDPType*)a)->IPLayeredPort), "cb:CircuitBreakerIPLayeredPortType")) + { soap_flag_IPLayeredPort2--; + continue; + } + /* transient soap skipped */ + if (soap_flag_TCPFlags1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(soap, "cb:TCPFlags", &(((cb__CircuitBreakerPacketTCPType*)a)->TCPFlags), "cb:CircuitBreakerIPLayeredTCPFlagsType")) + { soap_flag_TCPFlags1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_IPPacket2 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketTCPType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerPacketTCPType, 0, sizeof(cb__CircuitBreakerPacketTCPType), 0, soap_copy_cb__CircuitBreakerPacketTCPType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerPacketTCPType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketTCPType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerPacketTCPType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketTCPType(struct soap *soap, cb__CircuitBreakerPacketTCPType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketTCPType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerPacketTCPType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerPacketTCPType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerPacketTCPType; + if (size) + *size = sizeof(cb__CircuitBreakerPacketTCPType); + ((cb__CircuitBreakerPacketTCPType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerPacketTCPType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerPacketTCPType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerPacketTCPType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerPacketTCPType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketTCPType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerPacketTCPType %p -> %p\n", q, p)); + *(cb__CircuitBreakerPacketTCPType*)p = *(cb__CircuitBreakerPacketTCPType*)q; +} + +void cb__CircuitBreakerPacketUDPType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerIPPacketType(soap, &((cb__CircuitBreakerPacketUDPType*)this)->IPPacket); + soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortType(soap, &((cb__CircuitBreakerPacketUDPType*)this)->IPLayeredPort); + /* transient soap skipped */ +} + +void cb__CircuitBreakerPacketUDPType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerPacketUDPType*)this)->IPPacket = NULL; + ((cb__CircuitBreakerPacketUDPType*)this)->IPLayeredPort = NULL; + /* transient soap skipped */ +} + +int cb__CircuitBreakerPacketUDPType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerPacketUDPType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerPacketUDPType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerPacketUDPType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPacketUDPType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerPacketUDPType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerPacketUDPType), type); + soap_out_PointerTocb__CircuitBreakerIPPacketType(soap, "cb:IPPacket", -1, &(((cb__CircuitBreakerPacketUDPType*)a)->IPPacket), ""); + soap_out_PointerTocb__CircuitBreakerIPLayeredPortType(soap, "cb:IPLayeredPort", -1, &(((cb__CircuitBreakerPacketUDPType*)a)->IPLayeredPort), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerPacketUDPType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerPacketUDPType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPacketUDPType(struct soap *soap, cb__CircuitBreakerPacketUDPType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerPacketUDPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerPacketUDPType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerPacketUDPType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPacketUDPType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketUDPType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerPacketUDPType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerPacketUDPType, sizeof(cb__CircuitBreakerPacketUDPType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerPacketUDPType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerPacketUDPType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_IPPacket1 = 1, soap_flag_IPLayeredPort1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_IPPacket1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerIPPacketType(soap, "cb:IPPacket", &(((cb__CircuitBreakerPacketUDPType*)a)->IPPacket), "cb:CircuitBreakerIPPacketType")) + { soap_flag_IPPacket1--; + continue; + } + if (soap_flag_IPLayeredPort1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerIPLayeredPortType(soap, "cb:IPLayeredPort", &(((cb__CircuitBreakerPacketUDPType*)a)->IPLayeredPort), "cb:CircuitBreakerIPLayeredPortType")) + { soap_flag_IPLayeredPort1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_IPPacket1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketUDPType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerPacketUDPType, 0, sizeof(cb__CircuitBreakerPacketUDPType), 0, soap_copy_cb__CircuitBreakerPacketUDPType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerPacketUDPType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPacketUDPType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerPacketUDPType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPacketUDPType(struct soap *soap, cb__CircuitBreakerPacketUDPType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPacketUDPType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerPacketUDPType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerPacketUDPType, n, soap_fdelete); + if (!cp) + return NULL; + if (type && !soap_match_tag(soap, type, "cb:CircuitBreakerPacketTCPType")) + { cp->type = SOAP_TYPE_cb__CircuitBreakerPacketTCPType; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerPacketTCPType; + if (size) + *size = sizeof(cb__CircuitBreakerPacketTCPType); + ((cb__CircuitBreakerPacketTCPType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerPacketTCPType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerPacketTCPType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerPacketTCPType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerPacketTCPType*)cp->ptr; + } + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerPacketUDPType; + if (size) + *size = sizeof(cb__CircuitBreakerPacketUDPType); + ((cb__CircuitBreakerPacketUDPType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerPacketUDPType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerPacketUDPType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerPacketUDPType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerPacketUDPType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPacketUDPType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerPacketUDPType %p -> %p\n", q, p)); + *(cb__CircuitBreakerPacketUDPType*)p = *(cb__CircuitBreakerPacketUDPType*)q; +} + +void cb__CircuitBreakerIPPacketType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__cb__union_CircuitBreakerIPPacketType(soap, ((cb__CircuitBreakerIPPacketType*)this)->__union_CircuitBreakerIPPacketType, &((cb__CircuitBreakerIPPacketType*)this)->union_CircuitBreakerIPPacketType); + /* transient soap skipped */ +} + +void cb__CircuitBreakerIPPacketType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerIPPacketType*)this)->__union_CircuitBreakerIPPacketType = 0; + /* transient soap skipped */ +} + +int cb__CircuitBreakerIPPacketType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerIPPacketType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerIPPacketType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerIPPacketType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPPacketType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerIPPacketType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerIPPacketType), type); + soap_out__cb__union_CircuitBreakerIPPacketType(soap, ((cb__CircuitBreakerIPPacketType*)a)->__union_CircuitBreakerIPPacketType, &((cb__CircuitBreakerIPPacketType*)a)->union_CircuitBreakerIPPacketType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerIPPacketType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerIPPacketType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPPacketType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPPacketType(struct soap *soap, cb__CircuitBreakerIPPacketType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerIPPacketType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerIPPacketType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerIPPacketType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPPacketType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPPacketType(struct soap *soap, const char *tag, cb__CircuitBreakerIPPacketType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerIPPacketType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerIPPacketType, sizeof(cb__CircuitBreakerIPPacketType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerIPPacketType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerIPPacketType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_CircuitBreakerIPPacketType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_CircuitBreakerIPPacketType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__cb__union_CircuitBreakerIPPacketType(soap, &((cb__CircuitBreakerIPPacketType*)a)->__union_CircuitBreakerIPPacketType, &((cb__CircuitBreakerIPPacketType*)a)->union_CircuitBreakerIPPacketType)) + { soap_flag_union_CircuitBreakerIPPacketType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_CircuitBreakerIPPacketType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPPacketType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerIPPacketType, 0, sizeof(cb__CircuitBreakerIPPacketType), 0, soap_copy_cb__CircuitBreakerIPPacketType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerIPPacketType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPPacketType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerIPPacketType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPPacketType(struct soap *soap, cb__CircuitBreakerIPPacketType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerIPPacketType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPPacketType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerIPPacketType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerIPPacketType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerIPPacketType; + if (size) + *size = sizeof(cb__CircuitBreakerIPPacketType); + ((cb__CircuitBreakerIPPacketType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerIPPacketType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerIPPacketType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerIPPacketType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerIPPacketType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPPacketType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerIPPacketType %p -> %p\n", q, p)); + *(cb__CircuitBreakerIPPacketType*)p = *(cb__CircuitBreakerIPPacketType*)q; +} + +void cb__CircuitBreakerIPv6Type::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(soap, &((cb__CircuitBreakerIPv6Type*)this)->IPv6Desc); + /* transient soap skipped */ +} + +void cb__CircuitBreakerIPv6Type::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerIPv6Type*)this)->IPv6Desc = NULL; + /* transient soap skipped */ +} + +int cb__CircuitBreakerIPv6Type::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerIPv6Type); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerIPv6Type::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerIPv6Type(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPv6Type(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerIPv6Type *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerIPv6Type), type); + soap_out_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(soap, "cb:IPv6Desc", -1, &(((cb__CircuitBreakerIPv6Type*)a)->IPv6Desc), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerIPv6Type::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerIPv6Type(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6Type * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPv6Type(struct soap *soap, cb__CircuitBreakerIPv6Type *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerIPv6Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerIPv6Type::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerIPv6Type(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6Type * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPv6Type(struct soap *soap, const char *tag, cb__CircuitBreakerIPv6Type *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerIPv6Type *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerIPv6Type, sizeof(cb__CircuitBreakerIPv6Type), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerIPv6Type) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerIPv6Type *)a->soap_in(soap, tag, type); + } + } + short soap_flag_IPv6Desc1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_IPv6Desc1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(soap, "cb:IPv6Desc", &(((cb__CircuitBreakerIPv6Type*)a)->IPv6Desc), "cb:CircuitBreakerIPv6AddressAndMaskType")) + { soap_flag_IPv6Desc1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPv6Type *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerIPv6Type, 0, sizeof(cb__CircuitBreakerIPv6Type), 0, soap_copy_cb__CircuitBreakerIPv6Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerIPv6Type * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPv6Type(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerIPv6Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPv6Type(struct soap *soap, cb__CircuitBreakerIPv6Type *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6Type * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPv6Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerIPv6Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerIPv6Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerIPv6Type; + if (size) + *size = sizeof(cb__CircuitBreakerIPv6Type); + ((cb__CircuitBreakerIPv6Type*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerIPv6Type[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerIPv6Type); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerIPv6Type*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerIPv6Type*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPv6Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerIPv6Type %p -> %p\n", q, p)); + *(cb__CircuitBreakerIPv6Type*)p = *(cb__CircuitBreakerIPv6Type*)q; +} + +void cb__CircuitBreakerIPv4Type::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(soap, &((cb__CircuitBreakerIPv4Type*)this)->IPv4Desc); + /* transient soap skipped */ +} + +void cb__CircuitBreakerIPv4Type::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerIPv4Type*)this)->IPv4Desc = NULL; + /* transient soap skipped */ +} + +int cb__CircuitBreakerIPv4Type::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerIPv4Type); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerIPv4Type::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerIPv4Type(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPv4Type(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerIPv4Type *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerIPv4Type), type); + soap_out_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(soap, "cb:IPv4Desc", -1, &(((cb__CircuitBreakerIPv4Type*)a)->IPv4Desc), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerIPv4Type::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerIPv4Type(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4Type * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPv4Type(struct soap *soap, cb__CircuitBreakerIPv4Type *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerIPv4Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerIPv4Type::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerIPv4Type(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4Type * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPv4Type(struct soap *soap, const char *tag, cb__CircuitBreakerIPv4Type *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerIPv4Type *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerIPv4Type, sizeof(cb__CircuitBreakerIPv4Type), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerIPv4Type) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerIPv4Type *)a->soap_in(soap, tag, type); + } + } + short soap_flag_IPv4Desc1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_IPv4Desc1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(soap, "cb:IPv4Desc", &(((cb__CircuitBreakerIPv4Type*)a)->IPv4Desc), "cb:CircuitBreakerIPv4AddressAndMaskType")) + { soap_flag_IPv4Desc1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPv4Type *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerIPv4Type, 0, sizeof(cb__CircuitBreakerIPv4Type), 0, soap_copy_cb__CircuitBreakerIPv4Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerIPv4Type * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPv4Type(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerIPv4Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPv4Type(struct soap *soap, cb__CircuitBreakerIPv4Type *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4Type * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPv4Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerIPv4Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerIPv4Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerIPv4Type; + if (size) + *size = sizeof(cb__CircuitBreakerIPv4Type); + ((cb__CircuitBreakerIPv4Type*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerIPv4Type[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerIPv4Type); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerIPv4Type*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerIPv4Type*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPv4Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerIPv4Type %p -> %p\n", q, p)); + *(cb__CircuitBreakerIPv4Type*)p = *(cb__CircuitBreakerIPv4Type*)q; +} + +void cb__CircuitBreakerIPLayeredTCPFlagsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREFIN); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCORESYN); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCORERST); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREPUSH); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREACK); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREURG); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREECNE); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCORECWR); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCORENS); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREReserved1); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREReserved2); + soap_serialize_PointerTobool(soap, &((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREReserved3); + /* transient soap skipped */ +} + +void cb__CircuitBreakerIPLayeredTCPFlagsType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREFIN = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCORESYN = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCORERST = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREPUSH = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREACK = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREURG = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREECNE = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCORECWR = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCORENS = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREReserved1 = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREReserved2 = NULL; + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)this)->TCP_USCOREFLAG_USCOREReserved3 = NULL; + /* transient soap skipped */ +} + +int cb__CircuitBreakerIPLayeredTCPFlagsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerIPLayeredTCPFlagsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerIPLayeredTCPFlagsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerIPLayeredTCPFlagsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType), type); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_FIN", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREFIN), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_SYN", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCORESYN), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_RST", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCORERST), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_PUSH", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREPUSH), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_ACK", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREACK), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_URG", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREURG), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_ECNE", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREECNE), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_CWR", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCORECWR), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_NS", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCORENS), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_Reserved1", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREReserved1), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_Reserved2", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREReserved2), ""); + soap_out_PointerTobool(soap, "cb:TCP_FLAG_Reserved3", -1, &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREReserved3), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerIPLayeredTCPFlagsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerIPLayeredTCPFlagsType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, cb__CircuitBreakerIPLayeredTCPFlagsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerIPLayeredTCPFlagsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerIPLayeredTCPFlagsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerIPLayeredTCPFlagsType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, const char *tag, cb__CircuitBreakerIPLayeredTCPFlagsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerIPLayeredTCPFlagsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType, sizeof(cb__CircuitBreakerIPLayeredTCPFlagsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerIPLayeredTCPFlagsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_TCP_USCOREFLAG_USCOREFIN1 = 1, soap_flag_TCP_USCOREFLAG_USCORESYN1 = 1, soap_flag_TCP_USCOREFLAG_USCORERST1 = 1, soap_flag_TCP_USCOREFLAG_USCOREPUSH1 = 1, soap_flag_TCP_USCOREFLAG_USCOREACK1 = 1, soap_flag_TCP_USCOREFLAG_USCOREURG1 = 1, soap_flag_TCP_USCOREFLAG_USCOREECNE1 = 1, soap_flag_TCP_USCOREFLAG_USCORECWR1 = 1, soap_flag_TCP_USCOREFLAG_USCORENS1 = 1, soap_flag_TCP_USCOREFLAG_USCOREReserved11 = 1, soap_flag_TCP_USCOREFLAG_USCOREReserved21 = 1, soap_flag_TCP_USCOREFLAG_USCOREReserved31 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_TCP_USCOREFLAG_USCOREFIN1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_FIN", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREFIN), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCOREFIN1--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCORESYN1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_SYN", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCORESYN), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCORESYN1--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCORERST1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_RST", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCORERST), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCORERST1--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCOREPUSH1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_PUSH", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREPUSH), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCOREPUSH1--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCOREACK1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_ACK", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREACK), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCOREACK1--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCOREURG1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_URG", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREURG), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCOREURG1--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCOREECNE1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_ECNE", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREECNE), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCOREECNE1--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCORECWR1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_CWR", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCORECWR), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCORECWR1--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCORENS1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_NS", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCORENS), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCORENS1--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCOREReserved11 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_Reserved1", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREReserved1), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCOREReserved11--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCOREReserved21 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_Reserved2", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREReserved2), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCOREReserved21--; + continue; + } + if (soap_flag_TCP_USCOREFLAG_USCOREReserved31 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "cb:TCP_FLAG_Reserved3", &(((cb__CircuitBreakerIPLayeredTCPFlagsType*)a)->TCP_USCOREFLAG_USCOREReserved3), "xsd:boolean")) + { soap_flag_TCP_USCOREFLAG_USCOREReserved31--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPLayeredTCPFlagsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType, 0, sizeof(cb__CircuitBreakerIPLayeredTCPFlagsType), 0, soap_copy_cb__CircuitBreakerIPLayeredTCPFlagsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerIPLayeredTCPFlagsType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerIPLayeredTCPFlagsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, cb__CircuitBreakerIPLayeredTCPFlagsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerIPLayeredTCPFlagsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerIPLayeredTCPFlagsType; + if (size) + *size = sizeof(cb__CircuitBreakerIPLayeredTCPFlagsType); + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerIPLayeredTCPFlagsType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerIPLayeredTCPFlagsType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerIPLayeredTCPFlagsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerIPLayeredTCPFlagsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerIPLayeredTCPFlagsType %p -> %p\n", q, p)); + *(cb__CircuitBreakerIPLayeredTCPFlagsType*)p = *(cb__CircuitBreakerIPLayeredTCPFlagsType*)q; +} + +void cb__CircuitBreakerIPLayeredPortType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__cb__union_CircuitBreakerIPLayeredPortType(soap, ((cb__CircuitBreakerIPLayeredPortType*)this)->__union_CircuitBreakerIPLayeredPortType, &((cb__CircuitBreakerIPLayeredPortType*)this)->union_CircuitBreakerIPLayeredPortType); + /* transient soap skipped */ +} + +void cb__CircuitBreakerIPLayeredPortType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerIPLayeredPortType*)this)->__union_CircuitBreakerIPLayeredPortType = 0; + /* transient soap skipped */ +} + +int cb__CircuitBreakerIPLayeredPortType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerIPLayeredPortType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerIPLayeredPortType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPLayeredPortType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerIPLayeredPortType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType), type); + soap_out__cb__union_CircuitBreakerIPLayeredPortType(soap, ((cb__CircuitBreakerIPLayeredPortType*)a)->__union_CircuitBreakerIPLayeredPortType, &((cb__CircuitBreakerIPLayeredPortType*)a)->union_CircuitBreakerIPLayeredPortType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerIPLayeredPortType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerIPLayeredPortType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPLayeredPortType(struct soap *soap, cb__CircuitBreakerIPLayeredPortType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerIPLayeredPortType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerIPLayeredPortType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerIPLayeredPortType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPLayeredPortType(struct soap *soap, const char *tag, cb__CircuitBreakerIPLayeredPortType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerIPLayeredPortType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType, sizeof(cb__CircuitBreakerIPLayeredPortType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerIPLayeredPortType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_CircuitBreakerIPLayeredPortType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_CircuitBreakerIPLayeredPortType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__cb__union_CircuitBreakerIPLayeredPortType(soap, &((cb__CircuitBreakerIPLayeredPortType*)a)->__union_CircuitBreakerIPLayeredPortType, &((cb__CircuitBreakerIPLayeredPortType*)a)->union_CircuitBreakerIPLayeredPortType)) + { soap_flag_union_CircuitBreakerIPLayeredPortType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_CircuitBreakerIPLayeredPortType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPLayeredPortType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType, 0, sizeof(cb__CircuitBreakerIPLayeredPortType), 0, soap_copy_cb__CircuitBreakerIPLayeredPortType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerIPLayeredPortType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPLayeredPortType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerIPLayeredPortType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPLayeredPortType(struct soap *soap, cb__CircuitBreakerIPLayeredPortType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPLayeredPortType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerIPLayeredPortType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerIPLayeredPortType; + if (size) + *size = sizeof(cb__CircuitBreakerIPLayeredPortType); + ((cb__CircuitBreakerIPLayeredPortType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerIPLayeredPortType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerIPLayeredPortType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerIPLayeredPortType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerIPLayeredPortType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPLayeredPortType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerIPLayeredPortType %p -> %p\n", q, p)); + *(cb__CircuitBreakerIPLayeredPortType*)p = *(cb__CircuitBreakerIPLayeredPortType*)q; +} + +void cb__CircuitBreakerIPLayeredPortRangeType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerIPLayeredPortRangeType*)this)->PortMin, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerIPLayeredPortRangeType*)this)->PortMax, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void cb__CircuitBreakerIPLayeredPortRangeType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedShort(soap, &((cb__CircuitBreakerIPLayeredPortRangeType*)this)->PortMin); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerIPLayeredPortRangeType*)this)->PortMax); + /* transient soap skipped */ +} + +int cb__CircuitBreakerIPLayeredPortRangeType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerIPLayeredPortRangeType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerIPLayeredPortRangeType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerIPLayeredPortRangeType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType), type); + soap_out_unsignedShort(soap, "cb:PortMin", -1, &(((cb__CircuitBreakerIPLayeredPortRangeType*)a)->PortMin), ""); + soap_out_unsignedShort(soap, "cb:PortMax", -1, &(((cb__CircuitBreakerIPLayeredPortRangeType*)a)->PortMax), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerIPLayeredPortRangeType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerIPLayeredPortRangeType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, cb__CircuitBreakerIPLayeredPortRangeType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerIPLayeredPortRangeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerIPLayeredPortRangeType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerIPLayeredPortRangeType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, const char *tag, cb__CircuitBreakerIPLayeredPortRangeType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerIPLayeredPortRangeType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType, sizeof(cb__CircuitBreakerIPLayeredPortRangeType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerIPLayeredPortRangeType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PortMin1 = 1, soap_flag_PortMax1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PortMin1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:PortMin", &(((cb__CircuitBreakerIPLayeredPortRangeType*)a)->PortMin), "xsd:unsignedShort")) + { soap_flag_PortMin1--; + continue; + } + if (soap_flag_PortMax1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:PortMax", &(((cb__CircuitBreakerIPLayeredPortRangeType*)a)->PortMax), "xsd:unsignedShort")) + { soap_flag_PortMax1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PortMin1 > 0 || soap_flag_PortMax1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPLayeredPortRangeType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType, 0, sizeof(cb__CircuitBreakerIPLayeredPortRangeType), 0, soap_copy_cb__CircuitBreakerIPLayeredPortRangeType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerIPLayeredPortRangeType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerIPLayeredPortRangeType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, cb__CircuitBreakerIPLayeredPortRangeType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerIPLayeredPortRangeType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerIPLayeredPortRangeType; + if (size) + *size = sizeof(cb__CircuitBreakerIPLayeredPortRangeType); + ((cb__CircuitBreakerIPLayeredPortRangeType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerIPLayeredPortRangeType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerIPLayeredPortRangeType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerIPLayeredPortRangeType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerIPLayeredPortRangeType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerIPLayeredPortRangeType %p -> %p\n", q, p)); + *(cb__CircuitBreakerIPLayeredPortRangeType*)p = *(cb__CircuitBreakerIPLayeredPortRangeType*)q; +} + +void cb__CircuitBreakerIPLayeredPortSimpleType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerIPLayeredPortSimpleType*)this)->SourcePort, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((cb__CircuitBreakerIPLayeredPortSimpleType*)this)->DestinationPort, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void cb__CircuitBreakerIPLayeredPortSimpleType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedShort(soap, &((cb__CircuitBreakerIPLayeredPortSimpleType*)this)->SourcePort); + soap_default_unsignedShort(soap, &((cb__CircuitBreakerIPLayeredPortSimpleType*)this)->DestinationPort); + /* transient soap skipped */ +} + +int cb__CircuitBreakerIPLayeredPortSimpleType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerIPLayeredPortSimpleType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerIPLayeredPortSimpleType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerIPLayeredPortSimpleType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType), type); + soap_out_unsignedShort(soap, "cb:SourcePort", -1, &(((cb__CircuitBreakerIPLayeredPortSimpleType*)a)->SourcePort), ""); + soap_out_unsignedShort(soap, "cb:DestinationPort", -1, &(((cb__CircuitBreakerIPLayeredPortSimpleType*)a)->DestinationPort), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerIPLayeredPortSimpleType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerIPLayeredPortSimpleType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, cb__CircuitBreakerIPLayeredPortSimpleType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerIPLayeredPortSimpleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerIPLayeredPortSimpleType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerIPLayeredPortSimpleType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, const char *tag, cb__CircuitBreakerIPLayeredPortSimpleType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerIPLayeredPortSimpleType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType, sizeof(cb__CircuitBreakerIPLayeredPortSimpleType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerIPLayeredPortSimpleType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_SourcePort1 = 1, soap_flag_DestinationPort1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_SourcePort1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:SourcePort", &(((cb__CircuitBreakerIPLayeredPortSimpleType*)a)->SourcePort), "xsd:unsignedShort")) + { soap_flag_SourcePort1--; + continue; + } + if (soap_flag_DestinationPort1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "cb:DestinationPort", &(((cb__CircuitBreakerIPLayeredPortSimpleType*)a)->DestinationPort), "xsd:unsignedShort")) + { soap_flag_DestinationPort1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_SourcePort1 > 0 || soap_flag_DestinationPort1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPLayeredPortSimpleType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType, 0, sizeof(cb__CircuitBreakerIPLayeredPortSimpleType), 0, soap_copy_cb__CircuitBreakerIPLayeredPortSimpleType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerIPLayeredPortSimpleType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerIPLayeredPortSimpleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, cb__CircuitBreakerIPLayeredPortSimpleType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerIPLayeredPortSimpleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerIPLayeredPortSimpleType; + if (size) + *size = sizeof(cb__CircuitBreakerIPLayeredPortSimpleType); + ((cb__CircuitBreakerIPLayeredPortSimpleType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerIPLayeredPortSimpleType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerIPLayeredPortSimpleType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerIPLayeredPortSimpleType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerIPLayeredPortSimpleType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerIPLayeredPortSimpleType %p -> %p\n", q, p)); + *(cb__CircuitBreakerIPLayeredPortSimpleType*)p = *(cb__CircuitBreakerIPLayeredPortSimpleType*)q; +} + +void cb__CircuitBreakerIPv6AddressAndMaskType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_cb__IPv6AddressStringType(soap, &((cb__CircuitBreakerIPv6AddressAndMaskType*)this)->Address); + soap_serialize_cb__IPv6AddressStringType(soap, &((cb__CircuitBreakerIPv6AddressAndMaskType*)this)->AddressMask); + /* transient soap skipped */ +} + +void cb__CircuitBreakerIPv6AddressAndMaskType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__CircuitBreakerFilterIPAddressDirectionType(soap, &((cb__CircuitBreakerIPv6AddressAndMaskType*)this)->IPAddressDirection); + soap_default_cb__IPv6AddressStringType(soap, &((cb__CircuitBreakerIPv6AddressAndMaskType*)this)->Address); + soap_default_cb__IPv6AddressStringType(soap, &((cb__CircuitBreakerIPv6AddressAndMaskType*)this)->AddressMask); + /* transient soap skipped */ +} + +int cb__CircuitBreakerIPv6AddressAndMaskType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerIPv6AddressAndMaskType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerIPv6AddressAndMaskType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerIPv6AddressAndMaskType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType), type); + soap_out_cb__CircuitBreakerFilterIPAddressDirectionType(soap, "cb:IPAddressDirection", -1, &(((cb__CircuitBreakerIPv6AddressAndMaskType*)a)->IPAddressDirection), ""); + soap_out_cb__IPv6AddressStringType(soap, "cb:Address", -1, &(((cb__CircuitBreakerIPv6AddressAndMaskType*)a)->Address), ""); + soap_out_cb__IPv6AddressStringType(soap, "cb:AddressMask", -1, &(((cb__CircuitBreakerIPv6AddressAndMaskType*)a)->AddressMask), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerIPv6AddressAndMaskType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerIPv6AddressAndMaskType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv6AddressAndMaskType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerIPv6AddressAndMaskType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerIPv6AddressAndMaskType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerIPv6AddressAndMaskType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, const char *tag, cb__CircuitBreakerIPv6AddressAndMaskType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerIPv6AddressAndMaskType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType, sizeof(cb__CircuitBreakerIPv6AddressAndMaskType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerIPv6AddressAndMaskType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_IPAddressDirection1 = 1, soap_flag_Address1 = 1, soap_flag_AddressMask1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_IPAddressDirection1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__CircuitBreakerFilterIPAddressDirectionType(soap, "cb:IPAddressDirection", &(((cb__CircuitBreakerIPv6AddressAndMaskType*)a)->IPAddressDirection), "cb:CircuitBreakerFilterIPAddressDirectionType")) + { soap_flag_IPAddressDirection1--; + continue; + } + if (soap_flag_Address1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_cb__IPv6AddressStringType(soap, "cb:Address", &(((cb__CircuitBreakerIPv6AddressAndMaskType*)a)->Address), "cb:IPv6AddressStringType")) + { soap_flag_Address1--; + continue; + } + if (soap_flag_AddressMask1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_cb__IPv6AddressStringType(soap, "cb:AddressMask", &(((cb__CircuitBreakerIPv6AddressAndMaskType*)a)->AddressMask), "cb:IPv6AddressStringType")) + { soap_flag_AddressMask1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_IPAddressDirection1 > 0 || soap_flag_Address1 > 0 || soap_flag_AddressMask1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPv6AddressAndMaskType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType, 0, sizeof(cb__CircuitBreakerIPv6AddressAndMaskType), 0, soap_copy_cb__CircuitBreakerIPv6AddressAndMaskType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerIPv6AddressAndMaskType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerIPv6AddressAndMaskType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv6AddressAndMaskType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerIPv6AddressAndMaskType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerIPv6AddressAndMaskType; + if (size) + *size = sizeof(cb__CircuitBreakerIPv6AddressAndMaskType); + ((cb__CircuitBreakerIPv6AddressAndMaskType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerIPv6AddressAndMaskType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerIPv6AddressAndMaskType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerIPv6AddressAndMaskType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerIPv6AddressAndMaskType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerIPv6AddressAndMaskType %p -> %p\n", q, p)); + *(cb__CircuitBreakerIPv6AddressAndMaskType*)p = *(cb__CircuitBreakerIPv6AddressAndMaskType*)q; +} + +void cb__CircuitBreakerIPv4AddressAndMaskType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_cb__IPv4AddressStringType(soap, &((cb__CircuitBreakerIPv4AddressAndMaskType*)this)->Address); + soap_serialize_cb__IPv4AddressStringType(soap, &((cb__CircuitBreakerIPv4AddressAndMaskType*)this)->AddressMask); + /* transient soap skipped */ +} + +void cb__CircuitBreakerIPv4AddressAndMaskType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cb__CircuitBreakerFilterIPAddressDirectionType(soap, &((cb__CircuitBreakerIPv4AddressAndMaskType*)this)->IPAddressDirection); + soap_default_cb__IPv4AddressStringType(soap, &((cb__CircuitBreakerIPv4AddressAndMaskType*)this)->Address); + soap_default_cb__IPv4AddressStringType(soap, &((cb__CircuitBreakerIPv4AddressAndMaskType*)this)->AddressMask); + /* transient soap skipped */ +} + +int cb__CircuitBreakerIPv4AddressAndMaskType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerIPv4AddressAndMaskType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerIPv4AddressAndMaskType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerIPv4AddressAndMaskType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType), type); + soap_out_cb__CircuitBreakerFilterIPAddressDirectionType(soap, "cb:IPAddressDirection", -1, &(((cb__CircuitBreakerIPv4AddressAndMaskType*)a)->IPAddressDirection), ""); + soap_out_cb__IPv4AddressStringType(soap, "cb:Address", -1, &(((cb__CircuitBreakerIPv4AddressAndMaskType*)a)->Address), ""); + soap_out_cb__IPv4AddressStringType(soap, "cb:AddressMask", -1, &(((cb__CircuitBreakerIPv4AddressAndMaskType*)a)->AddressMask), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerIPv4AddressAndMaskType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerIPv4AddressAndMaskType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType * SOAP_FMAC4 soap_get_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv4AddressAndMaskType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerIPv4AddressAndMaskType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerIPv4AddressAndMaskType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerIPv4AddressAndMaskType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType * SOAP_FMAC4 soap_in_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, const char *tag, cb__CircuitBreakerIPv4AddressAndMaskType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerIPv4AddressAndMaskType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType, sizeof(cb__CircuitBreakerIPv4AddressAndMaskType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerIPv4AddressAndMaskType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_IPAddressDirection1 = 1, soap_flag_Address1 = 1, soap_flag_AddressMask1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_IPAddressDirection1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cb__CircuitBreakerFilterIPAddressDirectionType(soap, "cb:IPAddressDirection", &(((cb__CircuitBreakerIPv4AddressAndMaskType*)a)->IPAddressDirection), "cb:CircuitBreakerFilterIPAddressDirectionType")) + { soap_flag_IPAddressDirection1--; + continue; + } + if (soap_flag_Address1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_cb__IPv4AddressStringType(soap, "cb:Address", &(((cb__CircuitBreakerIPv4AddressAndMaskType*)a)->Address), "cb:IPv4AddressStringType")) + { soap_flag_Address1--; + continue; + } + if (soap_flag_AddressMask1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_cb__IPv4AddressStringType(soap, "cb:AddressMask", &(((cb__CircuitBreakerIPv4AddressAndMaskType*)a)->AddressMask), "cb:IPv4AddressStringType")) + { soap_flag_AddressMask1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_IPAddressDirection1 > 0 || soap_flag_Address1 > 0 || soap_flag_AddressMask1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPv4AddressAndMaskType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType, 0, sizeof(cb__CircuitBreakerIPv4AddressAndMaskType), 0, soap_copy_cb__CircuitBreakerIPv4AddressAndMaskType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerIPv4AddressAndMaskType * SOAP_FMAC6 soap_new_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerIPv4AddressAndMaskType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv4AddressAndMaskType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerIPv4AddressAndMaskType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerIPv4AddressAndMaskType; + if (size) + *size = sizeof(cb__CircuitBreakerIPv4AddressAndMaskType); + ((cb__CircuitBreakerIPv4AddressAndMaskType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerIPv4AddressAndMaskType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerIPv4AddressAndMaskType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerIPv4AddressAndMaskType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerIPv4AddressAndMaskType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerIPv4AddressAndMaskType %p -> %p\n", q, p)); + *(cb__CircuitBreakerIPv4AddressAndMaskType*)p = *(cb__CircuitBreakerIPv4AddressAndMaskType*)q; +} + +void cb__CircuitBreakerPolicyInfoType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocb__CircuitBreakerPolicyType(soap, &((cb__CircuitBreakerPolicyInfoType*)this)->Policy); + soap_embedded(soap, &((cb__CircuitBreakerPolicyInfoType*)this)->PolicyCreationHandle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void cb__CircuitBreakerPolicyInfoType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerPolicyInfoType*)this)->Policy = NULL; + soap_default_unsignedInt(soap, &((cb__CircuitBreakerPolicyInfoType*)this)->PolicyCreationHandle); + /* transient soap skipped */ +} + +int cb__CircuitBreakerPolicyInfoType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerPolicyInfoType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerPolicyInfoType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerPolicyInfoType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPolicyInfoType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerPolicyInfoType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerPolicyInfoType), type); + soap_out_PointerTocb__CircuitBreakerPolicyType(soap, "cb:Policy", -1, &(((cb__CircuitBreakerPolicyInfoType*)a)->Policy), ""); + soap_out_unsignedInt(soap, "cb:PolicyCreationHandle", -1, &(((cb__CircuitBreakerPolicyInfoType*)a)->PolicyCreationHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerPolicyInfoType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerPolicyInfoType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPolicyInfoType(struct soap *soap, cb__CircuitBreakerPolicyInfoType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerPolicyInfoType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerPolicyInfoType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerPolicyInfoType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPolicyInfoType(struct soap *soap, const char *tag, cb__CircuitBreakerPolicyInfoType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerPolicyInfoType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerPolicyInfoType, sizeof(cb__CircuitBreakerPolicyInfoType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerPolicyInfoType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerPolicyInfoType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Policy1 = 1, soap_flag_PolicyCreationHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Policy1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerPolicyType(soap, "cb:Policy", &(((cb__CircuitBreakerPolicyInfoType*)a)->Policy), "cb:CircuitBreakerPolicyType")) + { soap_flag_Policy1--; + continue; + } + if (soap_flag_PolicyCreationHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:PolicyCreationHandle", &(((cb__CircuitBreakerPolicyInfoType*)a)->PolicyCreationHandle), "xsd:unsignedInt")) + { soap_flag_PolicyCreationHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Policy1 > 0 || soap_flag_PolicyCreationHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerPolicyInfoType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerPolicyInfoType, 0, sizeof(cb__CircuitBreakerPolicyInfoType), 0, soap_copy_cb__CircuitBreakerPolicyInfoType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerPolicyInfoType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPolicyInfoType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerPolicyInfoType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPolicyInfoType(struct soap *soap, cb__CircuitBreakerPolicyInfoType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPolicyInfoType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerPolicyInfoType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerPolicyInfoType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerPolicyInfoType; + if (size) + *size = sizeof(cb__CircuitBreakerPolicyInfoType); + ((cb__CircuitBreakerPolicyInfoType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerPolicyInfoType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerPolicyInfoType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerPolicyInfoType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerPolicyInfoType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPolicyInfoType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerPolicyInfoType %p -> %p\n", q, p)); + *(cb__CircuitBreakerPolicyInfoType*)p = *(cb__CircuitBreakerPolicyInfoType*)q; +} + +void cb__CircuitBreakerPolicyType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerPolicyType*)this)->PolicyPrecedence, SOAP_TYPE_unsignedInt); + soap_serialize_PointerTocb__CircuitBreakerAntiSpoofingFilterType(soap, &((cb__CircuitBreakerPolicyType*)this)->AntiSpoofingFilter); + soap_serialize_std__vectorTemplateOfunsignedInt(soap, &((cb__CircuitBreakerPolicyType*)this)->FilterCreationHandles); + soap_serialize_PointerTocb__CircuitBreakerDefaultFilterType(soap, &((cb__CircuitBreakerPolicyType*)this)->DefaultTXFilter); + soap_serialize_PointerTocb__CircuitBreakerDefaultFilterType(soap, &((cb__CircuitBreakerPolicyType*)this)->DefaultRXFilter); + /* transient soap skipped */ +} + +void cb__CircuitBreakerPolicyType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cb__CircuitBreakerPolicyType*)this)->PolicyName = NULL; + soap_default_unsignedInt(soap, &((cb__CircuitBreakerPolicyType*)this)->PolicyPrecedence); + ((cb__CircuitBreakerPolicyType*)this)->AntiSpoofingFilter = NULL; + soap_default_std__vectorTemplateOfunsignedInt(soap, &((cb__CircuitBreakerPolicyType*)this)->FilterCreationHandles); + ((cb__CircuitBreakerPolicyType*)this)->DefaultTXFilter = NULL; + ((cb__CircuitBreakerPolicyType*)this)->DefaultRXFilter = NULL; + /* transient soap skipped */ +} + +int cb__CircuitBreakerPolicyType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerPolicyType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerPolicyType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerPolicyType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerPolicyType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerPolicyType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerPolicyType), type); + soap_outliteral(soap, "cb:PolicyName", &(((cb__CircuitBreakerPolicyType*)a)->PolicyName), NULL); + soap_out_unsignedInt(soap, "cb:PolicyPrecedence", -1, &(((cb__CircuitBreakerPolicyType*)a)->PolicyPrecedence), ""); + soap_out_PointerTocb__CircuitBreakerAntiSpoofingFilterType(soap, "cb:AntiSpoofingFilter", -1, &(((cb__CircuitBreakerPolicyType*)a)->AntiSpoofingFilter), ""); + soap_out_std__vectorTemplateOfunsignedInt(soap, "cb:FilterCreationHandles", -1, &(((cb__CircuitBreakerPolicyType*)a)->FilterCreationHandles), ""); + soap_out_PointerTocb__CircuitBreakerDefaultFilterType(soap, "cb:DefaultTXFilter", -1, &(((cb__CircuitBreakerPolicyType*)a)->DefaultTXFilter), ""); + soap_out_PointerTocb__CircuitBreakerDefaultFilterType(soap, "cb:DefaultRXFilter", -1, &(((cb__CircuitBreakerPolicyType*)a)->DefaultRXFilter), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerPolicyType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerPolicyType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyType * SOAP_FMAC4 soap_get_cb__CircuitBreakerPolicyType(struct soap *soap, cb__CircuitBreakerPolicyType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerPolicyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerPolicyType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerPolicyType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyType * SOAP_FMAC4 soap_in_cb__CircuitBreakerPolicyType(struct soap *soap, const char *tag, cb__CircuitBreakerPolicyType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerPolicyType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerPolicyType, sizeof(cb__CircuitBreakerPolicyType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerPolicyType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerPolicyType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PolicyName1 = 1, soap_flag_PolicyPrecedence1 = 1, soap_flag_AntiSpoofingFilter1 = 1, soap_flag_DefaultTXFilter1 = 1, soap_flag_DefaultRXFilter1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PolicyName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_inliteral(soap, "cb:PolicyName", &(((cb__CircuitBreakerPolicyType*)a)->PolicyName))) + { soap_flag_PolicyName1--; + continue; + } + if (soap_flag_PolicyPrecedence1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "cb:PolicyPrecedence", &(((cb__CircuitBreakerPolicyType*)a)->PolicyPrecedence), "xsd:unsignedInt")) + { soap_flag_PolicyPrecedence1--; + continue; + } + if (soap_flag_AntiSpoofingFilter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerAntiSpoofingFilterType(soap, "cb:AntiSpoofingFilter", &(((cb__CircuitBreakerPolicyType*)a)->AntiSpoofingFilter), "cb:CircuitBreakerAntiSpoofingFilterType")) + { soap_flag_AntiSpoofingFilter1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedInt(soap, "cb:FilterCreationHandles", &(((cb__CircuitBreakerPolicyType*)a)->FilterCreationHandles), "xsd:unsignedInt")) + continue; + if (soap_flag_DefaultTXFilter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerDefaultFilterType(soap, "cb:DefaultTXFilter", &(((cb__CircuitBreakerPolicyType*)a)->DefaultTXFilter), "cb:CircuitBreakerDefaultFilterType")) + { soap_flag_DefaultTXFilter1--; + continue; + } + if (soap_flag_DefaultRXFilter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocb__CircuitBreakerDefaultFilterType(soap, "cb:DefaultRXFilter", &(((cb__CircuitBreakerPolicyType*)a)->DefaultRXFilter), "cb:CircuitBreakerDefaultFilterType")) + { soap_flag_DefaultRXFilter1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PolicyPrecedence1 > 0 || soap_flag_DefaultTXFilter1 > 0 || soap_flag_DefaultRXFilter1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerPolicyType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerPolicyType, 0, sizeof(cb__CircuitBreakerPolicyType), 0, soap_copy_cb__CircuitBreakerPolicyType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerPolicyType * SOAP_FMAC6 soap_new_cb__CircuitBreakerPolicyType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerPolicyType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerPolicyType(struct soap *soap, cb__CircuitBreakerPolicyType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerPolicyType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerPolicyType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerPolicyType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerPolicyType; + if (size) + *size = sizeof(cb__CircuitBreakerPolicyType); + ((cb__CircuitBreakerPolicyType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerPolicyType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerPolicyType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerPolicyType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerPolicyType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerPolicyType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerPolicyType %p -> %p\n", q, p)); + *(cb__CircuitBreakerPolicyType*)p = *(cb__CircuitBreakerPolicyType*)q; +} + +void cb__CircuitBreakerDefaultFilterType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerDefaultFilterType*)this)->ActionDrop, SOAP_TYPE_bool); + soap_embedded(soap, &((cb__CircuitBreakerAntiSpoofingFilterType*)this)->ActionEventOnMatch, SOAP_TYPE_bool); + soap_embedded(soap, &((cb__CircuitBreakerAntiSpoofingFilterType*)this)->ActionCount, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void cb__CircuitBreakerDefaultFilterType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((cb__CircuitBreakerDefaultFilterType*)this)->ActionDrop); + soap_default_bool(soap, &((cb__CircuitBreakerAntiSpoofingFilterType*)this)->ActionEventOnMatch); + soap_default_bool(soap, &((cb__CircuitBreakerAntiSpoofingFilterType*)this)->ActionCount); + /* transient soap skipped */ +} + +int cb__CircuitBreakerDefaultFilterType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerDefaultFilterType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerDefaultFilterType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerDefaultFilterType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerDefaultFilterType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerDefaultFilterType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerDefaultFilterType), "cb:CircuitBreakerDefaultFilterType"); + soap_out_bool(soap, "cb:ActionEventOnMatch", -1, &(((cb__CircuitBreakerAntiSpoofingFilterType*)a)->ActionEventOnMatch), ""); + soap_out_bool(soap, "cb:ActionCount", -1, &(((cb__CircuitBreakerAntiSpoofingFilterType*)a)->ActionCount), ""); + /* transient soap skipped */ + soap_out_bool(soap, "cb:ActionDrop", -1, &(((cb__CircuitBreakerDefaultFilterType*)a)->ActionDrop), ""); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerDefaultFilterType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerDefaultFilterType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType * SOAP_FMAC4 soap_get_cb__CircuitBreakerDefaultFilterType(struct soap *soap, cb__CircuitBreakerDefaultFilterType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerDefaultFilterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerDefaultFilterType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerDefaultFilterType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType * SOAP_FMAC4 soap_in_cb__CircuitBreakerDefaultFilterType(struct soap *soap, const char *tag, cb__CircuitBreakerDefaultFilterType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerDefaultFilterType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerDefaultFilterType, sizeof(cb__CircuitBreakerDefaultFilterType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerDefaultFilterType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerDefaultFilterType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ActionEventOnMatch2 = 1, soap_flag_ActionCount2 = 1, soap_flag_ActionDrop1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ActionEventOnMatch2 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:ActionEventOnMatch", &(((cb__CircuitBreakerAntiSpoofingFilterType*)a)->ActionEventOnMatch), "xsd:boolean")) + { soap_flag_ActionEventOnMatch2--; + continue; + } + if (soap_flag_ActionCount2 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:ActionCount", &(((cb__CircuitBreakerAntiSpoofingFilterType*)a)->ActionCount), "xsd:boolean")) + { soap_flag_ActionCount2--; + continue; + } + /* transient soap skipped */ + if (soap_flag_ActionDrop1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:ActionDrop", &(((cb__CircuitBreakerDefaultFilterType*)a)->ActionDrop), "xsd:boolean")) + { soap_flag_ActionDrop1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ActionEventOnMatch2 > 0 || soap_flag_ActionCount2 > 0 || soap_flag_ActionDrop1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerDefaultFilterType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerDefaultFilterType, 0, sizeof(cb__CircuitBreakerDefaultFilterType), 0, soap_copy_cb__CircuitBreakerDefaultFilterType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerDefaultFilterType * SOAP_FMAC6 soap_new_cb__CircuitBreakerDefaultFilterType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerDefaultFilterType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerDefaultFilterType(struct soap *soap, cb__CircuitBreakerDefaultFilterType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerDefaultFilterType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerDefaultFilterType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerDefaultFilterType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerDefaultFilterType; + if (size) + *size = sizeof(cb__CircuitBreakerDefaultFilterType); + ((cb__CircuitBreakerDefaultFilterType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerDefaultFilterType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerDefaultFilterType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerDefaultFilterType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerDefaultFilterType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerDefaultFilterType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerDefaultFilterType %p -> %p\n", q, p)); + *(cb__CircuitBreakerDefaultFilterType*)p = *(cb__CircuitBreakerDefaultFilterType*)q; +} + +void cb__CircuitBreakerAntiSpoofingFilterType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cb__CircuitBreakerAntiSpoofingFilterType*)this)->ActionEventOnMatch, SOAP_TYPE_bool); + soap_embedded(soap, &((cb__CircuitBreakerAntiSpoofingFilterType*)this)->ActionCount, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void cb__CircuitBreakerAntiSpoofingFilterType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((cb__CircuitBreakerAntiSpoofingFilterType*)this)->ActionEventOnMatch); + soap_default_bool(soap, &((cb__CircuitBreakerAntiSpoofingFilterType*)this)->ActionCount); + /* transient soap skipped */ +} + +int cb__CircuitBreakerAntiSpoofingFilterType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cb__CircuitBreakerAntiSpoofingFilterType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cb__CircuitBreakerAntiSpoofingFilterType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, const char *tag, int id, const cb__CircuitBreakerAntiSpoofingFilterType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType), type); + soap_out_bool(soap, "cb:ActionEventOnMatch", -1, &(((cb__CircuitBreakerAntiSpoofingFilterType*)a)->ActionEventOnMatch), ""); + soap_out_bool(soap, "cb:ActionCount", -1, &(((cb__CircuitBreakerAntiSpoofingFilterType*)a)->ActionCount), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cb__CircuitBreakerAntiSpoofingFilterType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cb__CircuitBreakerAntiSpoofingFilterType(soap, this, tag, type); +} + +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType * SOAP_FMAC4 soap_get_cb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, cb__CircuitBreakerAntiSpoofingFilterType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cb__CircuitBreakerAntiSpoofingFilterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cb__CircuitBreakerAntiSpoofingFilterType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cb__CircuitBreakerAntiSpoofingFilterType(soap, tag, this, type); +} + +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType * SOAP_FMAC4 soap_in_cb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, const char *tag, cb__CircuitBreakerAntiSpoofingFilterType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cb__CircuitBreakerAntiSpoofingFilterType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType, sizeof(cb__CircuitBreakerAntiSpoofingFilterType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType) + { soap_revert(soap); + *soap->id = '\0'; + return (cb__CircuitBreakerAntiSpoofingFilterType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ActionEventOnMatch1 = 1, soap_flag_ActionCount1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ActionEventOnMatch1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:ActionEventOnMatch", &(((cb__CircuitBreakerAntiSpoofingFilterType*)a)->ActionEventOnMatch), "xsd:boolean")) + { soap_flag_ActionEventOnMatch1--; + continue; + } + if (soap_flag_ActionCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "cb:ActionCount", &(((cb__CircuitBreakerAntiSpoofingFilterType*)a)->ActionCount), "xsd:boolean")) + { soap_flag_ActionCount1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ActionEventOnMatch1 > 0 || soap_flag_ActionCount1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cb__CircuitBreakerAntiSpoofingFilterType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType, 0, sizeof(cb__CircuitBreakerAntiSpoofingFilterType), 0, soap_copy_cb__CircuitBreakerAntiSpoofingFilterType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cb__CircuitBreakerAntiSpoofingFilterType * SOAP_FMAC6 soap_new_cb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, int n) +{ return soap_instantiate_cb__CircuitBreakerAntiSpoofingFilterType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, cb__CircuitBreakerAntiSpoofingFilterType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType * SOAP_FMAC4 soap_instantiate_cb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cb__CircuitBreakerAntiSpoofingFilterType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType, n, soap_fdelete); + if (!cp) + return NULL; + if (type && !soap_match_tag(soap, type, "cb:CircuitBreakerDefaultFilterType")) + { cp->type = SOAP_TYPE_cb__CircuitBreakerDefaultFilterType; + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerDefaultFilterType; + if (size) + *size = sizeof(cb__CircuitBreakerDefaultFilterType); + ((cb__CircuitBreakerDefaultFilterType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerDefaultFilterType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerDefaultFilterType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerDefaultFilterType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerDefaultFilterType*)cp->ptr; + } + if (n < 0) + { cp->ptr = (void*)new cb__CircuitBreakerAntiSpoofingFilterType; + if (size) + *size = sizeof(cb__CircuitBreakerAntiSpoofingFilterType); + ((cb__CircuitBreakerAntiSpoofingFilterType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cb__CircuitBreakerAntiSpoofingFilterType[n]; + if (size) + *size = n * sizeof(cb__CircuitBreakerAntiSpoofingFilterType); + for (int i = 0; i < n; i++) + ((cb__CircuitBreakerAntiSpoofingFilterType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cb__CircuitBreakerAntiSpoofingFilterType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cb__CircuitBreakerAntiSpoofingFilterType %p -> %p\n", q, p)); + *(cb__CircuitBreakerAntiSpoofingFilterType*)p = *(cb__CircuitBreakerAntiSpoofingFilterType*)q; +} + +void _emi__GetGeneralAlertSubscriptionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToemi__AlertSubscriptionGeneralType(soap, &((_emi__GetGeneralAlertSubscriptionResponse*)this)->SubscriptionInfo); + /* transient soap skipped */ +} + +void _emi__GetGeneralAlertSubscriptionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__GetGeneralAlertSubscriptionResponse*)this)->Status); + ((_emi__GetGeneralAlertSubscriptionResponse*)this)->SubscriptionInfo = NULL; + /* transient soap skipped */ +} + +int _emi__GetGeneralAlertSubscriptionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetGeneralAlertSubscriptionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetGeneralAlertSubscriptionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, const char *tag, int id, const _emi__GetGeneralAlertSubscriptionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__GetGeneralAlertSubscriptionResponse*)a)->Status), ""); + soap_out_PointerToemi__AlertSubscriptionGeneralType(soap, "emi:SubscriptionInfo", -1, &(((_emi__GetGeneralAlertSubscriptionResponse*)a)->SubscriptionInfo), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetGeneralAlertSubscriptionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetGeneralAlertSubscriptionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse * SOAP_FMAC4 soap_get__emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, _emi__GetGeneralAlertSubscriptionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetGeneralAlertSubscriptionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetGeneralAlertSubscriptionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetGeneralAlertSubscriptionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse * SOAP_FMAC4 soap_in__emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, const char *tag, _emi__GetGeneralAlertSubscriptionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetGeneralAlertSubscriptionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse, sizeof(_emi__GetGeneralAlertSubscriptionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetGeneralAlertSubscriptionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_SubscriptionInfo1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__GetGeneralAlertSubscriptionResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_SubscriptionInfo1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertSubscriptionGeneralType(soap, "emi:SubscriptionInfo", &(((_emi__GetGeneralAlertSubscriptionResponse*)a)->SubscriptionInfo), "emi:AlertSubscriptionGeneralType")) + { soap_flag_SubscriptionInfo1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_SubscriptionInfo1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetGeneralAlertSubscriptionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse, 0, sizeof(_emi__GetGeneralAlertSubscriptionResponse), 0, soap_copy__emi__GetGeneralAlertSubscriptionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetGeneralAlertSubscriptionResponse * SOAP_FMAC6 soap_new__emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__GetGeneralAlertSubscriptionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, _emi__GetGeneralAlertSubscriptionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse * SOAP_FMAC4 soap_instantiate__emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetGeneralAlertSubscriptionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetGeneralAlertSubscriptionResponse; + if (size) + *size = sizeof(_emi__GetGeneralAlertSubscriptionResponse); + ((_emi__GetGeneralAlertSubscriptionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetGeneralAlertSubscriptionResponse[n]; + if (size) + *size = n * sizeof(_emi__GetGeneralAlertSubscriptionResponse); + for (int i = 0; i < n; i++) + ((_emi__GetGeneralAlertSubscriptionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetGeneralAlertSubscriptionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetGeneralAlertSubscriptionResponse %p -> %p\n", q, p)); + *(_emi__GetGeneralAlertSubscriptionResponse*)p = *(_emi__GetGeneralAlertSubscriptionResponse*)q; +} + +void _emi__GetGeneralAlertSubscription::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__GetGeneralAlertSubscription::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__AlertSubscriptionHandleType(soap, &((_emi__GetGeneralAlertSubscription*)this)->SubscriptionHandle); + /* transient soap skipped */ +} + +int _emi__GetGeneralAlertSubscription::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetGeneralAlertSubscription); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetGeneralAlertSubscription::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetGeneralAlertSubscription(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetGeneralAlertSubscription(struct soap *soap, const char *tag, int id, const _emi__GetGeneralAlertSubscription *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetGeneralAlertSubscription), type); + soap_out_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", -1, &(((_emi__GetGeneralAlertSubscription*)a)->SubscriptionHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetGeneralAlertSubscription::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetGeneralAlertSubscription(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_get__emi__GetGeneralAlertSubscription(struct soap *soap, _emi__GetGeneralAlertSubscription *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetGeneralAlertSubscription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetGeneralAlertSubscription::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetGeneralAlertSubscription(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_in__emi__GetGeneralAlertSubscription(struct soap *soap, const char *tag, _emi__GetGeneralAlertSubscription *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetGeneralAlertSubscription *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetGeneralAlertSubscription, sizeof(_emi__GetGeneralAlertSubscription), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetGeneralAlertSubscription) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetGeneralAlertSubscription *)a->soap_in(soap, tag, type); + } + } + short soap_flag_SubscriptionHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_SubscriptionHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", &(((_emi__GetGeneralAlertSubscription*)a)->SubscriptionHandle), "emi:AlertSubscriptionHandleType")) + { soap_flag_SubscriptionHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_SubscriptionHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetGeneralAlertSubscription *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetGeneralAlertSubscription, 0, sizeof(_emi__GetGeneralAlertSubscription), 0, soap_copy__emi__GetGeneralAlertSubscription); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetGeneralAlertSubscription * SOAP_FMAC6 soap_new__emi__GetGeneralAlertSubscription(struct soap *soap, int n) +{ return soap_instantiate__emi__GetGeneralAlertSubscription(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetGeneralAlertSubscription(struct soap *soap, _emi__GetGeneralAlertSubscription *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_instantiate__emi__GetGeneralAlertSubscription(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetGeneralAlertSubscription(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetGeneralAlertSubscription, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetGeneralAlertSubscription; + if (size) + *size = sizeof(_emi__GetGeneralAlertSubscription); + ((_emi__GetGeneralAlertSubscription*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetGeneralAlertSubscription[n]; + if (size) + *size = n * sizeof(_emi__GetGeneralAlertSubscription); + for (int i = 0; i < n; i++) + ((_emi__GetGeneralAlertSubscription*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetGeneralAlertSubscription*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetGeneralAlertSubscription(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetGeneralAlertSubscription %p -> %p\n", q, p)); + *(_emi__GetGeneralAlertSubscription*)p = *(_emi__GetGeneralAlertSubscription*)q; +} + +void _emi__EnumerateGeneralAlertSubscriptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, &((_emi__EnumerateGeneralAlertSubscriptionsResponse*)this)->SubscriptionHandle); + /* transient soap skipped */ +} + +void _emi__EnumerateGeneralAlertSubscriptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__EnumerateGeneralAlertSubscriptionsResponse*)this)->Status); + soap_default_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, &((_emi__EnumerateGeneralAlertSubscriptionsResponse*)this)->SubscriptionHandle); + /* transient soap skipped */ +} + +int _emi__EnumerateGeneralAlertSubscriptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateGeneralAlertSubscriptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateGeneralAlertSubscriptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, const char *tag, int id, const _emi__EnumerateGeneralAlertSubscriptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__EnumerateGeneralAlertSubscriptionsResponse*)a)->Status), ""); + soap_out_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", -1, &(((_emi__EnumerateGeneralAlertSubscriptionsResponse*)a)->SubscriptionHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateGeneralAlertSubscriptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateGeneralAlertSubscriptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse * SOAP_FMAC4 soap_get__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateGeneralAlertSubscriptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateGeneralAlertSubscriptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateGeneralAlertSubscriptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse * SOAP_FMAC4 soap_in__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, const char *tag, _emi__EnumerateGeneralAlertSubscriptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateGeneralAlertSubscriptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse, sizeof(_emi__EnumerateGeneralAlertSubscriptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateGeneralAlertSubscriptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__EnumerateGeneralAlertSubscriptionsResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", &(((_emi__EnumerateGeneralAlertSubscriptionsResponse*)a)->SubscriptionHandle), "emi:AlertSubscriptionHandleType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateGeneralAlertSubscriptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse, 0, sizeof(_emi__EnumerateGeneralAlertSubscriptionsResponse), 0, soap_copy__emi__EnumerateGeneralAlertSubscriptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateGeneralAlertSubscriptionsResponse * SOAP_FMAC6 soap_new__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateGeneralAlertSubscriptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateGeneralAlertSubscriptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateGeneralAlertSubscriptionsResponse; + if (size) + *size = sizeof(_emi__EnumerateGeneralAlertSubscriptionsResponse); + ((_emi__EnumerateGeneralAlertSubscriptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateGeneralAlertSubscriptionsResponse[n]; + if (size) + *size = n * sizeof(_emi__EnumerateGeneralAlertSubscriptionsResponse); + for (int i = 0; i < n; i++) + ((_emi__EnumerateGeneralAlertSubscriptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateGeneralAlertSubscriptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateGeneralAlertSubscriptionsResponse %p -> %p\n", q, p)); + *(_emi__EnumerateGeneralAlertSubscriptionsResponse*)p = *(_emi__EnumerateGeneralAlertSubscriptionsResponse*)q; +} + +void _emi__EnumerateGeneralAlertSubscriptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToemi__AlertSubscriptionPolicyIDType(soap, &((_emi__EnumerateGeneralAlertSubscriptions*)this)->PolicyID); + /* transient soap skipped */ +} + +void _emi__EnumerateGeneralAlertSubscriptions::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_emi__EnumerateGeneralAlertSubscriptions*)this)->PolicyID = NULL; + /* transient soap skipped */ +} + +int _emi__EnumerateGeneralAlertSubscriptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateGeneralAlertSubscriptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateGeneralAlertSubscriptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const char *tag, int id, const _emi__EnumerateGeneralAlertSubscriptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions), type); + soap_out_PointerToemi__AlertSubscriptionPolicyIDType(soap, "emi:PolicyID", -1, &(((_emi__EnumerateGeneralAlertSubscriptions*)a)->PolicyID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateGeneralAlertSubscriptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateGeneralAlertSubscriptions(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_get__emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateGeneralAlertSubscriptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateGeneralAlertSubscriptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateGeneralAlertSubscriptions(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_in__emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const char *tag, _emi__EnumerateGeneralAlertSubscriptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateGeneralAlertSubscriptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions, sizeof(_emi__EnumerateGeneralAlertSubscriptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateGeneralAlertSubscriptions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PolicyID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PolicyID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertSubscriptionPolicyIDType(soap, "emi:PolicyID", &(((_emi__EnumerateGeneralAlertSubscriptions*)a)->PolicyID), "emi:AlertSubscriptionPolicyIDType")) + { soap_flag_PolicyID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateGeneralAlertSubscriptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions, 0, sizeof(_emi__EnumerateGeneralAlertSubscriptions), 0, soap_copy__emi__EnumerateGeneralAlertSubscriptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC6 soap_new__emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateGeneralAlertSubscriptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_instantiate__emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateGeneralAlertSubscriptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateGeneralAlertSubscriptions; + if (size) + *size = sizeof(_emi__EnumerateGeneralAlertSubscriptions); + ((_emi__EnumerateGeneralAlertSubscriptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateGeneralAlertSubscriptions[n]; + if (size) + *size = n * sizeof(_emi__EnumerateGeneralAlertSubscriptions); + for (int i = 0; i < n; i++) + ((_emi__EnumerateGeneralAlertSubscriptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateGeneralAlertSubscriptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateGeneralAlertSubscriptions %p -> %p\n", q, p)); + *(_emi__EnumerateGeneralAlertSubscriptions*)p = *(_emi__EnumerateGeneralAlertSubscriptions*)q; +} + +void _emi__SubscribeForGeneralAlertResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__SubscribeForGeneralAlertResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__SubscribeForGeneralAlertResponse*)this)->Status); + soap_default_emi__AlertSubscriptionHandleType(soap, &((_emi__SubscribeForGeneralAlertResponse*)this)->SubscriptionHandle); + /* transient soap skipped */ +} + +int _emi__SubscribeForGeneralAlertResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__SubscribeForGeneralAlertResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__SubscribeForGeneralAlertResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__SubscribeForGeneralAlertResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SubscribeForGeneralAlertResponse(struct soap *soap, const char *tag, int id, const _emi__SubscribeForGeneralAlertResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__SubscribeForGeneralAlertResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__SubscribeForGeneralAlertResponse*)a)->Status), ""); + soap_out_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", -1, &(((_emi__SubscribeForGeneralAlertResponse*)a)->SubscriptionHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__SubscribeForGeneralAlertResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__SubscribeForGeneralAlertResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse * SOAP_FMAC4 soap_get__emi__SubscribeForGeneralAlertResponse(struct soap *soap, _emi__SubscribeForGeneralAlertResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__SubscribeForGeneralAlertResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__SubscribeForGeneralAlertResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__SubscribeForGeneralAlertResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse * SOAP_FMAC4 soap_in__emi__SubscribeForGeneralAlertResponse(struct soap *soap, const char *tag, _emi__SubscribeForGeneralAlertResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__SubscribeForGeneralAlertResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__SubscribeForGeneralAlertResponse, sizeof(_emi__SubscribeForGeneralAlertResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__SubscribeForGeneralAlertResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__SubscribeForGeneralAlertResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_SubscriptionHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__SubscribeForGeneralAlertResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_SubscriptionHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", &(((_emi__SubscribeForGeneralAlertResponse*)a)->SubscriptionHandle), "emi:AlertSubscriptionHandleType")) + { soap_flag_SubscriptionHandle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_SubscriptionHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__SubscribeForGeneralAlertResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__SubscribeForGeneralAlertResponse, 0, sizeof(_emi__SubscribeForGeneralAlertResponse), 0, soap_copy__emi__SubscribeForGeneralAlertResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__SubscribeForGeneralAlertResponse * SOAP_FMAC6 soap_new__emi__SubscribeForGeneralAlertResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__SubscribeForGeneralAlertResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SubscribeForGeneralAlertResponse(struct soap *soap, _emi__SubscribeForGeneralAlertResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse * SOAP_FMAC4 soap_instantiate__emi__SubscribeForGeneralAlertResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__SubscribeForGeneralAlertResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__SubscribeForGeneralAlertResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__SubscribeForGeneralAlertResponse; + if (size) + *size = sizeof(_emi__SubscribeForGeneralAlertResponse); + ((_emi__SubscribeForGeneralAlertResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__SubscribeForGeneralAlertResponse[n]; + if (size) + *size = n * sizeof(_emi__SubscribeForGeneralAlertResponse); + for (int i = 0; i < n; i++) + ((_emi__SubscribeForGeneralAlertResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__SubscribeForGeneralAlertResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SubscribeForGeneralAlertResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__SubscribeForGeneralAlertResponse %p -> %p\n", q, p)); + *(_emi__SubscribeForGeneralAlertResponse*)p = *(_emi__SubscribeForGeneralAlertResponse*)q; +} + +void _emi__SubscribeForGeneralAlert::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToemi__AlertSubscriptionGeneralType(soap, &((_emi__SubscribeForGeneralAlert*)this)->SubscriptionInfo); + /* transient soap skipped */ +} + +void _emi__SubscribeForGeneralAlert::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_emi__SubscribeForGeneralAlert*)this)->SubscriptionInfo = NULL; + /* transient soap skipped */ +} + +int _emi__SubscribeForGeneralAlert::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__SubscribeForGeneralAlert); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__SubscribeForGeneralAlert::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__SubscribeForGeneralAlert(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SubscribeForGeneralAlert(struct soap *soap, const char *tag, int id, const _emi__SubscribeForGeneralAlert *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__SubscribeForGeneralAlert), type); + soap_out_PointerToemi__AlertSubscriptionGeneralType(soap, "emi:SubscriptionInfo", -1, &(((_emi__SubscribeForGeneralAlert*)a)->SubscriptionInfo), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__SubscribeForGeneralAlert::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__SubscribeForGeneralAlert(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_get__emi__SubscribeForGeneralAlert(struct soap *soap, _emi__SubscribeForGeneralAlert *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__SubscribeForGeneralAlert(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__SubscribeForGeneralAlert::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__SubscribeForGeneralAlert(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_in__emi__SubscribeForGeneralAlert(struct soap *soap, const char *tag, _emi__SubscribeForGeneralAlert *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__SubscribeForGeneralAlert *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__SubscribeForGeneralAlert, sizeof(_emi__SubscribeForGeneralAlert), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__SubscribeForGeneralAlert) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__SubscribeForGeneralAlert *)a->soap_in(soap, tag, type); + } + } + short soap_flag_SubscriptionInfo1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_SubscriptionInfo1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertSubscriptionGeneralType(soap, "emi:SubscriptionInfo", &(((_emi__SubscribeForGeneralAlert*)a)->SubscriptionInfo), "emi:AlertSubscriptionGeneralType")) + { soap_flag_SubscriptionInfo1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_SubscriptionInfo1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__SubscribeForGeneralAlert *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__SubscribeForGeneralAlert, 0, sizeof(_emi__SubscribeForGeneralAlert), 0, soap_copy__emi__SubscribeForGeneralAlert); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__SubscribeForGeneralAlert * SOAP_FMAC6 soap_new__emi__SubscribeForGeneralAlert(struct soap *soap, int n) +{ return soap_instantiate__emi__SubscribeForGeneralAlert(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SubscribeForGeneralAlert(struct soap *soap, _emi__SubscribeForGeneralAlert *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_instantiate__emi__SubscribeForGeneralAlert(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__SubscribeForGeneralAlert(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__SubscribeForGeneralAlert, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__SubscribeForGeneralAlert; + if (size) + *size = sizeof(_emi__SubscribeForGeneralAlert); + ((_emi__SubscribeForGeneralAlert*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__SubscribeForGeneralAlert[n]; + if (size) + *size = n * sizeof(_emi__SubscribeForGeneralAlert); + for (int i = 0; i < n; i++) + ((_emi__SubscribeForGeneralAlert*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__SubscribeForGeneralAlert*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SubscribeForGeneralAlert(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__SubscribeForGeneralAlert %p -> %p\n", q, p)); + *(_emi__SubscribeForGeneralAlert*)p = *(_emi__SubscribeForGeneralAlert*)q; +} + +void _emi__CancelAlertSubscriptionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__CancelAlertSubscriptionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__CancelAlertSubscriptionResponse*)this)->Status); + /* transient soap skipped */ +} + +int _emi__CancelAlertSubscriptionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__CancelAlertSubscriptionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__CancelAlertSubscriptionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__CancelAlertSubscriptionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__CancelAlertSubscriptionResponse(struct soap *soap, const char *tag, int id, const _emi__CancelAlertSubscriptionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__CancelAlertSubscriptionResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__CancelAlertSubscriptionResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__CancelAlertSubscriptionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__CancelAlertSubscriptionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse * SOAP_FMAC4 soap_get__emi__CancelAlertSubscriptionResponse(struct soap *soap, _emi__CancelAlertSubscriptionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__CancelAlertSubscriptionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__CancelAlertSubscriptionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__CancelAlertSubscriptionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse * SOAP_FMAC4 soap_in__emi__CancelAlertSubscriptionResponse(struct soap *soap, const char *tag, _emi__CancelAlertSubscriptionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__CancelAlertSubscriptionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__CancelAlertSubscriptionResponse, sizeof(_emi__CancelAlertSubscriptionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__CancelAlertSubscriptionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__CancelAlertSubscriptionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__CancelAlertSubscriptionResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__CancelAlertSubscriptionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__CancelAlertSubscriptionResponse, 0, sizeof(_emi__CancelAlertSubscriptionResponse), 0, soap_copy__emi__CancelAlertSubscriptionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__CancelAlertSubscriptionResponse * SOAP_FMAC6 soap_new__emi__CancelAlertSubscriptionResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__CancelAlertSubscriptionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__CancelAlertSubscriptionResponse(struct soap *soap, _emi__CancelAlertSubscriptionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse * SOAP_FMAC4 soap_instantiate__emi__CancelAlertSubscriptionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__CancelAlertSubscriptionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__CancelAlertSubscriptionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__CancelAlertSubscriptionResponse; + if (size) + *size = sizeof(_emi__CancelAlertSubscriptionResponse); + ((_emi__CancelAlertSubscriptionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__CancelAlertSubscriptionResponse[n]; + if (size) + *size = n * sizeof(_emi__CancelAlertSubscriptionResponse); + for (int i = 0; i < n; i++) + ((_emi__CancelAlertSubscriptionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__CancelAlertSubscriptionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__CancelAlertSubscriptionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__CancelAlertSubscriptionResponse %p -> %p\n", q, p)); + *(_emi__CancelAlertSubscriptionResponse*)p = *(_emi__CancelAlertSubscriptionResponse*)q; +} + +void _emi__CancelAlertSubscription::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__CancelAlertSubscription::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__AlertSubscriptionHandleType(soap, &((_emi__CancelAlertSubscription*)this)->SubscriptionHandle); + /* transient soap skipped */ +} + +int _emi__CancelAlertSubscription::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__CancelAlertSubscription); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__CancelAlertSubscription::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__CancelAlertSubscription(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__CancelAlertSubscription(struct soap *soap, const char *tag, int id, const _emi__CancelAlertSubscription *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__CancelAlertSubscription), type); + soap_out_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", -1, &(((_emi__CancelAlertSubscription*)a)->SubscriptionHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__CancelAlertSubscription::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__CancelAlertSubscription(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__CancelAlertSubscription * SOAP_FMAC4 soap_get__emi__CancelAlertSubscription(struct soap *soap, _emi__CancelAlertSubscription *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__CancelAlertSubscription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__CancelAlertSubscription::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__CancelAlertSubscription(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__CancelAlertSubscription * SOAP_FMAC4 soap_in__emi__CancelAlertSubscription(struct soap *soap, const char *tag, _emi__CancelAlertSubscription *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__CancelAlertSubscription *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__CancelAlertSubscription, sizeof(_emi__CancelAlertSubscription), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__CancelAlertSubscription) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__CancelAlertSubscription *)a->soap_in(soap, tag, type); + } + } + short soap_flag_SubscriptionHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_SubscriptionHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", &(((_emi__CancelAlertSubscription*)a)->SubscriptionHandle), "emi:AlertSubscriptionHandleType")) + { soap_flag_SubscriptionHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_SubscriptionHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__CancelAlertSubscription *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__CancelAlertSubscription, 0, sizeof(_emi__CancelAlertSubscription), 0, soap_copy__emi__CancelAlertSubscription); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__CancelAlertSubscription * SOAP_FMAC6 soap_new__emi__CancelAlertSubscription(struct soap *soap, int n) +{ return soap_instantiate__emi__CancelAlertSubscription(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__CancelAlertSubscription(struct soap *soap, _emi__CancelAlertSubscription *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__CancelAlertSubscription * SOAP_FMAC4 soap_instantiate__emi__CancelAlertSubscription(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__CancelAlertSubscription(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__CancelAlertSubscription, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__CancelAlertSubscription; + if (size) + *size = sizeof(_emi__CancelAlertSubscription); + ((_emi__CancelAlertSubscription*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__CancelAlertSubscription[n]; + if (size) + *size = n * sizeof(_emi__CancelAlertSubscription); + for (int i = 0; i < n; i++) + ((_emi__CancelAlertSubscription*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__CancelAlertSubscription*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__CancelAlertSubscription(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__CancelAlertSubscription %p -> %p\n", q, p)); + *(_emi__CancelAlertSubscription*)p = *(_emi__CancelAlertSubscription*)q; +} + +void _emi__GetSensorAttributesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToemi__SensorAttributesType(soap, &((_emi__GetSensorAttributesResponse*)this)->Attributes); + /* transient soap skipped */ +} + +void _emi__GetSensorAttributesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__GetSensorAttributesResponse*)this)->Status); + ((_emi__GetSensorAttributesResponse*)this)->Attributes = NULL; + /* transient soap skipped */ +} + +int _emi__GetSensorAttributesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetSensorAttributesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetSensorAttributesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetSensorAttributesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetSensorAttributesResponse(struct soap *soap, const char *tag, int id, const _emi__GetSensorAttributesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetSensorAttributesResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__GetSensorAttributesResponse*)a)->Status), ""); + soap_out_PointerToemi__SensorAttributesType(soap, "emi:Attributes", -1, &(((_emi__GetSensorAttributesResponse*)a)->Attributes), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetSensorAttributesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetSensorAttributesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetSensorAttributesResponse * SOAP_FMAC4 soap_get__emi__GetSensorAttributesResponse(struct soap *soap, _emi__GetSensorAttributesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetSensorAttributesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetSensorAttributesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetSensorAttributesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetSensorAttributesResponse * SOAP_FMAC4 soap_in__emi__GetSensorAttributesResponse(struct soap *soap, const char *tag, _emi__GetSensorAttributesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetSensorAttributesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetSensorAttributesResponse, sizeof(_emi__GetSensorAttributesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetSensorAttributesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetSensorAttributesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Attributes1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__GetSensorAttributesResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Attributes1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__SensorAttributesType(soap, "emi:Attributes", &(((_emi__GetSensorAttributesResponse*)a)->Attributes), "emi:SensorAttributesType")) + { soap_flag_Attributes1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Attributes1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetSensorAttributesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetSensorAttributesResponse, 0, sizeof(_emi__GetSensorAttributesResponse), 0, soap_copy__emi__GetSensorAttributesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetSensorAttributesResponse * SOAP_FMAC6 soap_new__emi__GetSensorAttributesResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__GetSensorAttributesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetSensorAttributesResponse(struct soap *soap, _emi__GetSensorAttributesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetSensorAttributesResponse * SOAP_FMAC4 soap_instantiate__emi__GetSensorAttributesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetSensorAttributesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetSensorAttributesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetSensorAttributesResponse; + if (size) + *size = sizeof(_emi__GetSensorAttributesResponse); + ((_emi__GetSensorAttributesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetSensorAttributesResponse[n]; + if (size) + *size = n * sizeof(_emi__GetSensorAttributesResponse); + for (int i = 0; i < n; i++) + ((_emi__GetSensorAttributesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetSensorAttributesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetSensorAttributesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetSensorAttributesResponse %p -> %p\n", q, p)); + *(_emi__GetSensorAttributesResponse*)p = *(_emi__GetSensorAttributesResponse*)q; +} + +void _emi__GetSensorAttributes::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__GetSensorAttributes::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__SensorHandleType(soap, &((_emi__GetSensorAttributes*)this)->Handle); + /* transient soap skipped */ +} + +int _emi__GetSensorAttributes::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetSensorAttributes); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetSensorAttributes::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetSensorAttributes(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetSensorAttributes(struct soap *soap, const char *tag, int id, const _emi__GetSensorAttributes *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetSensorAttributes), type); + soap_out_emi__SensorHandleType(soap, "emi:Handle", -1, &(((_emi__GetSensorAttributes*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetSensorAttributes::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetSensorAttributes(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetSensorAttributes * SOAP_FMAC4 soap_get__emi__GetSensorAttributes(struct soap *soap, _emi__GetSensorAttributes *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetSensorAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetSensorAttributes::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetSensorAttributes(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetSensorAttributes * SOAP_FMAC4 soap_in__emi__GetSensorAttributes(struct soap *soap, const char *tag, _emi__GetSensorAttributes *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetSensorAttributes *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetSensorAttributes, sizeof(_emi__GetSensorAttributes), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetSensorAttributes) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetSensorAttributes *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__SensorHandleType(soap, "emi:Handle", &(((_emi__GetSensorAttributes*)a)->Handle), "emi:SensorHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetSensorAttributes *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetSensorAttributes, 0, sizeof(_emi__GetSensorAttributes), 0, soap_copy__emi__GetSensorAttributes); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetSensorAttributes * SOAP_FMAC6 soap_new__emi__GetSensorAttributes(struct soap *soap, int n) +{ return soap_instantiate__emi__GetSensorAttributes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetSensorAttributes(struct soap *soap, _emi__GetSensorAttributes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetSensorAttributes * SOAP_FMAC4 soap_instantiate__emi__GetSensorAttributes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetSensorAttributes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetSensorAttributes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetSensorAttributes; + if (size) + *size = sizeof(_emi__GetSensorAttributes); + ((_emi__GetSensorAttributes*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetSensorAttributes[n]; + if (size) + *size = n * sizeof(_emi__GetSensorAttributes); + for (int i = 0; i < n; i++) + ((_emi__GetSensorAttributes*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetSensorAttributes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetSensorAttributes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetSensorAttributes %p -> %p\n", q, p)); + *(_emi__GetSensorAttributes*)p = *(_emi__GetSensorAttributes*)q; +} + +void _emi__EnumerateSensorsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__EnumerateSensorsResponse*)this)->TotalCount, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_emi__EnumerateSensorsResponse*)this)->HandleCount, SOAP_TYPE_unsignedInt); + soap_serialize_PointerToemi__SensorHandleArrayType(soap, &((_emi__EnumerateSensorsResponse*)this)->Handles); + /* transient soap skipped */ +} + +void _emi__EnumerateSensorsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__EnumerateSensorsResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_emi__EnumerateSensorsResponse*)this)->TotalCount); + soap_default_unsignedInt(soap, &((_emi__EnumerateSensorsResponse*)this)->HandleCount); + ((_emi__EnumerateSensorsResponse*)this)->Handles = NULL; + /* transient soap skipped */ +} + +int _emi__EnumerateSensorsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateSensorsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateSensorsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateSensorsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateSensorsResponse(struct soap *soap, const char *tag, int id, const _emi__EnumerateSensorsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateSensorsResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__EnumerateSensorsResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "emi:TotalCount", -1, &(((_emi__EnumerateSensorsResponse*)a)->TotalCount), ""); + soap_out_unsignedInt(soap, "emi:HandleCount", -1, &(((_emi__EnumerateSensorsResponse*)a)->HandleCount), ""); + soap_out_PointerToemi__SensorHandleArrayType(soap, "emi:Handles", -1, &(((_emi__EnumerateSensorsResponse*)a)->Handles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateSensorsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateSensorsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateSensorsResponse * SOAP_FMAC4 soap_get__emi__EnumerateSensorsResponse(struct soap *soap, _emi__EnumerateSensorsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateSensorsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateSensorsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateSensorsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateSensorsResponse * SOAP_FMAC4 soap_in__emi__EnumerateSensorsResponse(struct soap *soap, const char *tag, _emi__EnumerateSensorsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateSensorsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateSensorsResponse, sizeof(_emi__EnumerateSensorsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateSensorsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateSensorsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_TotalCount1 = 1, soap_flag_HandleCount1 = 1, soap_flag_Handles1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__EnumerateSensorsResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_TotalCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:TotalCount", &(((_emi__EnumerateSensorsResponse*)a)->TotalCount), "xsd:unsignedInt")) + { soap_flag_TotalCount1--; + continue; + } + if (soap_flag_HandleCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:HandleCount", &(((_emi__EnumerateSensorsResponse*)a)->HandleCount), "xsd:unsignedInt")) + { soap_flag_HandleCount1--; + continue; + } + if (soap_flag_Handles1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__SensorHandleArrayType(soap, "emi:Handles", &(((_emi__EnumerateSensorsResponse*)a)->Handles), "emi:SensorHandleArrayType")) + { soap_flag_Handles1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_TotalCount1 > 0 || soap_flag_HandleCount1 > 0 || soap_flag_Handles1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateSensorsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateSensorsResponse, 0, sizeof(_emi__EnumerateSensorsResponse), 0, soap_copy__emi__EnumerateSensorsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateSensorsResponse * SOAP_FMAC6 soap_new__emi__EnumerateSensorsResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateSensorsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateSensorsResponse(struct soap *soap, _emi__EnumerateSensorsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateSensorsResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateSensorsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateSensorsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateSensorsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateSensorsResponse; + if (size) + *size = sizeof(_emi__EnumerateSensorsResponse); + ((_emi__EnumerateSensorsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateSensorsResponse[n]; + if (size) + *size = n * sizeof(_emi__EnumerateSensorsResponse); + for (int i = 0; i < n; i++) + ((_emi__EnumerateSensorsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateSensorsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateSensorsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateSensorsResponse %p -> %p\n", q, p)); + *(_emi__EnumerateSensorsResponse*)p = *(_emi__EnumerateSensorsResponse*)q; +} + +void _emi__EnumerateSensors::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__EnumerateSensors*)this)->StartIndex, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _emi__EnumerateSensors::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_emi__EnumerateSensors*)this)->StartIndex); + /* transient soap skipped */ +} + +int _emi__EnumerateSensors::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateSensors); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateSensors::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateSensors(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateSensors(struct soap *soap, const char *tag, int id, const _emi__EnumerateSensors *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateSensors), type); + soap_out_unsignedInt(soap, "emi:StartIndex", -1, &(((_emi__EnumerateSensors*)a)->StartIndex), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateSensors::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateSensors(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateSensors * SOAP_FMAC4 soap_get__emi__EnumerateSensors(struct soap *soap, _emi__EnumerateSensors *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateSensors(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateSensors::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateSensors(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateSensors * SOAP_FMAC4 soap_in__emi__EnumerateSensors(struct soap *soap, const char *tag, _emi__EnumerateSensors *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateSensors *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateSensors, sizeof(_emi__EnumerateSensors), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateSensors) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateSensors *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StartIndex1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StartIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:StartIndex", &(((_emi__EnumerateSensors*)a)->StartIndex), "xsd:unsignedInt")) + { soap_flag_StartIndex1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StartIndex1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateSensors *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateSensors, 0, sizeof(_emi__EnumerateSensors), 0, soap_copy__emi__EnumerateSensors); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateSensors * SOAP_FMAC6 soap_new__emi__EnumerateSensors(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateSensors(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateSensors(struct soap *soap, _emi__EnumerateSensors *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateSensors * SOAP_FMAC4 soap_instantiate__emi__EnumerateSensors(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateSensors(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateSensors, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateSensors; + if (size) + *size = sizeof(_emi__EnumerateSensors); + ((_emi__EnumerateSensors*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateSensors[n]; + if (size) + *size = n * sizeof(_emi__EnumerateSensors); + for (int i = 0; i < n; i++) + ((_emi__EnumerateSensors*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateSensors*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateSensors(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateSensors %p -> %p\n", q, p)); + *(_emi__EnumerateSensors*)p = *(_emi__EnumerateSensors*)q; +} + +void _emi__GetEventLogTimestampClockResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__GetEventLogTimestampClockResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__GetEventLogTimestampClockResponse*)this)->Status); + soap_default_emi__TimeType(soap, &((_emi__GetEventLogTimestampClockResponse*)this)->Time); + /* transient soap skipped */ +} + +int _emi__GetEventLogTimestampClockResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetEventLogTimestampClockResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetEventLogTimestampClockResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetEventLogTimestampClockResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventLogTimestampClockResponse(struct soap *soap, const char *tag, int id, const _emi__GetEventLogTimestampClockResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetEventLogTimestampClockResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__GetEventLogTimestampClockResponse*)a)->Status), ""); + soap_out_emi__TimeType(soap, "emi:Time", -1, &(((_emi__GetEventLogTimestampClockResponse*)a)->Time), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetEventLogTimestampClockResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetEventLogTimestampClockResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse * SOAP_FMAC4 soap_get__emi__GetEventLogTimestampClockResponse(struct soap *soap, _emi__GetEventLogTimestampClockResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetEventLogTimestampClockResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetEventLogTimestampClockResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetEventLogTimestampClockResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse * SOAP_FMAC4 soap_in__emi__GetEventLogTimestampClockResponse(struct soap *soap, const char *tag, _emi__GetEventLogTimestampClockResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetEventLogTimestampClockResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetEventLogTimestampClockResponse, sizeof(_emi__GetEventLogTimestampClockResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetEventLogTimestampClockResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetEventLogTimestampClockResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Time1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__GetEventLogTimestampClockResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Time1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__TimeType(soap, "emi:Time", &(((_emi__GetEventLogTimestampClockResponse*)a)->Time), "emi:TimeType")) + { soap_flag_Time1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Time1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetEventLogTimestampClockResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetEventLogTimestampClockResponse, 0, sizeof(_emi__GetEventLogTimestampClockResponse), 0, soap_copy__emi__GetEventLogTimestampClockResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetEventLogTimestampClockResponse * SOAP_FMAC6 soap_new__emi__GetEventLogTimestampClockResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__GetEventLogTimestampClockResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventLogTimestampClockResponse(struct soap *soap, _emi__GetEventLogTimestampClockResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse * SOAP_FMAC4 soap_instantiate__emi__GetEventLogTimestampClockResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetEventLogTimestampClockResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetEventLogTimestampClockResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetEventLogTimestampClockResponse; + if (size) + *size = sizeof(_emi__GetEventLogTimestampClockResponse); + ((_emi__GetEventLogTimestampClockResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetEventLogTimestampClockResponse[n]; + if (size) + *size = n * sizeof(_emi__GetEventLogTimestampClockResponse); + for (int i = 0; i < n; i++) + ((_emi__GetEventLogTimestampClockResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetEventLogTimestampClockResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventLogTimestampClockResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetEventLogTimestampClockResponse %p -> %p\n", q, p)); + *(_emi__GetEventLogTimestampClockResponse*)p = *(_emi__GetEventLogTimestampClockResponse*)q; +} + +void _emi__GetEventLogTimestampClock::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__GetEventLogTimestampClock::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _emi__GetEventLogTimestampClock::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetEventLogTimestampClock); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetEventLogTimestampClock::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetEventLogTimestampClock(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventLogTimestampClock(struct soap *soap, const char *tag, int id, const _emi__GetEventLogTimestampClock *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetEventLogTimestampClock), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetEventLogTimestampClock::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetEventLogTimestampClock(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_get__emi__GetEventLogTimestampClock(struct soap *soap, _emi__GetEventLogTimestampClock *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetEventLogTimestampClock(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetEventLogTimestampClock::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetEventLogTimestampClock(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_in__emi__GetEventLogTimestampClock(struct soap *soap, const char *tag, _emi__GetEventLogTimestampClock *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetEventLogTimestampClock *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetEventLogTimestampClock, sizeof(_emi__GetEventLogTimestampClock), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetEventLogTimestampClock) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetEventLogTimestampClock *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetEventLogTimestampClock *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetEventLogTimestampClock, 0, sizeof(_emi__GetEventLogTimestampClock), 0, soap_copy__emi__GetEventLogTimestampClock); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetEventLogTimestampClock * SOAP_FMAC6 soap_new__emi__GetEventLogTimestampClock(struct soap *soap, int n) +{ return soap_instantiate__emi__GetEventLogTimestampClock(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventLogTimestampClock(struct soap *soap, _emi__GetEventLogTimestampClock *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_instantiate__emi__GetEventLogTimestampClock(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetEventLogTimestampClock(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetEventLogTimestampClock, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetEventLogTimestampClock; + if (size) + *size = sizeof(_emi__GetEventLogTimestampClock); + ((_emi__GetEventLogTimestampClock*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetEventLogTimestampClock[n]; + if (size) + *size = n * sizeof(_emi__GetEventLogTimestampClock); + for (int i = 0; i < n; i++) + ((_emi__GetEventLogTimestampClock*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetEventLogTimestampClock*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventLogTimestampClock(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetEventLogTimestampClock %p -> %p\n", q, p)); + *(_emi__GetEventLogTimestampClock*)p = *(_emi__GetEventLogTimestampClock*)q; +} + +void _emi__SetEventLogTimestampClockResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__SetEventLogTimestampClockResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__SetEventLogTimestampClockResponse*)this)->Status); + /* transient soap skipped */ +} + +int _emi__SetEventLogTimestampClockResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__SetEventLogTimestampClockResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__SetEventLogTimestampClockResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__SetEventLogTimestampClockResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SetEventLogTimestampClockResponse(struct soap *soap, const char *tag, int id, const _emi__SetEventLogTimestampClockResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__SetEventLogTimestampClockResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__SetEventLogTimestampClockResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__SetEventLogTimestampClockResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__SetEventLogTimestampClockResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse * SOAP_FMAC4 soap_get__emi__SetEventLogTimestampClockResponse(struct soap *soap, _emi__SetEventLogTimestampClockResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__SetEventLogTimestampClockResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__SetEventLogTimestampClockResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__SetEventLogTimestampClockResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse * SOAP_FMAC4 soap_in__emi__SetEventLogTimestampClockResponse(struct soap *soap, const char *tag, _emi__SetEventLogTimestampClockResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__SetEventLogTimestampClockResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__SetEventLogTimestampClockResponse, sizeof(_emi__SetEventLogTimestampClockResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__SetEventLogTimestampClockResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__SetEventLogTimestampClockResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__SetEventLogTimestampClockResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__SetEventLogTimestampClockResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__SetEventLogTimestampClockResponse, 0, sizeof(_emi__SetEventLogTimestampClockResponse), 0, soap_copy__emi__SetEventLogTimestampClockResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__SetEventLogTimestampClockResponse * SOAP_FMAC6 soap_new__emi__SetEventLogTimestampClockResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__SetEventLogTimestampClockResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SetEventLogTimestampClockResponse(struct soap *soap, _emi__SetEventLogTimestampClockResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse * SOAP_FMAC4 soap_instantiate__emi__SetEventLogTimestampClockResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__SetEventLogTimestampClockResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__SetEventLogTimestampClockResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__SetEventLogTimestampClockResponse; + if (size) + *size = sizeof(_emi__SetEventLogTimestampClockResponse); + ((_emi__SetEventLogTimestampClockResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__SetEventLogTimestampClockResponse[n]; + if (size) + *size = n * sizeof(_emi__SetEventLogTimestampClockResponse); + for (int i = 0; i < n; i++) + ((_emi__SetEventLogTimestampClockResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__SetEventLogTimestampClockResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SetEventLogTimestampClockResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__SetEventLogTimestampClockResponse %p -> %p\n", q, p)); + *(_emi__SetEventLogTimestampClockResponse*)p = *(_emi__SetEventLogTimestampClockResponse*)q; +} + +void _emi__SetEventLogTimestampClock::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__SetEventLogTimestampClock::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__TimeType(soap, &((_emi__SetEventLogTimestampClock*)this)->Time); + /* transient soap skipped */ +} + +int _emi__SetEventLogTimestampClock::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__SetEventLogTimestampClock); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__SetEventLogTimestampClock::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__SetEventLogTimestampClock(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SetEventLogTimestampClock(struct soap *soap, const char *tag, int id, const _emi__SetEventLogTimestampClock *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__SetEventLogTimestampClock), type); + soap_out_emi__TimeType(soap, "emi:Time", -1, &(((_emi__SetEventLogTimestampClock*)a)->Time), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__SetEventLogTimestampClock::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__SetEventLogTimestampClock(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_get__emi__SetEventLogTimestampClock(struct soap *soap, _emi__SetEventLogTimestampClock *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__SetEventLogTimestampClock(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__SetEventLogTimestampClock::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__SetEventLogTimestampClock(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_in__emi__SetEventLogTimestampClock(struct soap *soap, const char *tag, _emi__SetEventLogTimestampClock *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__SetEventLogTimestampClock *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__SetEventLogTimestampClock, sizeof(_emi__SetEventLogTimestampClock), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__SetEventLogTimestampClock) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__SetEventLogTimestampClock *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Time1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Time1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__TimeType(soap, "emi:Time", &(((_emi__SetEventLogTimestampClock*)a)->Time), "emi:TimeType")) + { soap_flag_Time1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Time1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__SetEventLogTimestampClock *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__SetEventLogTimestampClock, 0, sizeof(_emi__SetEventLogTimestampClock), 0, soap_copy__emi__SetEventLogTimestampClock); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__SetEventLogTimestampClock * SOAP_FMAC6 soap_new__emi__SetEventLogTimestampClock(struct soap *soap, int n) +{ return soap_instantiate__emi__SetEventLogTimestampClock(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SetEventLogTimestampClock(struct soap *soap, _emi__SetEventLogTimestampClock *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_instantiate__emi__SetEventLogTimestampClock(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__SetEventLogTimestampClock(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__SetEventLogTimestampClock, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__SetEventLogTimestampClock; + if (size) + *size = sizeof(_emi__SetEventLogTimestampClock); + ((_emi__SetEventLogTimestampClock*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__SetEventLogTimestampClock[n]; + if (size) + *size = n * sizeof(_emi__SetEventLogTimestampClock); + for (int i = 0; i < n; i++) + ((_emi__SetEventLogTimestampClock*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__SetEventLogTimestampClock*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SetEventLogTimestampClock(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__SetEventLogTimestampClock %p -> %p\n", q, p)); + *(_emi__SetEventLogTimestampClock*)p = *(_emi__SetEventLogTimestampClock*)q; +} + +void _emi__FreezeEventLogResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__FreezeEventLogResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__FreezeEventLogResponse*)this)->Status); + /* transient soap skipped */ +} + +int _emi__FreezeEventLogResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__FreezeEventLogResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__FreezeEventLogResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__FreezeEventLogResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__FreezeEventLogResponse(struct soap *soap, const char *tag, int id, const _emi__FreezeEventLogResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__FreezeEventLogResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__FreezeEventLogResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__FreezeEventLogResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__FreezeEventLogResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__FreezeEventLogResponse * SOAP_FMAC4 soap_get__emi__FreezeEventLogResponse(struct soap *soap, _emi__FreezeEventLogResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__FreezeEventLogResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__FreezeEventLogResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__FreezeEventLogResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__FreezeEventLogResponse * SOAP_FMAC4 soap_in__emi__FreezeEventLogResponse(struct soap *soap, const char *tag, _emi__FreezeEventLogResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__FreezeEventLogResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__FreezeEventLogResponse, sizeof(_emi__FreezeEventLogResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__FreezeEventLogResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__FreezeEventLogResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__FreezeEventLogResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__FreezeEventLogResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__FreezeEventLogResponse, 0, sizeof(_emi__FreezeEventLogResponse), 0, soap_copy__emi__FreezeEventLogResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__FreezeEventLogResponse * SOAP_FMAC6 soap_new__emi__FreezeEventLogResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__FreezeEventLogResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__FreezeEventLogResponse(struct soap *soap, _emi__FreezeEventLogResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__FreezeEventLogResponse * SOAP_FMAC4 soap_instantiate__emi__FreezeEventLogResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__FreezeEventLogResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__FreezeEventLogResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__FreezeEventLogResponse; + if (size) + *size = sizeof(_emi__FreezeEventLogResponse); + ((_emi__FreezeEventLogResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__FreezeEventLogResponse[n]; + if (size) + *size = n * sizeof(_emi__FreezeEventLogResponse); + for (int i = 0; i < n; i++) + ((_emi__FreezeEventLogResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__FreezeEventLogResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__FreezeEventLogResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__FreezeEventLogResponse %p -> %p\n", q, p)); + *(_emi__FreezeEventLogResponse*)p = *(_emi__FreezeEventLogResponse*)q; +} + +void _emi__FreezeEventLog::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__FreezeEventLog*)this)->NewState, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _emi__FreezeEventLog::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((_emi__FreezeEventLog*)this)->NewState); + /* transient soap skipped */ +} + +int _emi__FreezeEventLog::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__FreezeEventLog); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__FreezeEventLog::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__FreezeEventLog(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__FreezeEventLog(struct soap *soap, const char *tag, int id, const _emi__FreezeEventLog *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__FreezeEventLog), type); + soap_out_bool(soap, "emi:NewState", -1, &(((_emi__FreezeEventLog*)a)->NewState), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__FreezeEventLog::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__FreezeEventLog(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__FreezeEventLog * SOAP_FMAC4 soap_get__emi__FreezeEventLog(struct soap *soap, _emi__FreezeEventLog *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__FreezeEventLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__FreezeEventLog::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__FreezeEventLog(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__FreezeEventLog * SOAP_FMAC4 soap_in__emi__FreezeEventLog(struct soap *soap, const char *tag, _emi__FreezeEventLog *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__FreezeEventLog *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__FreezeEventLog, sizeof(_emi__FreezeEventLog), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__FreezeEventLog) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__FreezeEventLog *)a->soap_in(soap, tag, type); + } + } + short soap_flag_NewState1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_NewState1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "emi:NewState", &(((_emi__FreezeEventLog*)a)->NewState), "xsd:boolean")) + { soap_flag_NewState1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_NewState1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__FreezeEventLog *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__FreezeEventLog, 0, sizeof(_emi__FreezeEventLog), 0, soap_copy__emi__FreezeEventLog); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__FreezeEventLog * SOAP_FMAC6 soap_new__emi__FreezeEventLog(struct soap *soap, int n) +{ return soap_instantiate__emi__FreezeEventLog(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__FreezeEventLog(struct soap *soap, _emi__FreezeEventLog *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__FreezeEventLog * SOAP_FMAC4 soap_instantiate__emi__FreezeEventLog(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__FreezeEventLog(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__FreezeEventLog, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__FreezeEventLog; + if (size) + *size = sizeof(_emi__FreezeEventLog); + ((_emi__FreezeEventLog*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__FreezeEventLog[n]; + if (size) + *size = n * sizeof(_emi__FreezeEventLog); + for (int i = 0; i < n; i++) + ((_emi__FreezeEventLog*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__FreezeEventLog*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__FreezeEventLog(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__FreezeEventLog %p -> %p\n", q, p)); + *(_emi__FreezeEventLog*)p = *(_emi__FreezeEventLog*)q; +} + +void _emi__ClearEventLogResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__ClearEventLogResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__ClearEventLogResponse*)this)->Status); + /* transient soap skipped */ +} + +int _emi__ClearEventLogResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__ClearEventLogResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__ClearEventLogResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__ClearEventLogResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__ClearEventLogResponse(struct soap *soap, const char *tag, int id, const _emi__ClearEventLogResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__ClearEventLogResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__ClearEventLogResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__ClearEventLogResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__ClearEventLogResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__ClearEventLogResponse * SOAP_FMAC4 soap_get__emi__ClearEventLogResponse(struct soap *soap, _emi__ClearEventLogResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__ClearEventLogResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__ClearEventLogResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__ClearEventLogResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__ClearEventLogResponse * SOAP_FMAC4 soap_in__emi__ClearEventLogResponse(struct soap *soap, const char *tag, _emi__ClearEventLogResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__ClearEventLogResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__ClearEventLogResponse, sizeof(_emi__ClearEventLogResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__ClearEventLogResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__ClearEventLogResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__ClearEventLogResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__ClearEventLogResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__ClearEventLogResponse, 0, sizeof(_emi__ClearEventLogResponse), 0, soap_copy__emi__ClearEventLogResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__ClearEventLogResponse * SOAP_FMAC6 soap_new__emi__ClearEventLogResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__ClearEventLogResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__ClearEventLogResponse(struct soap *soap, _emi__ClearEventLogResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__ClearEventLogResponse * SOAP_FMAC4 soap_instantiate__emi__ClearEventLogResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__ClearEventLogResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__ClearEventLogResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__ClearEventLogResponse; + if (size) + *size = sizeof(_emi__ClearEventLogResponse); + ((_emi__ClearEventLogResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__ClearEventLogResponse[n]; + if (size) + *size = n * sizeof(_emi__ClearEventLogResponse); + for (int i = 0; i < n; i++) + ((_emi__ClearEventLogResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__ClearEventLogResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__ClearEventLogResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__ClearEventLogResponse %p -> %p\n", q, p)); + *(_emi__ClearEventLogResponse*)p = *(_emi__ClearEventLogResponse*)q; +} + +void _emi__ClearEventLog::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__ClearEventLog::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _emi__ClearEventLog::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__ClearEventLog); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__ClearEventLog::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__ClearEventLog(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__ClearEventLog(struct soap *soap, const char *tag, int id, const _emi__ClearEventLog *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__ClearEventLog), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__ClearEventLog::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__ClearEventLog(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__ClearEventLog * SOAP_FMAC4 soap_get__emi__ClearEventLog(struct soap *soap, _emi__ClearEventLog *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__ClearEventLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__ClearEventLog::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__ClearEventLog(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__ClearEventLog * SOAP_FMAC4 soap_in__emi__ClearEventLog(struct soap *soap, const char *tag, _emi__ClearEventLog *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__ClearEventLog *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__ClearEventLog, sizeof(_emi__ClearEventLog), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__ClearEventLog) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__ClearEventLog *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__ClearEventLog *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__ClearEventLog, 0, sizeof(_emi__ClearEventLog), 0, soap_copy__emi__ClearEventLog); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__ClearEventLog * SOAP_FMAC6 soap_new__emi__ClearEventLog(struct soap *soap, int n) +{ return soap_instantiate__emi__ClearEventLog(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__ClearEventLog(struct soap *soap, _emi__ClearEventLog *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__ClearEventLog * SOAP_FMAC4 soap_instantiate__emi__ClearEventLog(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__ClearEventLog(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__ClearEventLog, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__ClearEventLog; + if (size) + *size = sizeof(_emi__ClearEventLog); + ((_emi__ClearEventLog*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__ClearEventLog[n]; + if (size) + *size = n * sizeof(_emi__ClearEventLog); + for (int i = 0; i < n; i++) + ((_emi__ClearEventLog*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__ClearEventLog*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__ClearEventLog(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__ClearEventLog %p -> %p\n", q, p)); + *(_emi__ClearEventLog*)p = *(_emi__ClearEventLog*)q; +} + +void _emi__GetEventLogStatusResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__GetEventLogStatusResponse*)this)->NumberOfFreeRecords, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_emi__GetEventLogStatusResponse*)this)->NumberOfRecords, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_emi__GetEventLogStatusResponse*)this)->IsFrozen, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _emi__GetEventLogStatusResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__GetEventLogStatusResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_emi__GetEventLogStatusResponse*)this)->NumberOfFreeRecords); + soap_default_unsignedInt(soap, &((_emi__GetEventLogStatusResponse*)this)->NumberOfRecords); + soap_default_emi__TimeType(soap, &((_emi__GetEventLogStatusResponse*)this)->Time); + soap_default_bool(soap, &((_emi__GetEventLogStatusResponse*)this)->IsFrozen); + /* transient soap skipped */ +} + +int _emi__GetEventLogStatusResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetEventLogStatusResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetEventLogStatusResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetEventLogStatusResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventLogStatusResponse(struct soap *soap, const char *tag, int id, const _emi__GetEventLogStatusResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetEventLogStatusResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__GetEventLogStatusResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "emi:NumberOfFreeRecords", -1, &(((_emi__GetEventLogStatusResponse*)a)->NumberOfFreeRecords), ""); + soap_out_unsignedInt(soap, "emi:NumberOfRecords", -1, &(((_emi__GetEventLogStatusResponse*)a)->NumberOfRecords), ""); + soap_out_emi__TimeType(soap, "emi:Time", -1, &(((_emi__GetEventLogStatusResponse*)a)->Time), ""); + soap_out_bool(soap, "emi:IsFrozen", -1, &(((_emi__GetEventLogStatusResponse*)a)->IsFrozen), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetEventLogStatusResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetEventLogStatusResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetEventLogStatusResponse * SOAP_FMAC4 soap_get__emi__GetEventLogStatusResponse(struct soap *soap, _emi__GetEventLogStatusResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetEventLogStatusResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetEventLogStatusResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetEventLogStatusResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetEventLogStatusResponse * SOAP_FMAC4 soap_in__emi__GetEventLogStatusResponse(struct soap *soap, const char *tag, _emi__GetEventLogStatusResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetEventLogStatusResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetEventLogStatusResponse, sizeof(_emi__GetEventLogStatusResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetEventLogStatusResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetEventLogStatusResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_NumberOfFreeRecords1 = 1, soap_flag_NumberOfRecords1 = 1, soap_flag_Time1 = 1, soap_flag_IsFrozen1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__GetEventLogStatusResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_NumberOfFreeRecords1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:NumberOfFreeRecords", &(((_emi__GetEventLogStatusResponse*)a)->NumberOfFreeRecords), "xsd:unsignedInt")) + { soap_flag_NumberOfFreeRecords1--; + continue; + } + if (soap_flag_NumberOfRecords1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:NumberOfRecords", &(((_emi__GetEventLogStatusResponse*)a)->NumberOfRecords), "xsd:unsignedInt")) + { soap_flag_NumberOfRecords1--; + continue; + } + if (soap_flag_Time1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__TimeType(soap, "emi:Time", &(((_emi__GetEventLogStatusResponse*)a)->Time), "emi:TimeType")) + { soap_flag_Time1--; + continue; + } + if (soap_flag_IsFrozen1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "emi:IsFrozen", &(((_emi__GetEventLogStatusResponse*)a)->IsFrozen), "xsd:boolean")) + { soap_flag_IsFrozen1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_NumberOfFreeRecords1 > 0 || soap_flag_NumberOfRecords1 > 0 || soap_flag_Time1 > 0 || soap_flag_IsFrozen1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetEventLogStatusResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetEventLogStatusResponse, 0, sizeof(_emi__GetEventLogStatusResponse), 0, soap_copy__emi__GetEventLogStatusResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetEventLogStatusResponse * SOAP_FMAC6 soap_new__emi__GetEventLogStatusResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__GetEventLogStatusResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventLogStatusResponse(struct soap *soap, _emi__GetEventLogStatusResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetEventLogStatusResponse * SOAP_FMAC4 soap_instantiate__emi__GetEventLogStatusResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetEventLogStatusResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetEventLogStatusResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetEventLogStatusResponse; + if (size) + *size = sizeof(_emi__GetEventLogStatusResponse); + ((_emi__GetEventLogStatusResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetEventLogStatusResponse[n]; + if (size) + *size = n * sizeof(_emi__GetEventLogStatusResponse); + for (int i = 0; i < n; i++) + ((_emi__GetEventLogStatusResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetEventLogStatusResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventLogStatusResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetEventLogStatusResponse %p -> %p\n", q, p)); + *(_emi__GetEventLogStatusResponse*)p = *(_emi__GetEventLogStatusResponse*)q; +} + +void _emi__GetEventLogStatus::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__GetEventLogStatus::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _emi__GetEventLogStatus::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetEventLogStatus); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetEventLogStatus::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetEventLogStatus(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventLogStatus(struct soap *soap, const char *tag, int id, const _emi__GetEventLogStatus *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetEventLogStatus), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetEventLogStatus::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetEventLogStatus(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetEventLogStatus * SOAP_FMAC4 soap_get__emi__GetEventLogStatus(struct soap *soap, _emi__GetEventLogStatus *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetEventLogStatus(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetEventLogStatus::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetEventLogStatus(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetEventLogStatus * SOAP_FMAC4 soap_in__emi__GetEventLogStatus(struct soap *soap, const char *tag, _emi__GetEventLogStatus *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetEventLogStatus *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetEventLogStatus, sizeof(_emi__GetEventLogStatus), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetEventLogStatus) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetEventLogStatus *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetEventLogStatus *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetEventLogStatus, 0, sizeof(_emi__GetEventLogStatus), 0, soap_copy__emi__GetEventLogStatus); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetEventLogStatus * SOAP_FMAC6 soap_new__emi__GetEventLogStatus(struct soap *soap, int n) +{ return soap_instantiate__emi__GetEventLogStatus(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventLogStatus(struct soap *soap, _emi__GetEventLogStatus *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetEventLogStatus * SOAP_FMAC4 soap_instantiate__emi__GetEventLogStatus(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetEventLogStatus(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetEventLogStatus, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetEventLogStatus; + if (size) + *size = sizeof(_emi__GetEventLogStatus); + ((_emi__GetEventLogStatus*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetEventLogStatus[n]; + if (size) + *size = n * sizeof(_emi__GetEventLogStatus); + for (int i = 0; i < n; i++) + ((_emi__GetEventLogStatus*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetEventLogStatus*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventLogStatus(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetEventLogStatus %p -> %p\n", q, p)); + *(_emi__GetEventLogStatus*)p = *(_emi__GetEventLogStatus*)q; +} + +void _emi__ReadEventLogRecordsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__ReadEventLogRecordsResponse*)this)->TotalRecordCount, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_emi__ReadEventLogRecordsResponse*)this)->RecordsReturned, SOAP_TYPE_unsignedInt); + soap_serialize_PointerToemi__EventLogRecordArrayType(soap, &((_emi__ReadEventLogRecordsResponse*)this)->EventRecords); + /* transient soap skipped */ +} + +void _emi__ReadEventLogRecordsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__ReadEventLogRecordsResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_emi__ReadEventLogRecordsResponse*)this)->TotalRecordCount); + soap_default_unsignedInt(soap, &((_emi__ReadEventLogRecordsResponse*)this)->RecordsReturned); + ((_emi__ReadEventLogRecordsResponse*)this)->EventRecords = NULL; + /* transient soap skipped */ +} + +int _emi__ReadEventLogRecordsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__ReadEventLogRecordsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__ReadEventLogRecordsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__ReadEventLogRecordsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__ReadEventLogRecordsResponse(struct soap *soap, const char *tag, int id, const _emi__ReadEventLogRecordsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__ReadEventLogRecordsResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__ReadEventLogRecordsResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "emi:TotalRecordCount", -1, &(((_emi__ReadEventLogRecordsResponse*)a)->TotalRecordCount), ""); + soap_out_unsignedInt(soap, "emi:RecordsReturned", -1, &(((_emi__ReadEventLogRecordsResponse*)a)->RecordsReturned), ""); + soap_out_PointerToemi__EventLogRecordArrayType(soap, "emi:EventRecords", -1, &(((_emi__ReadEventLogRecordsResponse*)a)->EventRecords), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__ReadEventLogRecordsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__ReadEventLogRecordsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse * SOAP_FMAC4 soap_get__emi__ReadEventLogRecordsResponse(struct soap *soap, _emi__ReadEventLogRecordsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__ReadEventLogRecordsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__ReadEventLogRecordsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__ReadEventLogRecordsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse * SOAP_FMAC4 soap_in__emi__ReadEventLogRecordsResponse(struct soap *soap, const char *tag, _emi__ReadEventLogRecordsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__ReadEventLogRecordsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__ReadEventLogRecordsResponse, sizeof(_emi__ReadEventLogRecordsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__ReadEventLogRecordsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__ReadEventLogRecordsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_TotalRecordCount1 = 1, soap_flag_RecordsReturned1 = 1, soap_flag_EventRecords1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__ReadEventLogRecordsResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_TotalRecordCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:TotalRecordCount", &(((_emi__ReadEventLogRecordsResponse*)a)->TotalRecordCount), "xsd:unsignedInt")) + { soap_flag_TotalRecordCount1--; + continue; + } + if (soap_flag_RecordsReturned1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:RecordsReturned", &(((_emi__ReadEventLogRecordsResponse*)a)->RecordsReturned), "xsd:unsignedInt")) + { soap_flag_RecordsReturned1--; + continue; + } + if (soap_flag_EventRecords1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__EventLogRecordArrayType(soap, "emi:EventRecords", &(((_emi__ReadEventLogRecordsResponse*)a)->EventRecords), "emi:EventLogRecordArrayType")) + { soap_flag_EventRecords1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_TotalRecordCount1 > 0 || soap_flag_RecordsReturned1 > 0 || soap_flag_EventRecords1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__ReadEventLogRecordsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__ReadEventLogRecordsResponse, 0, sizeof(_emi__ReadEventLogRecordsResponse), 0, soap_copy__emi__ReadEventLogRecordsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__ReadEventLogRecordsResponse * SOAP_FMAC6 soap_new__emi__ReadEventLogRecordsResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__ReadEventLogRecordsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__ReadEventLogRecordsResponse(struct soap *soap, _emi__ReadEventLogRecordsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse * SOAP_FMAC4 soap_instantiate__emi__ReadEventLogRecordsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__ReadEventLogRecordsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__ReadEventLogRecordsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__ReadEventLogRecordsResponse; + if (size) + *size = sizeof(_emi__ReadEventLogRecordsResponse); + ((_emi__ReadEventLogRecordsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__ReadEventLogRecordsResponse[n]; + if (size) + *size = n * sizeof(_emi__ReadEventLogRecordsResponse); + for (int i = 0; i < n; i++) + ((_emi__ReadEventLogRecordsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__ReadEventLogRecordsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__ReadEventLogRecordsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__ReadEventLogRecordsResponse %p -> %p\n", q, p)); + *(_emi__ReadEventLogRecordsResponse*)p = *(_emi__ReadEventLogRecordsResponse*)q; +} + +void _emi__ReadEventLogRecords::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__ReadEventLogRecords*)this)->StartIndex, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _emi__ReadEventLogRecords::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_emi__ReadEventLogRecords*)this)->StartIndex); + /* transient soap skipped */ +} + +int _emi__ReadEventLogRecords::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__ReadEventLogRecords); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__ReadEventLogRecords::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__ReadEventLogRecords(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__ReadEventLogRecords(struct soap *soap, const char *tag, int id, const _emi__ReadEventLogRecords *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__ReadEventLogRecords), type); + soap_out_unsignedInt(soap, "emi:StartIndex", -1, &(((_emi__ReadEventLogRecords*)a)->StartIndex), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__ReadEventLogRecords::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__ReadEventLogRecords(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__ReadEventLogRecords * SOAP_FMAC4 soap_get__emi__ReadEventLogRecords(struct soap *soap, _emi__ReadEventLogRecords *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__ReadEventLogRecords(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__ReadEventLogRecords::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__ReadEventLogRecords(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__ReadEventLogRecords * SOAP_FMAC4 soap_in__emi__ReadEventLogRecords(struct soap *soap, const char *tag, _emi__ReadEventLogRecords *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__ReadEventLogRecords *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__ReadEventLogRecords, sizeof(_emi__ReadEventLogRecords), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__ReadEventLogRecords) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__ReadEventLogRecords *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StartIndex1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StartIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:StartIndex", &(((_emi__ReadEventLogRecords*)a)->StartIndex), "xsd:unsignedInt")) + { soap_flag_StartIndex1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StartIndex1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__ReadEventLogRecords *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__ReadEventLogRecords, 0, sizeof(_emi__ReadEventLogRecords), 0, soap_copy__emi__ReadEventLogRecords); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__ReadEventLogRecords * SOAP_FMAC6 soap_new__emi__ReadEventLogRecords(struct soap *soap, int n) +{ return soap_instantiate__emi__ReadEventLogRecords(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__ReadEventLogRecords(struct soap *soap, _emi__ReadEventLogRecords *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__ReadEventLogRecords * SOAP_FMAC4 soap_instantiate__emi__ReadEventLogRecords(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__ReadEventLogRecords(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__ReadEventLogRecords, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__ReadEventLogRecords; + if (size) + *size = sizeof(_emi__ReadEventLogRecords); + ((_emi__ReadEventLogRecords*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__ReadEventLogRecords[n]; + if (size) + *size = n * sizeof(_emi__ReadEventLogRecords); + for (int i = 0; i < n; i++) + ((_emi__ReadEventLogRecords*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__ReadEventLogRecords*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__ReadEventLogRecords(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__ReadEventLogRecords %p -> %p\n", q, p)); + *(_emi__ReadEventLogRecords*)p = *(_emi__ReadEventLogRecords*)q; +} + +void _emi__RemoveEventFilterResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__RemoveEventFilterResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__RemoveEventFilterResponse*)this)->Status); + /* transient soap skipped */ +} + +int _emi__RemoveEventFilterResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__RemoveEventFilterResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__RemoveEventFilterResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__RemoveEventFilterResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__RemoveEventFilterResponse(struct soap *soap, const char *tag, int id, const _emi__RemoveEventFilterResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__RemoveEventFilterResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__RemoveEventFilterResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__RemoveEventFilterResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__RemoveEventFilterResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__RemoveEventFilterResponse * SOAP_FMAC4 soap_get__emi__RemoveEventFilterResponse(struct soap *soap, _emi__RemoveEventFilterResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__RemoveEventFilterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__RemoveEventFilterResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__RemoveEventFilterResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__RemoveEventFilterResponse * SOAP_FMAC4 soap_in__emi__RemoveEventFilterResponse(struct soap *soap, const char *tag, _emi__RemoveEventFilterResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__RemoveEventFilterResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__RemoveEventFilterResponse, sizeof(_emi__RemoveEventFilterResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__RemoveEventFilterResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__RemoveEventFilterResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__RemoveEventFilterResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__RemoveEventFilterResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__RemoveEventFilterResponse, 0, sizeof(_emi__RemoveEventFilterResponse), 0, soap_copy__emi__RemoveEventFilterResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__RemoveEventFilterResponse * SOAP_FMAC6 soap_new__emi__RemoveEventFilterResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__RemoveEventFilterResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__RemoveEventFilterResponse(struct soap *soap, _emi__RemoveEventFilterResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__RemoveEventFilterResponse * SOAP_FMAC4 soap_instantiate__emi__RemoveEventFilterResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__RemoveEventFilterResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__RemoveEventFilterResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__RemoveEventFilterResponse; + if (size) + *size = sizeof(_emi__RemoveEventFilterResponse); + ((_emi__RemoveEventFilterResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__RemoveEventFilterResponse[n]; + if (size) + *size = n * sizeof(_emi__RemoveEventFilterResponse); + for (int i = 0; i < n; i++) + ((_emi__RemoveEventFilterResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__RemoveEventFilterResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__RemoveEventFilterResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__RemoveEventFilterResponse %p -> %p\n", q, p)); + *(_emi__RemoveEventFilterResponse*)p = *(_emi__RemoveEventFilterResponse*)q; +} + +void _emi__RemoveEventFilter::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__RemoveEventFilter::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__EventFilterHandleType(soap, &((_emi__RemoveEventFilter*)this)->EventFilterHandle); + /* transient soap skipped */ +} + +int _emi__RemoveEventFilter::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__RemoveEventFilter); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__RemoveEventFilter::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__RemoveEventFilter(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__RemoveEventFilter(struct soap *soap, const char *tag, int id, const _emi__RemoveEventFilter *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__RemoveEventFilter), type); + soap_out_emi__EventFilterHandleType(soap, "emi:EventFilterHandle", -1, &(((_emi__RemoveEventFilter*)a)->EventFilterHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__RemoveEventFilter::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__RemoveEventFilter(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__RemoveEventFilter * SOAP_FMAC4 soap_get__emi__RemoveEventFilter(struct soap *soap, _emi__RemoveEventFilter *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__RemoveEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__RemoveEventFilter::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__RemoveEventFilter(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__RemoveEventFilter * SOAP_FMAC4 soap_in__emi__RemoveEventFilter(struct soap *soap, const char *tag, _emi__RemoveEventFilter *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__RemoveEventFilter *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__RemoveEventFilter, sizeof(_emi__RemoveEventFilter), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__RemoveEventFilter) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__RemoveEventFilter *)a->soap_in(soap, tag, type); + } + } + short soap_flag_EventFilterHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_EventFilterHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__EventFilterHandleType(soap, "emi:EventFilterHandle", &(((_emi__RemoveEventFilter*)a)->EventFilterHandle), "emi:EventFilterHandleType")) + { soap_flag_EventFilterHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_EventFilterHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__RemoveEventFilter *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__RemoveEventFilter, 0, sizeof(_emi__RemoveEventFilter), 0, soap_copy__emi__RemoveEventFilter); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__RemoveEventFilter * SOAP_FMAC6 soap_new__emi__RemoveEventFilter(struct soap *soap, int n) +{ return soap_instantiate__emi__RemoveEventFilter(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__RemoveEventFilter(struct soap *soap, _emi__RemoveEventFilter *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__RemoveEventFilter * SOAP_FMAC4 soap_instantiate__emi__RemoveEventFilter(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__RemoveEventFilter(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__RemoveEventFilter, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__RemoveEventFilter; + if (size) + *size = sizeof(_emi__RemoveEventFilter); + ((_emi__RemoveEventFilter*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__RemoveEventFilter[n]; + if (size) + *size = n * sizeof(_emi__RemoveEventFilter); + for (int i = 0; i < n; i++) + ((_emi__RemoveEventFilter*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__RemoveEventFilter*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__RemoveEventFilter(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__RemoveEventFilter %p -> %p\n", q, p)); + *(_emi__RemoveEventFilter*)p = *(_emi__RemoveEventFilter*)q; +} + +void _emi__UpdateEventFilterResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__UpdateEventFilterResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__UpdateEventFilterResponse*)this)->Status); + /* transient soap skipped */ +} + +int _emi__UpdateEventFilterResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__UpdateEventFilterResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__UpdateEventFilterResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__UpdateEventFilterResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__UpdateEventFilterResponse(struct soap *soap, const char *tag, int id, const _emi__UpdateEventFilterResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__UpdateEventFilterResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__UpdateEventFilterResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__UpdateEventFilterResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__UpdateEventFilterResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__UpdateEventFilterResponse * SOAP_FMAC4 soap_get__emi__UpdateEventFilterResponse(struct soap *soap, _emi__UpdateEventFilterResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__UpdateEventFilterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__UpdateEventFilterResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__UpdateEventFilterResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__UpdateEventFilterResponse * SOAP_FMAC4 soap_in__emi__UpdateEventFilterResponse(struct soap *soap, const char *tag, _emi__UpdateEventFilterResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__UpdateEventFilterResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__UpdateEventFilterResponse, sizeof(_emi__UpdateEventFilterResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__UpdateEventFilterResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__UpdateEventFilterResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__UpdateEventFilterResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__UpdateEventFilterResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__UpdateEventFilterResponse, 0, sizeof(_emi__UpdateEventFilterResponse), 0, soap_copy__emi__UpdateEventFilterResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__UpdateEventFilterResponse * SOAP_FMAC6 soap_new__emi__UpdateEventFilterResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__UpdateEventFilterResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__UpdateEventFilterResponse(struct soap *soap, _emi__UpdateEventFilterResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__UpdateEventFilterResponse * SOAP_FMAC4 soap_instantiate__emi__UpdateEventFilterResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__UpdateEventFilterResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__UpdateEventFilterResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__UpdateEventFilterResponse; + if (size) + *size = sizeof(_emi__UpdateEventFilterResponse); + ((_emi__UpdateEventFilterResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__UpdateEventFilterResponse[n]; + if (size) + *size = n * sizeof(_emi__UpdateEventFilterResponse); + for (int i = 0; i < n; i++) + ((_emi__UpdateEventFilterResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__UpdateEventFilterResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__UpdateEventFilterResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__UpdateEventFilterResponse %p -> %p\n", q, p)); + *(_emi__UpdateEventFilterResponse*)p = *(_emi__UpdateEventFilterResponse*)q; +} + +void _emi__UpdateEventFilter::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToemi__EventFilterType(soap, &((_emi__UpdateEventFilter*)this)->EventFilter); + /* transient soap skipped */ +} + +void _emi__UpdateEventFilter::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__EventFilterHandleType(soap, &((_emi__UpdateEventFilter*)this)->EventFilterHandle); + ((_emi__UpdateEventFilter*)this)->EventFilter = NULL; + /* transient soap skipped */ +} + +int _emi__UpdateEventFilter::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__UpdateEventFilter); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__UpdateEventFilter::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__UpdateEventFilter(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__UpdateEventFilter(struct soap *soap, const char *tag, int id, const _emi__UpdateEventFilter *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__UpdateEventFilter), type); + soap_out_emi__EventFilterHandleType(soap, "emi:EventFilterHandle", -1, &(((_emi__UpdateEventFilter*)a)->EventFilterHandle), ""); + soap_out_PointerToemi__EventFilterType(soap, "emi:EventFilter", -1, &(((_emi__UpdateEventFilter*)a)->EventFilter), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__UpdateEventFilter::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__UpdateEventFilter(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__UpdateEventFilter * SOAP_FMAC4 soap_get__emi__UpdateEventFilter(struct soap *soap, _emi__UpdateEventFilter *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__UpdateEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__UpdateEventFilter::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__UpdateEventFilter(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__UpdateEventFilter * SOAP_FMAC4 soap_in__emi__UpdateEventFilter(struct soap *soap, const char *tag, _emi__UpdateEventFilter *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__UpdateEventFilter *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__UpdateEventFilter, sizeof(_emi__UpdateEventFilter), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__UpdateEventFilter) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__UpdateEventFilter *)a->soap_in(soap, tag, type); + } + } + short soap_flag_EventFilterHandle1 = 1, soap_flag_EventFilter1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_EventFilterHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__EventFilterHandleType(soap, "emi:EventFilterHandle", &(((_emi__UpdateEventFilter*)a)->EventFilterHandle), "emi:EventFilterHandleType")) + { soap_flag_EventFilterHandle1--; + continue; + } + if (soap_flag_EventFilter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__EventFilterType(soap, "emi:EventFilter", &(((_emi__UpdateEventFilter*)a)->EventFilter), "emi:EventFilterType")) + { soap_flag_EventFilter1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_EventFilterHandle1 > 0 || soap_flag_EventFilter1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__UpdateEventFilter *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__UpdateEventFilter, 0, sizeof(_emi__UpdateEventFilter), 0, soap_copy__emi__UpdateEventFilter); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__UpdateEventFilter * SOAP_FMAC6 soap_new__emi__UpdateEventFilter(struct soap *soap, int n) +{ return soap_instantiate__emi__UpdateEventFilter(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__UpdateEventFilter(struct soap *soap, _emi__UpdateEventFilter *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__UpdateEventFilter * SOAP_FMAC4 soap_instantiate__emi__UpdateEventFilter(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__UpdateEventFilter(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__UpdateEventFilter, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__UpdateEventFilter; + if (size) + *size = sizeof(_emi__UpdateEventFilter); + ((_emi__UpdateEventFilter*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__UpdateEventFilter[n]; + if (size) + *size = n * sizeof(_emi__UpdateEventFilter); + for (int i = 0; i < n; i++) + ((_emi__UpdateEventFilter*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__UpdateEventFilter*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__UpdateEventFilter(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__UpdateEventFilter %p -> %p\n", q, p)); + *(_emi__UpdateEventFilter*)p = *(_emi__UpdateEventFilter*)q; +} + +void _emi__GetEventFilterResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToemi__EventFilterType(soap, &((_emi__GetEventFilterResponse*)this)->EventFilter); + /* transient soap skipped */ +} + +void _emi__GetEventFilterResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__GetEventFilterResponse*)this)->Status); + ((_emi__GetEventFilterResponse*)this)->EventFilter = NULL; + /* transient soap skipped */ +} + +int _emi__GetEventFilterResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetEventFilterResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetEventFilterResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetEventFilterResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventFilterResponse(struct soap *soap, const char *tag, int id, const _emi__GetEventFilterResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetEventFilterResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__GetEventFilterResponse*)a)->Status), ""); + soap_out_PointerToemi__EventFilterType(soap, "emi:EventFilter", -1, &(((_emi__GetEventFilterResponse*)a)->EventFilter), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetEventFilterResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetEventFilterResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetEventFilterResponse * SOAP_FMAC4 soap_get__emi__GetEventFilterResponse(struct soap *soap, _emi__GetEventFilterResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetEventFilterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetEventFilterResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetEventFilterResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetEventFilterResponse * SOAP_FMAC4 soap_in__emi__GetEventFilterResponse(struct soap *soap, const char *tag, _emi__GetEventFilterResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetEventFilterResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetEventFilterResponse, sizeof(_emi__GetEventFilterResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetEventFilterResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetEventFilterResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_EventFilter1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__GetEventFilterResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_EventFilter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__EventFilterType(soap, "emi:EventFilter", &(((_emi__GetEventFilterResponse*)a)->EventFilter), "emi:EventFilterType")) + { soap_flag_EventFilter1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_EventFilter1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetEventFilterResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetEventFilterResponse, 0, sizeof(_emi__GetEventFilterResponse), 0, soap_copy__emi__GetEventFilterResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetEventFilterResponse * SOAP_FMAC6 soap_new__emi__GetEventFilterResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__GetEventFilterResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventFilterResponse(struct soap *soap, _emi__GetEventFilterResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetEventFilterResponse * SOAP_FMAC4 soap_instantiate__emi__GetEventFilterResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetEventFilterResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetEventFilterResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetEventFilterResponse; + if (size) + *size = sizeof(_emi__GetEventFilterResponse); + ((_emi__GetEventFilterResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetEventFilterResponse[n]; + if (size) + *size = n * sizeof(_emi__GetEventFilterResponse); + for (int i = 0; i < n; i++) + ((_emi__GetEventFilterResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetEventFilterResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventFilterResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetEventFilterResponse %p -> %p\n", q, p)); + *(_emi__GetEventFilterResponse*)p = *(_emi__GetEventFilterResponse*)q; +} + +void _emi__GetEventFilter::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__GetEventFilter::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__EventFilterHandleType(soap, &((_emi__GetEventFilter*)this)->EventFilterHandle); + /* transient soap skipped */ +} + +int _emi__GetEventFilter::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetEventFilter); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetEventFilter::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetEventFilter(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetEventFilter(struct soap *soap, const char *tag, int id, const _emi__GetEventFilter *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetEventFilter), type); + soap_out_emi__EventFilterHandleType(soap, "emi:EventFilterHandle", -1, &(((_emi__GetEventFilter*)a)->EventFilterHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetEventFilter::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetEventFilter(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetEventFilter * SOAP_FMAC4 soap_get__emi__GetEventFilter(struct soap *soap, _emi__GetEventFilter *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetEventFilter::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetEventFilter(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetEventFilter * SOAP_FMAC4 soap_in__emi__GetEventFilter(struct soap *soap, const char *tag, _emi__GetEventFilter *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetEventFilter *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetEventFilter, sizeof(_emi__GetEventFilter), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetEventFilter) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetEventFilter *)a->soap_in(soap, tag, type); + } + } + short soap_flag_EventFilterHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_EventFilterHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__EventFilterHandleType(soap, "emi:EventFilterHandle", &(((_emi__GetEventFilter*)a)->EventFilterHandle), "emi:EventFilterHandleType")) + { soap_flag_EventFilterHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_EventFilterHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetEventFilter *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetEventFilter, 0, sizeof(_emi__GetEventFilter), 0, soap_copy__emi__GetEventFilter); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetEventFilter * SOAP_FMAC6 soap_new__emi__GetEventFilter(struct soap *soap, int n) +{ return soap_instantiate__emi__GetEventFilter(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetEventFilter(struct soap *soap, _emi__GetEventFilter *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetEventFilter * SOAP_FMAC4 soap_instantiate__emi__GetEventFilter(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetEventFilter(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetEventFilter, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetEventFilter; + if (size) + *size = sizeof(_emi__GetEventFilter); + ((_emi__GetEventFilter*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetEventFilter[n]; + if (size) + *size = n * sizeof(_emi__GetEventFilter); + for (int i = 0; i < n; i++) + ((_emi__GetEventFilter*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetEventFilter*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetEventFilter(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetEventFilter %p -> %p\n", q, p)); + *(_emi__GetEventFilter*)p = *(_emi__GetEventFilter*)q; +} + +void _emi__EnumerateEventFiltersResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__EnumerateEventFiltersResponse*)this)->TotalEventFilterCount, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_emi__EnumerateEventFiltersResponse*)this)->FiltersReturned, SOAP_TYPE_unsignedInt); + soap_serialize_PointerToemi__EventFilterHandleArrayType(soap, &((_emi__EnumerateEventFiltersResponse*)this)->Filters); + /* transient soap skipped */ +} + +void _emi__EnumerateEventFiltersResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__EnumerateEventFiltersResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_emi__EnumerateEventFiltersResponse*)this)->TotalEventFilterCount); + soap_default_unsignedInt(soap, &((_emi__EnumerateEventFiltersResponse*)this)->FiltersReturned); + ((_emi__EnumerateEventFiltersResponse*)this)->Filters = NULL; + /* transient soap skipped */ +} + +int _emi__EnumerateEventFiltersResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateEventFiltersResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateEventFiltersResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateEventFiltersResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateEventFiltersResponse(struct soap *soap, const char *tag, int id, const _emi__EnumerateEventFiltersResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateEventFiltersResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__EnumerateEventFiltersResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "emi:TotalEventFilterCount", -1, &(((_emi__EnumerateEventFiltersResponse*)a)->TotalEventFilterCount), ""); + soap_out_unsignedInt(soap, "emi:FiltersReturned", -1, &(((_emi__EnumerateEventFiltersResponse*)a)->FiltersReturned), ""); + soap_out_PointerToemi__EventFilterHandleArrayType(soap, "emi:Filters", -1, &(((_emi__EnumerateEventFiltersResponse*)a)->Filters), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateEventFiltersResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateEventFiltersResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse * SOAP_FMAC4 soap_get__emi__EnumerateEventFiltersResponse(struct soap *soap, _emi__EnumerateEventFiltersResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateEventFiltersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateEventFiltersResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateEventFiltersResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse * SOAP_FMAC4 soap_in__emi__EnumerateEventFiltersResponse(struct soap *soap, const char *tag, _emi__EnumerateEventFiltersResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateEventFiltersResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateEventFiltersResponse, sizeof(_emi__EnumerateEventFiltersResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateEventFiltersResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateEventFiltersResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_TotalEventFilterCount1 = 1, soap_flag_FiltersReturned1 = 1, soap_flag_Filters1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__EnumerateEventFiltersResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_TotalEventFilterCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:TotalEventFilterCount", &(((_emi__EnumerateEventFiltersResponse*)a)->TotalEventFilterCount), "xsd:unsignedInt")) + { soap_flag_TotalEventFilterCount1--; + continue; + } + if (soap_flag_FiltersReturned1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:FiltersReturned", &(((_emi__EnumerateEventFiltersResponse*)a)->FiltersReturned), "xsd:unsignedInt")) + { soap_flag_FiltersReturned1--; + continue; + } + if (soap_flag_Filters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__EventFilterHandleArrayType(soap, "emi:Filters", &(((_emi__EnumerateEventFiltersResponse*)a)->Filters), "emi:EventFilterHandleArrayType")) + { soap_flag_Filters1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_TotalEventFilterCount1 > 0 || soap_flag_FiltersReturned1 > 0 || soap_flag_Filters1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateEventFiltersResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateEventFiltersResponse, 0, sizeof(_emi__EnumerateEventFiltersResponse), 0, soap_copy__emi__EnumerateEventFiltersResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateEventFiltersResponse * SOAP_FMAC6 soap_new__emi__EnumerateEventFiltersResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateEventFiltersResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateEventFiltersResponse(struct soap *soap, _emi__EnumerateEventFiltersResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateEventFiltersResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateEventFiltersResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateEventFiltersResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateEventFiltersResponse; + if (size) + *size = sizeof(_emi__EnumerateEventFiltersResponse); + ((_emi__EnumerateEventFiltersResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateEventFiltersResponse[n]; + if (size) + *size = n * sizeof(_emi__EnumerateEventFiltersResponse); + for (int i = 0; i < n; i++) + ((_emi__EnumerateEventFiltersResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateEventFiltersResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateEventFiltersResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateEventFiltersResponse %p -> %p\n", q, p)); + *(_emi__EnumerateEventFiltersResponse*)p = *(_emi__EnumerateEventFiltersResponse*)q; +} + +void _emi__EnumerateEventFilters::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__EnumerateEventFilters*)this)->StartIndex, SOAP_TYPE_unsignedInt); + soap_serialize_PointerToemi__AlertSubscriptionPolicyIDType(soap, &((_emi__EnumerateEventFilters*)this)->AlertSubscriptionPolicyID); + /* transient soap skipped */ +} + +void _emi__EnumerateEventFilters::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_emi__EnumerateEventFilters*)this)->StartIndex); + ((_emi__EnumerateEventFilters*)this)->AlertSubscriptionPolicyID = NULL; + /* transient soap skipped */ +} + +int _emi__EnumerateEventFilters::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateEventFilters); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateEventFilters::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateEventFilters(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateEventFilters(struct soap *soap, const char *tag, int id, const _emi__EnumerateEventFilters *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateEventFilters), type); + soap_out_unsignedInt(soap, "emi:StartIndex", -1, &(((_emi__EnumerateEventFilters*)a)->StartIndex), ""); + soap_out_PointerToemi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", -1, &(((_emi__EnumerateEventFilters*)a)->AlertSubscriptionPolicyID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateEventFilters::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateEventFilters(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateEventFilters * SOAP_FMAC4 soap_get__emi__EnumerateEventFilters(struct soap *soap, _emi__EnumerateEventFilters *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateEventFilters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateEventFilters::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateEventFilters(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateEventFilters * SOAP_FMAC4 soap_in__emi__EnumerateEventFilters(struct soap *soap, const char *tag, _emi__EnumerateEventFilters *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateEventFilters *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateEventFilters, sizeof(_emi__EnumerateEventFilters), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateEventFilters) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateEventFilters *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StartIndex1 = 1, soap_flag_AlertSubscriptionPolicyID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StartIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:StartIndex", &(((_emi__EnumerateEventFilters*)a)->StartIndex), "xsd:unsignedInt")) + { soap_flag_StartIndex1--; + continue; + } + if (soap_flag_AlertSubscriptionPolicyID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", &(((_emi__EnumerateEventFilters*)a)->AlertSubscriptionPolicyID), "emi:AlertSubscriptionPolicyIDType")) + { soap_flag_AlertSubscriptionPolicyID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StartIndex1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateEventFilters *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateEventFilters, 0, sizeof(_emi__EnumerateEventFilters), 0, soap_copy__emi__EnumerateEventFilters); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateEventFilters * SOAP_FMAC6 soap_new__emi__EnumerateEventFilters(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateEventFilters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateEventFilters(struct soap *soap, _emi__EnumerateEventFilters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateEventFilters * SOAP_FMAC4 soap_instantiate__emi__EnumerateEventFilters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateEventFilters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateEventFilters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateEventFilters; + if (size) + *size = sizeof(_emi__EnumerateEventFilters); + ((_emi__EnumerateEventFilters*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateEventFilters[n]; + if (size) + *size = n * sizeof(_emi__EnumerateEventFilters); + for (int i = 0; i < n; i++) + ((_emi__EnumerateEventFilters*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateEventFilters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateEventFilters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateEventFilters %p -> %p\n", q, p)); + *(_emi__EnumerateEventFilters*)p = *(_emi__EnumerateEventFilters*)q; +} + +void _emi__AddEventFilterResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__AddEventFilterResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__AddEventFilterResponse*)this)->Status); + soap_default_emi__EventFilterHandleType(soap, &((_emi__AddEventFilterResponse*)this)->EventFilterHandle); + /* transient soap skipped */ +} + +int _emi__AddEventFilterResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__AddEventFilterResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__AddEventFilterResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__AddEventFilterResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__AddEventFilterResponse(struct soap *soap, const char *tag, int id, const _emi__AddEventFilterResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__AddEventFilterResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__AddEventFilterResponse*)a)->Status), ""); + soap_out_emi__EventFilterHandleType(soap, "emi:EventFilterHandle", -1, &(((_emi__AddEventFilterResponse*)a)->EventFilterHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__AddEventFilterResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__AddEventFilterResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__AddEventFilterResponse * SOAP_FMAC4 soap_get__emi__AddEventFilterResponse(struct soap *soap, _emi__AddEventFilterResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__AddEventFilterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__AddEventFilterResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__AddEventFilterResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__AddEventFilterResponse * SOAP_FMAC4 soap_in__emi__AddEventFilterResponse(struct soap *soap, const char *tag, _emi__AddEventFilterResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__AddEventFilterResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__AddEventFilterResponse, sizeof(_emi__AddEventFilterResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__AddEventFilterResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__AddEventFilterResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_EventFilterHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__AddEventFilterResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_EventFilterHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__EventFilterHandleType(soap, "emi:EventFilterHandle", &(((_emi__AddEventFilterResponse*)a)->EventFilterHandle), "emi:EventFilterHandleType")) + { soap_flag_EventFilterHandle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_EventFilterHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__AddEventFilterResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__AddEventFilterResponse, 0, sizeof(_emi__AddEventFilterResponse), 0, soap_copy__emi__AddEventFilterResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__AddEventFilterResponse * SOAP_FMAC6 soap_new__emi__AddEventFilterResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__AddEventFilterResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__AddEventFilterResponse(struct soap *soap, _emi__AddEventFilterResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__AddEventFilterResponse * SOAP_FMAC4 soap_instantiate__emi__AddEventFilterResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__AddEventFilterResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__AddEventFilterResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__AddEventFilterResponse; + if (size) + *size = sizeof(_emi__AddEventFilterResponse); + ((_emi__AddEventFilterResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__AddEventFilterResponse[n]; + if (size) + *size = n * sizeof(_emi__AddEventFilterResponse); + for (int i = 0; i < n; i++) + ((_emi__AddEventFilterResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__AddEventFilterResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__AddEventFilterResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__AddEventFilterResponse %p -> %p\n", q, p)); + *(_emi__AddEventFilterResponse*)p = *(_emi__AddEventFilterResponse*)q; +} + +void _emi__AddEventFilter::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToemi__EventFilterType(soap, &((_emi__AddEventFilter*)this)->EventFilter); + /* transient soap skipped */ +} + +void _emi__AddEventFilter::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_emi__AddEventFilter*)this)->EventFilter = NULL; + /* transient soap skipped */ +} + +int _emi__AddEventFilter::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__AddEventFilter); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__AddEventFilter::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__AddEventFilter(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__AddEventFilter(struct soap *soap, const char *tag, int id, const _emi__AddEventFilter *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__AddEventFilter), type); + soap_out_PointerToemi__EventFilterType(soap, "emi:EventFilter", -1, &(((_emi__AddEventFilter*)a)->EventFilter), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__AddEventFilter::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__AddEventFilter(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__AddEventFilter * SOAP_FMAC4 soap_get__emi__AddEventFilter(struct soap *soap, _emi__AddEventFilter *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__AddEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__AddEventFilter::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__AddEventFilter(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__AddEventFilter * SOAP_FMAC4 soap_in__emi__AddEventFilter(struct soap *soap, const char *tag, _emi__AddEventFilter *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__AddEventFilter *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__AddEventFilter, sizeof(_emi__AddEventFilter), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__AddEventFilter) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__AddEventFilter *)a->soap_in(soap, tag, type); + } + } + short soap_flag_EventFilter1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_EventFilter1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__EventFilterType(soap, "emi:EventFilter", &(((_emi__AddEventFilter*)a)->EventFilter), "emi:EventFilterType")) + { soap_flag_EventFilter1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_EventFilter1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__AddEventFilter *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__AddEventFilter, 0, sizeof(_emi__AddEventFilter), 0, soap_copy__emi__AddEventFilter); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__AddEventFilter * SOAP_FMAC6 soap_new__emi__AddEventFilter(struct soap *soap, int n) +{ return soap_instantiate__emi__AddEventFilter(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__AddEventFilter(struct soap *soap, _emi__AddEventFilter *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__AddEventFilter * SOAP_FMAC4 soap_instantiate__emi__AddEventFilter(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__AddEventFilter(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__AddEventFilter, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__AddEventFilter; + if (size) + *size = sizeof(_emi__AddEventFilter); + ((_emi__AddEventFilter*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__AddEventFilter[n]; + if (size) + *size = n * sizeof(_emi__AddEventFilter); + for (int i = 0; i < n; i++) + ((_emi__AddEventFilter*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__AddEventFilter*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__AddEventFilter(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__AddEventFilter %p -> %p\n", q, p)); + *(_emi__AddEventFilter*)p = *(_emi__AddEventFilter*)q; +} + +void _emi__GetAlertCommunityStringResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__GetAlertCommunityStringResponse*)this)->Length, SOAP_TYPE_unsignedByte); + soap_serialize_PointerToemi__ByteStr(soap, &((_emi__GetAlertCommunityStringResponse*)this)->CommunityString); + /* transient soap skipped */ +} + +void _emi__GetAlertCommunityStringResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__GetAlertCommunityStringResponse*)this)->Status); + soap_default_unsignedByte(soap, &((_emi__GetAlertCommunityStringResponse*)this)->Length); + ((_emi__GetAlertCommunityStringResponse*)this)->CommunityString = NULL; + /* transient soap skipped */ +} + +int _emi__GetAlertCommunityStringResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetAlertCommunityStringResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetAlertCommunityStringResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetAlertCommunityStringResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetAlertCommunityStringResponse(struct soap *soap, const char *tag, int id, const _emi__GetAlertCommunityStringResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetAlertCommunityStringResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__GetAlertCommunityStringResponse*)a)->Status), ""); + soap_out_unsignedByte(soap, "emi:Length", -1, &(((_emi__GetAlertCommunityStringResponse*)a)->Length), ""); + soap_out_PointerToemi__ByteStr(soap, "emi:CommunityString", -1, &(((_emi__GetAlertCommunityStringResponse*)a)->CommunityString), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetAlertCommunityStringResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetAlertCommunityStringResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse * SOAP_FMAC4 soap_get__emi__GetAlertCommunityStringResponse(struct soap *soap, _emi__GetAlertCommunityStringResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetAlertCommunityStringResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetAlertCommunityStringResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetAlertCommunityStringResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse * SOAP_FMAC4 soap_in__emi__GetAlertCommunityStringResponse(struct soap *soap, const char *tag, _emi__GetAlertCommunityStringResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetAlertCommunityStringResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetAlertCommunityStringResponse, sizeof(_emi__GetAlertCommunityStringResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetAlertCommunityStringResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetAlertCommunityStringResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_Length1 = 1, soap_flag_CommunityString1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__GetAlertCommunityStringResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_Length1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:Length", &(((_emi__GetAlertCommunityStringResponse*)a)->Length), "xsd:unsignedByte")) + { soap_flag_Length1--; + continue; + } + if (soap_flag_CommunityString1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__ByteStr(soap, "emi:CommunityString", &(((_emi__GetAlertCommunityStringResponse*)a)->CommunityString), "emi:ByteStr")) + { soap_flag_CommunityString1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_Length1 > 0 || soap_flag_CommunityString1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetAlertCommunityStringResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetAlertCommunityStringResponse, 0, sizeof(_emi__GetAlertCommunityStringResponse), 0, soap_copy__emi__GetAlertCommunityStringResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetAlertCommunityStringResponse * SOAP_FMAC6 soap_new__emi__GetAlertCommunityStringResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__GetAlertCommunityStringResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetAlertCommunityStringResponse(struct soap *soap, _emi__GetAlertCommunityStringResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse * SOAP_FMAC4 soap_instantiate__emi__GetAlertCommunityStringResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetAlertCommunityStringResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetAlertCommunityStringResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetAlertCommunityStringResponse; + if (size) + *size = sizeof(_emi__GetAlertCommunityStringResponse); + ((_emi__GetAlertCommunityStringResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetAlertCommunityStringResponse[n]; + if (size) + *size = n * sizeof(_emi__GetAlertCommunityStringResponse); + for (int i = 0; i < n; i++) + ((_emi__GetAlertCommunityStringResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetAlertCommunityStringResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetAlertCommunityStringResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetAlertCommunityStringResponse %p -> %p\n", q, p)); + *(_emi__GetAlertCommunityStringResponse*)p = *(_emi__GetAlertCommunityStringResponse*)q; +} + +void _emi__GetAlertCommunityString::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__GetAlertCommunityString::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _emi__GetAlertCommunityString::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetAlertCommunityString); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetAlertCommunityString::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetAlertCommunityString(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetAlertCommunityString(struct soap *soap, const char *tag, int id, const _emi__GetAlertCommunityString *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetAlertCommunityString), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetAlertCommunityString::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetAlertCommunityString(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetAlertCommunityString * SOAP_FMAC4 soap_get__emi__GetAlertCommunityString(struct soap *soap, _emi__GetAlertCommunityString *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetAlertCommunityString(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetAlertCommunityString::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetAlertCommunityString(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetAlertCommunityString * SOAP_FMAC4 soap_in__emi__GetAlertCommunityString(struct soap *soap, const char *tag, _emi__GetAlertCommunityString *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetAlertCommunityString *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetAlertCommunityString, sizeof(_emi__GetAlertCommunityString), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetAlertCommunityString) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetAlertCommunityString *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetAlertCommunityString *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetAlertCommunityString, 0, sizeof(_emi__GetAlertCommunityString), 0, soap_copy__emi__GetAlertCommunityString); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetAlertCommunityString * SOAP_FMAC6 soap_new__emi__GetAlertCommunityString(struct soap *soap, int n) +{ return soap_instantiate__emi__GetAlertCommunityString(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetAlertCommunityString(struct soap *soap, _emi__GetAlertCommunityString *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetAlertCommunityString * SOAP_FMAC4 soap_instantiate__emi__GetAlertCommunityString(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetAlertCommunityString(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetAlertCommunityString, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetAlertCommunityString; + if (size) + *size = sizeof(_emi__GetAlertCommunityString); + ((_emi__GetAlertCommunityString*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetAlertCommunityString[n]; + if (size) + *size = n * sizeof(_emi__GetAlertCommunityString); + for (int i = 0; i < n; i++) + ((_emi__GetAlertCommunityString*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetAlertCommunityString*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetAlertCommunityString(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetAlertCommunityString %p -> %p\n", q, p)); + *(_emi__GetAlertCommunityString*)p = *(_emi__GetAlertCommunityString*)q; +} + +void _emi__SetAlertCommunityStringResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__SetAlertCommunityStringResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__SetAlertCommunityStringResponse*)this)->Status); + /* transient soap skipped */ +} + +int _emi__SetAlertCommunityStringResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__SetAlertCommunityStringResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__SetAlertCommunityStringResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__SetAlertCommunityStringResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SetAlertCommunityStringResponse(struct soap *soap, const char *tag, int id, const _emi__SetAlertCommunityStringResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__SetAlertCommunityStringResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__SetAlertCommunityStringResponse*)a)->Status), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__SetAlertCommunityStringResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__SetAlertCommunityStringResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse * SOAP_FMAC4 soap_get__emi__SetAlertCommunityStringResponse(struct soap *soap, _emi__SetAlertCommunityStringResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__SetAlertCommunityStringResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__SetAlertCommunityStringResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__SetAlertCommunityStringResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse * SOAP_FMAC4 soap_in__emi__SetAlertCommunityStringResponse(struct soap *soap, const char *tag, _emi__SetAlertCommunityStringResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__SetAlertCommunityStringResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__SetAlertCommunityStringResponse, sizeof(_emi__SetAlertCommunityStringResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__SetAlertCommunityStringResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__SetAlertCommunityStringResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__SetAlertCommunityStringResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__SetAlertCommunityStringResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__SetAlertCommunityStringResponse, 0, sizeof(_emi__SetAlertCommunityStringResponse), 0, soap_copy__emi__SetAlertCommunityStringResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__SetAlertCommunityStringResponse * SOAP_FMAC6 soap_new__emi__SetAlertCommunityStringResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__SetAlertCommunityStringResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SetAlertCommunityStringResponse(struct soap *soap, _emi__SetAlertCommunityStringResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse * SOAP_FMAC4 soap_instantiate__emi__SetAlertCommunityStringResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__SetAlertCommunityStringResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__SetAlertCommunityStringResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__SetAlertCommunityStringResponse; + if (size) + *size = sizeof(_emi__SetAlertCommunityStringResponse); + ((_emi__SetAlertCommunityStringResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__SetAlertCommunityStringResponse[n]; + if (size) + *size = n * sizeof(_emi__SetAlertCommunityStringResponse); + for (int i = 0; i < n; i++) + ((_emi__SetAlertCommunityStringResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__SetAlertCommunityStringResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SetAlertCommunityStringResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__SetAlertCommunityStringResponse %p -> %p\n", q, p)); + *(_emi__SetAlertCommunityStringResponse*)p = *(_emi__SetAlertCommunityStringResponse*)q; +} + +void _emi__SetAlertCommunityString::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__SetAlertCommunityString*)this)->Length, SOAP_TYPE_unsignedByte); + soap_serialize_PointerToemi__ByteStr(soap, &((_emi__SetAlertCommunityString*)this)->CommunityString); + /* transient soap skipped */ +} + +void _emi__SetAlertCommunityString::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedByte(soap, &((_emi__SetAlertCommunityString*)this)->Length); + ((_emi__SetAlertCommunityString*)this)->CommunityString = NULL; + /* transient soap skipped */ +} + +int _emi__SetAlertCommunityString::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__SetAlertCommunityString); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__SetAlertCommunityString::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__SetAlertCommunityString(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SetAlertCommunityString(struct soap *soap, const char *tag, int id, const _emi__SetAlertCommunityString *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__SetAlertCommunityString), type); + soap_out_unsignedByte(soap, "emi:Length", -1, &(((_emi__SetAlertCommunityString*)a)->Length), ""); + soap_out_PointerToemi__ByteStr(soap, "emi:CommunityString", -1, &(((_emi__SetAlertCommunityString*)a)->CommunityString), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__SetAlertCommunityString::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__SetAlertCommunityString(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__SetAlertCommunityString * SOAP_FMAC4 soap_get__emi__SetAlertCommunityString(struct soap *soap, _emi__SetAlertCommunityString *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__SetAlertCommunityString(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__SetAlertCommunityString::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__SetAlertCommunityString(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__SetAlertCommunityString * SOAP_FMAC4 soap_in__emi__SetAlertCommunityString(struct soap *soap, const char *tag, _emi__SetAlertCommunityString *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__SetAlertCommunityString *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__SetAlertCommunityString, sizeof(_emi__SetAlertCommunityString), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__SetAlertCommunityString) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__SetAlertCommunityString *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Length1 = 1, soap_flag_CommunityString1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Length1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:Length", &(((_emi__SetAlertCommunityString*)a)->Length), "xsd:unsignedByte")) + { soap_flag_Length1--; + continue; + } + if (soap_flag_CommunityString1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__ByteStr(soap, "emi:CommunityString", &(((_emi__SetAlertCommunityString*)a)->CommunityString), "emi:ByteStr")) + { soap_flag_CommunityString1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Length1 > 0 || soap_flag_CommunityString1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__SetAlertCommunityString *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__SetAlertCommunityString, 0, sizeof(_emi__SetAlertCommunityString), 0, soap_copy__emi__SetAlertCommunityString); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__SetAlertCommunityString * SOAP_FMAC6 soap_new__emi__SetAlertCommunityString(struct soap *soap, int n) +{ return soap_instantiate__emi__SetAlertCommunityString(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SetAlertCommunityString(struct soap *soap, _emi__SetAlertCommunityString *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__SetAlertCommunityString * SOAP_FMAC4 soap_instantiate__emi__SetAlertCommunityString(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__SetAlertCommunityString(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__SetAlertCommunityString, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__SetAlertCommunityString; + if (size) + *size = sizeof(_emi__SetAlertCommunityString); + ((_emi__SetAlertCommunityString*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__SetAlertCommunityString[n]; + if (size) + *size = n * sizeof(_emi__SetAlertCommunityString); + for (int i = 0; i < n; i++) + ((_emi__SetAlertCommunityString*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__SetAlertCommunityString*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SetAlertCommunityString(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__SetAlertCommunityString %p -> %p\n", q, p)); + *(_emi__SetAlertCommunityString*)p = *(_emi__SetAlertCommunityString*)q; +} + +void _emi__EnumerateAlertPoliciesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__EnumerateAlertPoliciesResponse*)this)->TotalPolicyCount, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_emi__EnumerateAlertPoliciesResponse*)this)->PoliciesReturned, SOAP_TYPE_unsignedInt); + soap_serialize_PointerToemi__AlertSubscriptionPolicyIDArrayType(soap, &((_emi__EnumerateAlertPoliciesResponse*)this)->PolicyHandles); + /* transient soap skipped */ +} + +void _emi__EnumerateAlertPoliciesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__EnumerateAlertPoliciesResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_emi__EnumerateAlertPoliciesResponse*)this)->TotalPolicyCount); + soap_default_unsignedInt(soap, &((_emi__EnumerateAlertPoliciesResponse*)this)->PoliciesReturned); + ((_emi__EnumerateAlertPoliciesResponse*)this)->PolicyHandles = NULL; + /* transient soap skipped */ +} + +int _emi__EnumerateAlertPoliciesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateAlertPoliciesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateAlertPoliciesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateAlertPoliciesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateAlertPoliciesResponse(struct soap *soap, const char *tag, int id, const _emi__EnumerateAlertPoliciesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateAlertPoliciesResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__EnumerateAlertPoliciesResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "emi:TotalPolicyCount", -1, &(((_emi__EnumerateAlertPoliciesResponse*)a)->TotalPolicyCount), ""); + soap_out_unsignedInt(soap, "emi:PoliciesReturned", -1, &(((_emi__EnumerateAlertPoliciesResponse*)a)->PoliciesReturned), ""); + soap_out_PointerToemi__AlertSubscriptionPolicyIDArrayType(soap, "emi:PolicyHandles", -1, &(((_emi__EnumerateAlertPoliciesResponse*)a)->PolicyHandles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateAlertPoliciesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateAlertPoliciesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse * SOAP_FMAC4 soap_get__emi__EnumerateAlertPoliciesResponse(struct soap *soap, _emi__EnumerateAlertPoliciesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateAlertPoliciesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateAlertPoliciesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateAlertPoliciesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse * SOAP_FMAC4 soap_in__emi__EnumerateAlertPoliciesResponse(struct soap *soap, const char *tag, _emi__EnumerateAlertPoliciesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateAlertPoliciesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateAlertPoliciesResponse, sizeof(_emi__EnumerateAlertPoliciesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateAlertPoliciesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateAlertPoliciesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_TotalPolicyCount1 = 1, soap_flag_PoliciesReturned1 = 1, soap_flag_PolicyHandles1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__EnumerateAlertPoliciesResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_TotalPolicyCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:TotalPolicyCount", &(((_emi__EnumerateAlertPoliciesResponse*)a)->TotalPolicyCount), "xsd:unsignedInt")) + { soap_flag_TotalPolicyCount1--; + continue; + } + if (soap_flag_PoliciesReturned1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:PoliciesReturned", &(((_emi__EnumerateAlertPoliciesResponse*)a)->PoliciesReturned), "xsd:unsignedInt")) + { soap_flag_PoliciesReturned1--; + continue; + } + if (soap_flag_PolicyHandles1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertSubscriptionPolicyIDArrayType(soap, "emi:PolicyHandles", &(((_emi__EnumerateAlertPoliciesResponse*)a)->PolicyHandles), "emi:AlertSubscriptionPolicyIDArrayType")) + { soap_flag_PolicyHandles1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_TotalPolicyCount1 > 0 || soap_flag_PoliciesReturned1 > 0 || soap_flag_PolicyHandles1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateAlertPoliciesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateAlertPoliciesResponse, 0, sizeof(_emi__EnumerateAlertPoliciesResponse), 0, soap_copy__emi__EnumerateAlertPoliciesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateAlertPoliciesResponse * SOAP_FMAC6 soap_new__emi__EnumerateAlertPoliciesResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateAlertPoliciesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateAlertPoliciesResponse(struct soap *soap, _emi__EnumerateAlertPoliciesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateAlertPoliciesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateAlertPoliciesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateAlertPoliciesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateAlertPoliciesResponse; + if (size) + *size = sizeof(_emi__EnumerateAlertPoliciesResponse); + ((_emi__EnumerateAlertPoliciesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateAlertPoliciesResponse[n]; + if (size) + *size = n * sizeof(_emi__EnumerateAlertPoliciesResponse); + for (int i = 0; i < n; i++) + ((_emi__EnumerateAlertPoliciesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateAlertPoliciesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateAlertPoliciesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateAlertPoliciesResponse %p -> %p\n", q, p)); + *(_emi__EnumerateAlertPoliciesResponse*)p = *(_emi__EnumerateAlertPoliciesResponse*)q; +} + +void _emi__EnumerateAlertPolicies::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__EnumerateAlertPolicies*)this)->StartIndex, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _emi__EnumerateAlertPolicies::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_emi__EnumerateAlertPolicies*)this)->StartIndex); + /* transient soap skipped */ +} + +int _emi__EnumerateAlertPolicies::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateAlertPolicies); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateAlertPolicies::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateAlertPolicies(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateAlertPolicies(struct soap *soap, const char *tag, int id, const _emi__EnumerateAlertPolicies *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateAlertPolicies), type); + soap_out_unsignedInt(soap, "emi:StartIndex", -1, &(((_emi__EnumerateAlertPolicies*)a)->StartIndex), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateAlertPolicies::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateAlertPolicies(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_get__emi__EnumerateAlertPolicies(struct soap *soap, _emi__EnumerateAlertPolicies *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateAlertPolicies(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateAlertPolicies::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateAlertPolicies(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_in__emi__EnumerateAlertPolicies(struct soap *soap, const char *tag, _emi__EnumerateAlertPolicies *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateAlertPolicies *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateAlertPolicies, sizeof(_emi__EnumerateAlertPolicies), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateAlertPolicies) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateAlertPolicies *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StartIndex1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StartIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:StartIndex", &(((_emi__EnumerateAlertPolicies*)a)->StartIndex), "xsd:unsignedInt")) + { soap_flag_StartIndex1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StartIndex1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateAlertPolicies *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateAlertPolicies, 0, sizeof(_emi__EnumerateAlertPolicies), 0, soap_copy__emi__EnumerateAlertPolicies); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateAlertPolicies * SOAP_FMAC6 soap_new__emi__EnumerateAlertPolicies(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateAlertPolicies(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateAlertPolicies(struct soap *soap, _emi__EnumerateAlertPolicies *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_instantiate__emi__EnumerateAlertPolicies(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateAlertPolicies(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateAlertPolicies, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateAlertPolicies; + if (size) + *size = sizeof(_emi__EnumerateAlertPolicies); + ((_emi__EnumerateAlertPolicies*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateAlertPolicies[n]; + if (size) + *size = n * sizeof(_emi__EnumerateAlertPolicies); + for (int i = 0; i < n; i++) + ((_emi__EnumerateAlertPolicies*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateAlertPolicies*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateAlertPolicies(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateAlertPolicies %p -> %p\n", q, p)); + *(_emi__EnumerateAlertPolicies*)p = *(_emi__EnumerateAlertPolicies*)q; +} + +void _emi__GetAlertSubscriptionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToemi__AlertSubscriptionType(soap, &((_emi__GetAlertSubscriptionResponse*)this)->SubscriptionInfo); + /* transient soap skipped */ +} + +void _emi__GetAlertSubscriptionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__GetAlertSubscriptionResponse*)this)->Status); + ((_emi__GetAlertSubscriptionResponse*)this)->SubscriptionInfo = NULL; + /* transient soap skipped */ +} + +int _emi__GetAlertSubscriptionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetAlertSubscriptionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetAlertSubscriptionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetAlertSubscriptionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetAlertSubscriptionResponse(struct soap *soap, const char *tag, int id, const _emi__GetAlertSubscriptionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetAlertSubscriptionResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__GetAlertSubscriptionResponse*)a)->Status), ""); + soap_out_PointerToemi__AlertSubscriptionType(soap, "emi:SubscriptionInfo", -1, &(((_emi__GetAlertSubscriptionResponse*)a)->SubscriptionInfo), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetAlertSubscriptionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetAlertSubscriptionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse * SOAP_FMAC4 soap_get__emi__GetAlertSubscriptionResponse(struct soap *soap, _emi__GetAlertSubscriptionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetAlertSubscriptionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetAlertSubscriptionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetAlertSubscriptionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse * SOAP_FMAC4 soap_in__emi__GetAlertSubscriptionResponse(struct soap *soap, const char *tag, _emi__GetAlertSubscriptionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetAlertSubscriptionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetAlertSubscriptionResponse, sizeof(_emi__GetAlertSubscriptionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetAlertSubscriptionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetAlertSubscriptionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_SubscriptionInfo1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__GetAlertSubscriptionResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_SubscriptionInfo1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertSubscriptionType(soap, "emi:SubscriptionInfo", &(((_emi__GetAlertSubscriptionResponse*)a)->SubscriptionInfo), "emi:AlertSubscriptionType")) + { soap_flag_SubscriptionInfo1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_SubscriptionInfo1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetAlertSubscriptionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetAlertSubscriptionResponse, 0, sizeof(_emi__GetAlertSubscriptionResponse), 0, soap_copy__emi__GetAlertSubscriptionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetAlertSubscriptionResponse * SOAP_FMAC6 soap_new__emi__GetAlertSubscriptionResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__GetAlertSubscriptionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetAlertSubscriptionResponse(struct soap *soap, _emi__GetAlertSubscriptionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse * SOAP_FMAC4 soap_instantiate__emi__GetAlertSubscriptionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetAlertSubscriptionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetAlertSubscriptionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetAlertSubscriptionResponse; + if (size) + *size = sizeof(_emi__GetAlertSubscriptionResponse); + ((_emi__GetAlertSubscriptionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetAlertSubscriptionResponse[n]; + if (size) + *size = n * sizeof(_emi__GetAlertSubscriptionResponse); + for (int i = 0; i < n; i++) + ((_emi__GetAlertSubscriptionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetAlertSubscriptionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetAlertSubscriptionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetAlertSubscriptionResponse %p -> %p\n", q, p)); + *(_emi__GetAlertSubscriptionResponse*)p = *(_emi__GetAlertSubscriptionResponse*)q; +} + +void _emi__GetAlertSubscription::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__GetAlertSubscription::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__AlertSubscriptionHandleType(soap, &((_emi__GetAlertSubscription*)this)->SubscriptionID); + /* transient soap skipped */ +} + +int _emi__GetAlertSubscription::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__GetAlertSubscription); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__GetAlertSubscription::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__GetAlertSubscription(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__GetAlertSubscription(struct soap *soap, const char *tag, int id, const _emi__GetAlertSubscription *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__GetAlertSubscription), type); + soap_out_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionID", -1, &(((_emi__GetAlertSubscription*)a)->SubscriptionID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__GetAlertSubscription::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__GetAlertSubscription(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__GetAlertSubscription * SOAP_FMAC4 soap_get__emi__GetAlertSubscription(struct soap *soap, _emi__GetAlertSubscription *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__GetAlertSubscription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__GetAlertSubscription::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__GetAlertSubscription(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__GetAlertSubscription * SOAP_FMAC4 soap_in__emi__GetAlertSubscription(struct soap *soap, const char *tag, _emi__GetAlertSubscription *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__GetAlertSubscription *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__GetAlertSubscription, sizeof(_emi__GetAlertSubscription), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__GetAlertSubscription) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__GetAlertSubscription *)a->soap_in(soap, tag, type); + } + } + short soap_flag_SubscriptionID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_SubscriptionID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionID", &(((_emi__GetAlertSubscription*)a)->SubscriptionID), "emi:AlertSubscriptionHandleType")) + { soap_flag_SubscriptionID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_SubscriptionID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__GetAlertSubscription *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__GetAlertSubscription, 0, sizeof(_emi__GetAlertSubscription), 0, soap_copy__emi__GetAlertSubscription); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__GetAlertSubscription * SOAP_FMAC6 soap_new__emi__GetAlertSubscription(struct soap *soap, int n) +{ return soap_instantiate__emi__GetAlertSubscription(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__GetAlertSubscription(struct soap *soap, _emi__GetAlertSubscription *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__GetAlertSubscription * SOAP_FMAC4 soap_instantiate__emi__GetAlertSubscription(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__GetAlertSubscription(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__GetAlertSubscription, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__GetAlertSubscription; + if (size) + *size = sizeof(_emi__GetAlertSubscription); + ((_emi__GetAlertSubscription*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__GetAlertSubscription[n]; + if (size) + *size = n * sizeof(_emi__GetAlertSubscription); + for (int i = 0; i < n; i++) + ((_emi__GetAlertSubscription*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__GetAlertSubscription*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__GetAlertSubscription(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__GetAlertSubscription %p -> %p\n", q, p)); + *(_emi__GetAlertSubscription*)p = *(_emi__GetAlertSubscription*)q; +} + +void _emi__EnumerateAlertSubscriptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__EnumerateAlertSubscriptionsResponse*)this)->TotalSubscriptionCount, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_emi__EnumerateAlertSubscriptionsResponse*)this)->SubscriptionsReturned, SOAP_TYPE_unsignedInt); + soap_serialize_PointerToemi__AlertSubscriptionHandleArrayType(soap, &((_emi__EnumerateAlertSubscriptionsResponse*)this)->SubscriptionHandles); + /* transient soap skipped */ +} + +void _emi__EnumerateAlertSubscriptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__EnumerateAlertSubscriptionsResponse*)this)->Status); + soap_default_unsignedInt(soap, &((_emi__EnumerateAlertSubscriptionsResponse*)this)->TotalSubscriptionCount); + soap_default_unsignedInt(soap, &((_emi__EnumerateAlertSubscriptionsResponse*)this)->SubscriptionsReturned); + ((_emi__EnumerateAlertSubscriptionsResponse*)this)->SubscriptionHandles = NULL; + /* transient soap skipped */ +} + +int _emi__EnumerateAlertSubscriptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateAlertSubscriptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateAlertSubscriptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, const char *tag, int id, const _emi__EnumerateAlertSubscriptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__EnumerateAlertSubscriptionsResponse*)a)->Status), ""); + soap_out_unsignedInt(soap, "emi:TotalSubscriptionCount", -1, &(((_emi__EnumerateAlertSubscriptionsResponse*)a)->TotalSubscriptionCount), ""); + soap_out_unsignedInt(soap, "emi:SubscriptionsReturned", -1, &(((_emi__EnumerateAlertSubscriptionsResponse*)a)->SubscriptionsReturned), ""); + soap_out_PointerToemi__AlertSubscriptionHandleArrayType(soap, "emi:SubscriptionHandles", -1, &(((_emi__EnumerateAlertSubscriptionsResponse*)a)->SubscriptionHandles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateAlertSubscriptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateAlertSubscriptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse * SOAP_FMAC4 soap_get__emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateAlertSubscriptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateAlertSubscriptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateAlertSubscriptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateAlertSubscriptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse * SOAP_FMAC4 soap_in__emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, const char *tag, _emi__EnumerateAlertSubscriptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateAlertSubscriptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse, sizeof(_emi__EnumerateAlertSubscriptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateAlertSubscriptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_TotalSubscriptionCount1 = 1, soap_flag_SubscriptionsReturned1 = 1, soap_flag_SubscriptionHandles1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__EnumerateAlertSubscriptionsResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_TotalSubscriptionCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:TotalSubscriptionCount", &(((_emi__EnumerateAlertSubscriptionsResponse*)a)->TotalSubscriptionCount), "xsd:unsignedInt")) + { soap_flag_TotalSubscriptionCount1--; + continue; + } + if (soap_flag_SubscriptionsReturned1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:SubscriptionsReturned", &(((_emi__EnumerateAlertSubscriptionsResponse*)a)->SubscriptionsReturned), "xsd:unsignedInt")) + { soap_flag_SubscriptionsReturned1--; + continue; + } + if (soap_flag_SubscriptionHandles1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertSubscriptionHandleArrayType(soap, "emi:SubscriptionHandles", &(((_emi__EnumerateAlertSubscriptionsResponse*)a)->SubscriptionHandles), "emi:AlertSubscriptionHandleArrayType")) + { soap_flag_SubscriptionHandles1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_TotalSubscriptionCount1 > 0 || soap_flag_SubscriptionsReturned1 > 0 || soap_flag_SubscriptionHandles1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateAlertSubscriptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse, 0, sizeof(_emi__EnumerateAlertSubscriptionsResponse), 0, soap_copy__emi__EnumerateAlertSubscriptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateAlertSubscriptionsResponse * SOAP_FMAC6 soap_new__emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateAlertSubscriptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateAlertSubscriptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse * SOAP_FMAC4 soap_instantiate__emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateAlertSubscriptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateAlertSubscriptionsResponse; + if (size) + *size = sizeof(_emi__EnumerateAlertSubscriptionsResponse); + ((_emi__EnumerateAlertSubscriptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateAlertSubscriptionsResponse[n]; + if (size) + *size = n * sizeof(_emi__EnumerateAlertSubscriptionsResponse); + for (int i = 0; i < n; i++) + ((_emi__EnumerateAlertSubscriptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateAlertSubscriptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateAlertSubscriptionsResponse %p -> %p\n", q, p)); + *(_emi__EnumerateAlertSubscriptionsResponse*)p = *(_emi__EnumerateAlertSubscriptionsResponse*)q; +} + +void _emi__EnumerateAlertSubscriptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_emi__EnumerateAlertSubscriptions*)this)->StartIndex, SOAP_TYPE_unsignedInt); + soap_serialize_PointerToemi__AlertSubscriptionPolicyIDType(soap, &((_emi__EnumerateAlertSubscriptions*)this)->AlertSubscriptionPolicyID); + /* transient soap skipped */ +} + +void _emi__EnumerateAlertSubscriptions::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_emi__EnumerateAlertSubscriptions*)this)->StartIndex); + ((_emi__EnumerateAlertSubscriptions*)this)->AlertSubscriptionPolicyID = NULL; + /* transient soap skipped */ +} + +int _emi__EnumerateAlertSubscriptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__EnumerateAlertSubscriptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__EnumerateAlertSubscriptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__EnumerateAlertSubscriptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__EnumerateAlertSubscriptions(struct soap *soap, const char *tag, int id, const _emi__EnumerateAlertSubscriptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__EnumerateAlertSubscriptions), type); + soap_out_unsignedInt(soap, "emi:StartIndex", -1, &(((_emi__EnumerateAlertSubscriptions*)a)->StartIndex), ""); + soap_out_PointerToemi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", -1, &(((_emi__EnumerateAlertSubscriptions*)a)->AlertSubscriptionPolicyID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__EnumerateAlertSubscriptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__EnumerateAlertSubscriptions(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_get__emi__EnumerateAlertSubscriptions(struct soap *soap, _emi__EnumerateAlertSubscriptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__EnumerateAlertSubscriptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__EnumerateAlertSubscriptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__EnumerateAlertSubscriptions(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_in__emi__EnumerateAlertSubscriptions(struct soap *soap, const char *tag, _emi__EnumerateAlertSubscriptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__EnumerateAlertSubscriptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__EnumerateAlertSubscriptions, sizeof(_emi__EnumerateAlertSubscriptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__EnumerateAlertSubscriptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__EnumerateAlertSubscriptions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StartIndex1 = 1, soap_flag_AlertSubscriptionPolicyID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StartIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "emi:StartIndex", &(((_emi__EnumerateAlertSubscriptions*)a)->StartIndex), "xsd:unsignedInt")) + { soap_flag_StartIndex1--; + continue; + } + if (soap_flag_AlertSubscriptionPolicyID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", &(((_emi__EnumerateAlertSubscriptions*)a)->AlertSubscriptionPolicyID), "emi:AlertSubscriptionPolicyIDType")) + { soap_flag_AlertSubscriptionPolicyID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StartIndex1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__EnumerateAlertSubscriptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__EnumerateAlertSubscriptions, 0, sizeof(_emi__EnumerateAlertSubscriptions), 0, soap_copy__emi__EnumerateAlertSubscriptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__EnumerateAlertSubscriptions * SOAP_FMAC6 soap_new__emi__EnumerateAlertSubscriptions(struct soap *soap, int n) +{ return soap_instantiate__emi__EnumerateAlertSubscriptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__EnumerateAlertSubscriptions(struct soap *soap, _emi__EnumerateAlertSubscriptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_instantiate__emi__EnumerateAlertSubscriptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__EnumerateAlertSubscriptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__EnumerateAlertSubscriptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__EnumerateAlertSubscriptions; + if (size) + *size = sizeof(_emi__EnumerateAlertSubscriptions); + ((_emi__EnumerateAlertSubscriptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__EnumerateAlertSubscriptions[n]; + if (size) + *size = n * sizeof(_emi__EnumerateAlertSubscriptions); + for (int i = 0; i < n; i++) + ((_emi__EnumerateAlertSubscriptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__EnumerateAlertSubscriptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__EnumerateAlertSubscriptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__EnumerateAlertSubscriptions %p -> %p\n", q, p)); + *(_emi__EnumerateAlertSubscriptions*)p = *(_emi__EnumerateAlertSubscriptions*)q; +} + +void _emi__SubscribeForAlertResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _emi__SubscribeForAlertResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__PT_USCORESTATUS(soap, &((_emi__SubscribeForAlertResponse*)this)->Status); + soap_default_emi__AlertSubscriptionHandleType(soap, &((_emi__SubscribeForAlertResponse*)this)->SubscriptionHandle); + /* transient soap skipped */ +} + +int _emi__SubscribeForAlertResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__SubscribeForAlertResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__SubscribeForAlertResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__SubscribeForAlertResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SubscribeForAlertResponse(struct soap *soap, const char *tag, int id, const _emi__SubscribeForAlertResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__SubscribeForAlertResponse), type); + soap_element_result(soap, "emi:Status"); + soap_out_emi__PT_USCORESTATUS(soap, "emi:Status", -1, &(((_emi__SubscribeForAlertResponse*)a)->Status), ""); + soap_out_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", -1, &(((_emi__SubscribeForAlertResponse*)a)->SubscriptionHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__SubscribeForAlertResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__SubscribeForAlertResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__SubscribeForAlertResponse * SOAP_FMAC4 soap_get__emi__SubscribeForAlertResponse(struct soap *soap, _emi__SubscribeForAlertResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__SubscribeForAlertResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__SubscribeForAlertResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__SubscribeForAlertResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__SubscribeForAlertResponse * SOAP_FMAC4 soap_in__emi__SubscribeForAlertResponse(struct soap *soap, const char *tag, _emi__SubscribeForAlertResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__SubscribeForAlertResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__SubscribeForAlertResponse, sizeof(_emi__SubscribeForAlertResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__SubscribeForAlertResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__SubscribeForAlertResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Status1 = 1, soap_flag_SubscriptionHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Status1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__PT_USCORESTATUS(soap, "emi:Status", &(((_emi__SubscribeForAlertResponse*)a)->Status), "emi:PT_STATUS")) + { soap_flag_Status1--; + continue; + } + if (soap_flag_SubscriptionHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__AlertSubscriptionHandleType(soap, "emi:SubscriptionHandle", &(((_emi__SubscribeForAlertResponse*)a)->SubscriptionHandle), "emi:AlertSubscriptionHandleType")) + { soap_flag_SubscriptionHandle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "emi:Status"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Status1 > 0 || soap_flag_SubscriptionHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__SubscribeForAlertResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__SubscribeForAlertResponse, 0, sizeof(_emi__SubscribeForAlertResponse), 0, soap_copy__emi__SubscribeForAlertResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__SubscribeForAlertResponse * SOAP_FMAC6 soap_new__emi__SubscribeForAlertResponse(struct soap *soap, int n) +{ return soap_instantiate__emi__SubscribeForAlertResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SubscribeForAlertResponse(struct soap *soap, _emi__SubscribeForAlertResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__SubscribeForAlertResponse * SOAP_FMAC4 soap_instantiate__emi__SubscribeForAlertResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__SubscribeForAlertResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__SubscribeForAlertResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__SubscribeForAlertResponse; + if (size) + *size = sizeof(_emi__SubscribeForAlertResponse); + ((_emi__SubscribeForAlertResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__SubscribeForAlertResponse[n]; + if (size) + *size = n * sizeof(_emi__SubscribeForAlertResponse); + for (int i = 0; i < n; i++) + ((_emi__SubscribeForAlertResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__SubscribeForAlertResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SubscribeForAlertResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__SubscribeForAlertResponse %p -> %p\n", q, p)); + *(_emi__SubscribeForAlertResponse*)p = *(_emi__SubscribeForAlertResponse*)q; +} + +void _emi__SubscribeForAlert::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToemi__AlertSubscriptionType(soap, &((_emi__SubscribeForAlert*)this)->SubscriptionInfo); + /* transient soap skipped */ +} + +void _emi__SubscribeForAlert::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_emi__SubscribeForAlert*)this)->SubscriptionInfo = NULL; + /* transient soap skipped */ +} + +int _emi__SubscribeForAlert::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__emi__SubscribeForAlert); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _emi__SubscribeForAlert::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__emi__SubscribeForAlert(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__SubscribeForAlert(struct soap *soap, const char *tag, int id, const _emi__SubscribeForAlert *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__emi__SubscribeForAlert), type); + soap_out_PointerToemi__AlertSubscriptionType(soap, "emi:SubscriptionInfo", -1, &(((_emi__SubscribeForAlert*)a)->SubscriptionInfo), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_emi__SubscribeForAlert::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__emi__SubscribeForAlert(soap, this, tag, type); +} + +SOAP_FMAC3 _emi__SubscribeForAlert * SOAP_FMAC4 soap_get__emi__SubscribeForAlert(struct soap *soap, _emi__SubscribeForAlert *p, const char *tag, const char *type) +{ + if ((p = soap_in__emi__SubscribeForAlert(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_emi__SubscribeForAlert::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__emi__SubscribeForAlert(soap, tag, this, type); +} + +SOAP_FMAC3 _emi__SubscribeForAlert * SOAP_FMAC4 soap_in__emi__SubscribeForAlert(struct soap *soap, const char *tag, _emi__SubscribeForAlert *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_emi__SubscribeForAlert *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__emi__SubscribeForAlert, sizeof(_emi__SubscribeForAlert), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__emi__SubscribeForAlert) + { soap_revert(soap); + *soap->id = '\0'; + return (_emi__SubscribeForAlert *)a->soap_in(soap, tag, type); + } + } + short soap_flag_SubscriptionInfo1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_SubscriptionInfo1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertSubscriptionType(soap, "emi:SubscriptionInfo", &(((_emi__SubscribeForAlert*)a)->SubscriptionInfo), "emi:AlertSubscriptionType")) + { soap_flag_SubscriptionInfo1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_SubscriptionInfo1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_emi__SubscribeForAlert *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__emi__SubscribeForAlert, 0, sizeof(_emi__SubscribeForAlert), 0, soap_copy__emi__SubscribeForAlert); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _emi__SubscribeForAlert * SOAP_FMAC6 soap_new__emi__SubscribeForAlert(struct soap *soap, int n) +{ return soap_instantiate__emi__SubscribeForAlert(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__emi__SubscribeForAlert(struct soap *soap, _emi__SubscribeForAlert *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _emi__SubscribeForAlert * SOAP_FMAC4 soap_instantiate__emi__SubscribeForAlert(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__emi__SubscribeForAlert(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__emi__SubscribeForAlert, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _emi__SubscribeForAlert; + if (size) + *size = sizeof(_emi__SubscribeForAlert); + ((_emi__SubscribeForAlert*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _emi__SubscribeForAlert[n]; + if (size) + *size = n * sizeof(_emi__SubscribeForAlert); + for (int i = 0; i < n; i++) + ((_emi__SubscribeForAlert*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_emi__SubscribeForAlert*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__emi__SubscribeForAlert(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _emi__SubscribeForAlert %p -> %p\n", q, p)); + *(_emi__SubscribeForAlert*)p = *(_emi__SubscribeForAlert*)q; +} + +void emi__AlertSubscriptionGeneralType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((emi__AlertSubscriptionGeneralType*)this)->PolicyID, SOAP_TYPE_emi__AlertSubscriptionPolicyIDType); + soap_serialize__emi__union_AlertSubscriptionGeneralType(soap, ((emi__AlertSubscriptionGeneralType*)this)->__union_AlertSubscriptionGeneralType, &((emi__AlertSubscriptionGeneralType*)this)->union_AlertSubscriptionGeneralType); + /* transient soap skipped */ +} + +void emi__AlertSubscriptionGeneralType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__AlertSubscriptionPolicyIDType(soap, &((emi__AlertSubscriptionGeneralType*)this)->PolicyID); + ((emi__AlertSubscriptionGeneralType*)this)->__union_AlertSubscriptionGeneralType = 0; + ((emi__AlertSubscriptionGeneralType*)this)->__any = NULL; + /* transient soap skipped */ +} + +int emi__AlertSubscriptionGeneralType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__AlertSubscriptionGeneralType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__AlertSubscriptionGeneralType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__AlertSubscriptionGeneralType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionGeneralType(struct soap *soap, const char *tag, int id, const emi__AlertSubscriptionGeneralType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__AlertSubscriptionGeneralType), type); + soap_out_emi__AlertSubscriptionPolicyIDType(soap, "emi:PolicyID", -1, &(((emi__AlertSubscriptionGeneralType*)a)->PolicyID), ""); + soap_out__emi__union_AlertSubscriptionGeneralType(soap, ((emi__AlertSubscriptionGeneralType*)a)->__union_AlertSubscriptionGeneralType, &((emi__AlertSubscriptionGeneralType*)a)->union_AlertSubscriptionGeneralType); + soap_outliteral(soap, "-any", &(((emi__AlertSubscriptionGeneralType*)a)->__any), NULL); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__AlertSubscriptionGeneralType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__AlertSubscriptionGeneralType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionGeneralType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionGeneralType(struct soap *soap, emi__AlertSubscriptionGeneralType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertSubscriptionGeneralType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__AlertSubscriptionGeneralType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__AlertSubscriptionGeneralType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionGeneralType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionGeneralType(struct soap *soap, const char *tag, emi__AlertSubscriptionGeneralType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__AlertSubscriptionGeneralType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__AlertSubscriptionGeneralType, sizeof(emi__AlertSubscriptionGeneralType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__AlertSubscriptionGeneralType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__AlertSubscriptionGeneralType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PolicyID1 = 1, soap_flag_union_AlertSubscriptionGeneralType1 = 1, soap_flag___any1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PolicyID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__AlertSubscriptionPolicyIDType(soap, "emi:PolicyID", &(((emi__AlertSubscriptionGeneralType*)a)->PolicyID), "emi:AlertSubscriptionPolicyIDType")) + { soap_flag_PolicyID1--; + continue; + } + if (soap_flag_union_AlertSubscriptionGeneralType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__emi__union_AlertSubscriptionGeneralType(soap, &((emi__AlertSubscriptionGeneralType*)a)->__union_AlertSubscriptionGeneralType, &((emi__AlertSubscriptionGeneralType*)a)->union_AlertSubscriptionGeneralType)) + { soap_flag_union_AlertSubscriptionGeneralType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap_flag___any1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_inliteral(soap, "-any", &(((emi__AlertSubscriptionGeneralType*)a)->__any))) + { soap_flag___any1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PolicyID1 > 0 || soap_flag_union_AlertSubscriptionGeneralType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__AlertSubscriptionGeneralType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__AlertSubscriptionGeneralType, 0, sizeof(emi__AlertSubscriptionGeneralType), 0, soap_copy_emi__AlertSubscriptionGeneralType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__AlertSubscriptionGeneralType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionGeneralType(struct soap *soap, int n) +{ return soap_instantiate_emi__AlertSubscriptionGeneralType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionGeneralType(struct soap *soap, emi__AlertSubscriptionGeneralType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__AlertSubscriptionGeneralType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionGeneralType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__AlertSubscriptionGeneralType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__AlertSubscriptionGeneralType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__AlertSubscriptionGeneralType; + if (size) + *size = sizeof(emi__AlertSubscriptionGeneralType); + ((emi__AlertSubscriptionGeneralType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__AlertSubscriptionGeneralType[n]; + if (size) + *size = n * sizeof(emi__AlertSubscriptionGeneralType); + for (int i = 0; i < n; i++) + ((emi__AlertSubscriptionGeneralType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__AlertSubscriptionGeneralType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionGeneralType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__AlertSubscriptionGeneralType %p -> %p\n", q, p)); + *(emi__AlertSubscriptionGeneralType*)p = *(emi__AlertSubscriptionGeneralType*)q; +} + +void emi__AlertSubscriptionSoapType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocmn__URLType(soap, &((emi__AlertSubscriptionSoapType*)this)->Address); + soap_serialize_PointerTosai__CertificateHandleType(soap, &((emi__AlertSubscriptionSoapType*)this)->ClientCredentials); + soap_serialize_PointerToemi__AlertCredentialsType(soap, &((emi__AlertSubscriptionSoapType*)this)->UserCredentials); + soap_serialize_std__vectorTemplateOfemi__AlertAuthOptionsType(soap, &((emi__AlertSubscriptionSoapType*)this)->AlertAuthOptions); + /* transient soap skipped */ +} + +void emi__AlertSubscriptionSoapType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((emi__AlertSubscriptionSoapType*)this)->Address = NULL; + ((emi__AlertSubscriptionSoapType*)this)->ClientCredentials = NULL; + ((emi__AlertSubscriptionSoapType*)this)->UserCredentials = NULL; + soap_default_std__vectorTemplateOfemi__AlertAuthOptionsType(soap, &((emi__AlertSubscriptionSoapType*)this)->AlertAuthOptions); + /* transient soap skipped */ +} + +int emi__AlertSubscriptionSoapType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__AlertSubscriptionSoapType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__AlertSubscriptionSoapType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__AlertSubscriptionSoapType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionSoapType(struct soap *soap, const char *tag, int id, const emi__AlertSubscriptionSoapType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__AlertSubscriptionSoapType), type); + soap_out_PointerTocmn__URLType(soap, "emi:Address", -1, &(((emi__AlertSubscriptionSoapType*)a)->Address), ""); + soap_out_PointerTosai__CertificateHandleType(soap, "emi:ClientCredentials", -1, &(((emi__AlertSubscriptionSoapType*)a)->ClientCredentials), ""); + soap_out_PointerToemi__AlertCredentialsType(soap, "emi:UserCredentials", -1, &(((emi__AlertSubscriptionSoapType*)a)->UserCredentials), ""); + soap_out_std__vectorTemplateOfemi__AlertAuthOptionsType(soap, "emi:AlertAuthOptions", -1, &(((emi__AlertSubscriptionSoapType*)a)->AlertAuthOptions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__AlertSubscriptionSoapType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__AlertSubscriptionSoapType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionSoapType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionSoapType(struct soap *soap, emi__AlertSubscriptionSoapType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertSubscriptionSoapType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__AlertSubscriptionSoapType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__AlertSubscriptionSoapType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionSoapType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionSoapType(struct soap *soap, const char *tag, emi__AlertSubscriptionSoapType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__AlertSubscriptionSoapType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__AlertSubscriptionSoapType, sizeof(emi__AlertSubscriptionSoapType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__AlertSubscriptionSoapType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__AlertSubscriptionSoapType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Address1 = 1, soap_flag_ClientCredentials1 = 1, soap_flag_UserCredentials1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Address1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocmn__URLType(soap, "emi:Address", &(((emi__AlertSubscriptionSoapType*)a)->Address), "cmn:URLType")) + { soap_flag_Address1--; + continue; + } + if (soap_flag_ClientCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateHandleType(soap, "emi:ClientCredentials", &(((emi__AlertSubscriptionSoapType*)a)->ClientCredentials), "sai:CertificateHandleType")) + { soap_flag_ClientCredentials1--; + continue; + } + if (soap_flag_UserCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__AlertCredentialsType(soap, "emi:UserCredentials", &(((emi__AlertSubscriptionSoapType*)a)->UserCredentials), "emi:AlertCredentialsType")) + { soap_flag_UserCredentials1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfemi__AlertAuthOptionsType(soap, "emi:AlertAuthOptions", &(((emi__AlertSubscriptionSoapType*)a)->AlertAuthOptions), "emi:AlertAuthOptionsType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Address1 > 0 || ((emi__AlertSubscriptionSoapType*)a)->AlertAuthOptions.size() > 3)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__AlertSubscriptionSoapType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__AlertSubscriptionSoapType, 0, sizeof(emi__AlertSubscriptionSoapType), 0, soap_copy_emi__AlertSubscriptionSoapType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__AlertSubscriptionSoapType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionSoapType(struct soap *soap, int n) +{ return soap_instantiate_emi__AlertSubscriptionSoapType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionSoapType(struct soap *soap, emi__AlertSubscriptionSoapType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__AlertSubscriptionSoapType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionSoapType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__AlertSubscriptionSoapType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__AlertSubscriptionSoapType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__AlertSubscriptionSoapType; + if (size) + *size = sizeof(emi__AlertSubscriptionSoapType); + ((emi__AlertSubscriptionSoapType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__AlertSubscriptionSoapType[n]; + if (size) + *size = n * sizeof(emi__AlertSubscriptionSoapType); + for (int i = 0; i < n; i++) + ((emi__AlertSubscriptionSoapType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__AlertSubscriptionSoapType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionSoapType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__AlertSubscriptionSoapType %p -> %p\n", q, p)); + *(emi__AlertSubscriptionSoapType*)p = *(emi__AlertSubscriptionSoapType*)q; +} + +void emi__AlertSubscriptionSNMPType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocmn__NodeAddressType(soap, &((emi__AlertSubscriptionSNMPType*)this)->Address); + soap_serialize_PointerToemi__CommunityStringType(soap, &((emi__AlertSubscriptionSNMPType*)this)->CommunityString); + /* transient soap skipped */ +} + +void emi__AlertSubscriptionSNMPType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((emi__AlertSubscriptionSNMPType*)this)->Address = NULL; + ((emi__AlertSubscriptionSNMPType*)this)->CommunityString = NULL; + /* transient soap skipped */ +} + +int emi__AlertSubscriptionSNMPType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__AlertSubscriptionSNMPType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__AlertSubscriptionSNMPType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__AlertSubscriptionSNMPType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionSNMPType(struct soap *soap, const char *tag, int id, const emi__AlertSubscriptionSNMPType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__AlertSubscriptionSNMPType), type); + soap_out_PointerTocmn__NodeAddressType(soap, "emi:Address", -1, &(((emi__AlertSubscriptionSNMPType*)a)->Address), ""); + soap_out_PointerToemi__CommunityStringType(soap, "emi:CommunityString", -1, &(((emi__AlertSubscriptionSNMPType*)a)->CommunityString), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__AlertSubscriptionSNMPType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__AlertSubscriptionSNMPType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionSNMPType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionSNMPType(struct soap *soap, emi__AlertSubscriptionSNMPType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertSubscriptionSNMPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__AlertSubscriptionSNMPType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__AlertSubscriptionSNMPType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionSNMPType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionSNMPType(struct soap *soap, const char *tag, emi__AlertSubscriptionSNMPType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__AlertSubscriptionSNMPType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__AlertSubscriptionSNMPType, sizeof(emi__AlertSubscriptionSNMPType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__AlertSubscriptionSNMPType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__AlertSubscriptionSNMPType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Address1 = 1, soap_flag_CommunityString1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Address1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocmn__NodeAddressType(soap, "emi:Address", &(((emi__AlertSubscriptionSNMPType*)a)->Address), "cmn:NodeAddressType")) + { soap_flag_Address1--; + continue; + } + if (soap_flag_CommunityString1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerToemi__CommunityStringType(soap, "emi:CommunityString", &(((emi__AlertSubscriptionSNMPType*)a)->CommunityString), "emi:CommunityStringType")) + { soap_flag_CommunityString1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Address1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__AlertSubscriptionSNMPType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__AlertSubscriptionSNMPType, 0, sizeof(emi__AlertSubscriptionSNMPType), 0, soap_copy_emi__AlertSubscriptionSNMPType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__AlertSubscriptionSNMPType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionSNMPType(struct soap *soap, int n) +{ return soap_instantiate_emi__AlertSubscriptionSNMPType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionSNMPType(struct soap *soap, emi__AlertSubscriptionSNMPType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__AlertSubscriptionSNMPType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionSNMPType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__AlertSubscriptionSNMPType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__AlertSubscriptionSNMPType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__AlertSubscriptionSNMPType; + if (size) + *size = sizeof(emi__AlertSubscriptionSNMPType); + ((emi__AlertSubscriptionSNMPType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__AlertSubscriptionSNMPType[n]; + if (size) + *size = n * sizeof(emi__AlertSubscriptionSNMPType); + for (int i = 0; i < n; i++) + ((emi__AlertSubscriptionSNMPType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__AlertSubscriptionSNMPType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionSNMPType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__AlertSubscriptionSNMPType %p -> %p\n", q, p)); + *(emi__AlertSubscriptionSNMPType*)p = *(emi__AlertSubscriptionSNMPType*)q; +} + +void emi__AlertCredentialsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((emi__AlertCredentialsType*)this)->Username, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((emi__AlertCredentialsType*)this)->Username); + soap_embedded(soap, &((emi__AlertCredentialsType*)this)->Password, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((emi__AlertCredentialsType*)this)->Password); + /* transient soap skipped */ +} + +void emi__AlertCredentialsType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((emi__AlertCredentialsType*)this)->Username); + soap_default_std__string(soap, &((emi__AlertCredentialsType*)this)->Password); + /* transient soap skipped */ +} + +int emi__AlertCredentialsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__AlertCredentialsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__AlertCredentialsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__AlertCredentialsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertCredentialsType(struct soap *soap, const char *tag, int id, const emi__AlertCredentialsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__AlertCredentialsType), type); + soap_out_std__string(soap, "emi:Username", -1, &(((emi__AlertCredentialsType*)a)->Username), ""); + soap_out_std__string(soap, "emi:Password", -1, &(((emi__AlertCredentialsType*)a)->Password), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__AlertCredentialsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__AlertCredentialsType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__AlertCredentialsType * SOAP_FMAC4 soap_get_emi__AlertCredentialsType(struct soap *soap, emi__AlertCredentialsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertCredentialsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__AlertCredentialsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__AlertCredentialsType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__AlertCredentialsType * SOAP_FMAC4 soap_in_emi__AlertCredentialsType(struct soap *soap, const char *tag, emi__AlertCredentialsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__AlertCredentialsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__AlertCredentialsType, sizeof(emi__AlertCredentialsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__AlertCredentialsType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__AlertCredentialsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Username1 = 1, soap_flag_Password1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Username1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "emi:Username", &(((emi__AlertCredentialsType*)a)->Username), "xsd:string")) + { soap_flag_Username1--; + continue; + } + if (soap_flag_Password1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "emi:Password", &(((emi__AlertCredentialsType*)a)->Password), "xsd:string")) + { soap_flag_Password1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Username1 > 0 || soap_flag_Password1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__AlertCredentialsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__AlertCredentialsType, 0, sizeof(emi__AlertCredentialsType), 0, soap_copy_emi__AlertCredentialsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__AlertCredentialsType * SOAP_FMAC6 soap_new_emi__AlertCredentialsType(struct soap *soap, int n) +{ return soap_instantiate_emi__AlertCredentialsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertCredentialsType(struct soap *soap, emi__AlertCredentialsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__AlertCredentialsType * SOAP_FMAC4 soap_instantiate_emi__AlertCredentialsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__AlertCredentialsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__AlertCredentialsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__AlertCredentialsType; + if (size) + *size = sizeof(emi__AlertCredentialsType); + ((emi__AlertCredentialsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__AlertCredentialsType[n]; + if (size) + *size = n * sizeof(emi__AlertCredentialsType); + for (int i = 0; i < n; i++) + ((emi__AlertCredentialsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__AlertCredentialsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertCredentialsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__AlertCredentialsType %p -> %p\n", q, p)); + *(emi__AlertCredentialsType*)p = *(emi__AlertCredentialsType*)q; +} + +void emi__ByteStr::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((emi__ByteStr*)this)->Byte); + /* transient soap skipped */ +} + +void emi__ByteStr::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfunsignedByte(soap, &((emi__ByteStr*)this)->Byte); + /* transient soap skipped */ +} + +int emi__ByteStr::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__ByteStr); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__ByteStr::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__ByteStr(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__ByteStr(struct soap *soap, const char *tag, int id, const emi__ByteStr *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__ByteStr), type); + soap_out_std__vectorTemplateOfunsignedByte(soap, "emi:Byte", -1, &(((emi__ByteStr*)a)->Byte), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__ByteStr::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__ByteStr(soap, this, tag, type); +} + +SOAP_FMAC3 emi__ByteStr * SOAP_FMAC4 soap_get_emi__ByteStr(struct soap *soap, emi__ByteStr *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__ByteStr(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__ByteStr::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__ByteStr(soap, tag, this, type); +} + +SOAP_FMAC3 emi__ByteStr * SOAP_FMAC4 soap_in_emi__ByteStr(struct soap *soap, const char *tag, emi__ByteStr *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__ByteStr *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__ByteStr, sizeof(emi__ByteStr), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__ByteStr) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__ByteStr *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "emi:Byte", &(((emi__ByteStr*)a)->Byte), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((emi__ByteStr*)a)->Byte.size() > 16)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__ByteStr *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__ByteStr, 0, sizeof(emi__ByteStr), 0, soap_copy_emi__ByteStr); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__ByteStr * SOAP_FMAC6 soap_new_emi__ByteStr(struct soap *soap, int n) +{ return soap_instantiate_emi__ByteStr(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__ByteStr(struct soap *soap, emi__ByteStr *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__ByteStr * SOAP_FMAC4 soap_instantiate_emi__ByteStr(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__ByteStr(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__ByteStr, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__ByteStr; + if (size) + *size = sizeof(emi__ByteStr); + ((emi__ByteStr*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__ByteStr[n]; + if (size) + *size = n * sizeof(emi__ByteStr); + for (int i = 0; i < n; i++) + ((emi__ByteStr*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__ByteStr*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__ByteStr(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__ByteStr %p -> %p\n", q, p)); + *(emi__ByteStr*)p = *(emi__ByteStr*)q; +} + +void emi__SensorAttributesType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((emi__SensorAttributesType*)this)->IsLegacySensor, SOAP_TYPE_bool); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->AssertionEvent, SOAP_TYPE_bool); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->DeassertionEvent, SOAP_TYPE_bool); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->Index, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->DeviceAddress, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->EventSensorType, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->EventType, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->EventOffset, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->EventSourceType, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->SensorNumber, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->Entity, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__SensorAttributesType*)this)->EntityInstance, SOAP_TYPE_unsignedByte); + /* transient soap skipped */ +} + +void emi__SensorAttributesType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((emi__SensorAttributesType*)this)->IsLegacySensor); + soap_default_bool(soap, &((emi__SensorAttributesType*)this)->AssertionEvent); + soap_default_bool(soap, &((emi__SensorAttributesType*)this)->DeassertionEvent); + soap_default_unsignedByte(soap, &((emi__SensorAttributesType*)this)->Index); + soap_default_unsignedByte(soap, &((emi__SensorAttributesType*)this)->DeviceAddress); + soap_default_unsignedByte(soap, &((emi__SensorAttributesType*)this)->EventSensorType); + soap_default_unsignedByte(soap, &((emi__SensorAttributesType*)this)->EventType); + soap_default_unsignedByte(soap, &((emi__SensorAttributesType*)this)->EventOffset); + soap_default_unsignedByte(soap, &((emi__SensorAttributesType*)this)->EventSourceType); + soap_default_emi__EventSeverityType(soap, &((emi__SensorAttributesType*)this)->EventSeverity); + soap_default_unsignedByte(soap, &((emi__SensorAttributesType*)this)->SensorNumber); + soap_default_unsignedByte(soap, &((emi__SensorAttributesType*)this)->Entity); + soap_default_unsignedByte(soap, &((emi__SensorAttributesType*)this)->EntityInstance); + /* transient soap skipped */ +} + +int emi__SensorAttributesType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__SensorAttributesType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__SensorAttributesType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__SensorAttributesType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__SensorAttributesType(struct soap *soap, const char *tag, int id, const emi__SensorAttributesType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__SensorAttributesType), type); + soap_out_bool(soap, "emi:IsLegacySensor", -1, &(((emi__SensorAttributesType*)a)->IsLegacySensor), ""); + soap_out_bool(soap, "emi:AssertionEvent", -1, &(((emi__SensorAttributesType*)a)->AssertionEvent), ""); + soap_out_bool(soap, "emi:DeassertionEvent", -1, &(((emi__SensorAttributesType*)a)->DeassertionEvent), ""); + soap_out_unsignedByte(soap, "emi:Index", -1, &(((emi__SensorAttributesType*)a)->Index), ""); + soap_out_unsignedByte(soap, "emi:DeviceAddress", -1, &(((emi__SensorAttributesType*)a)->DeviceAddress), ""); + soap_out_unsignedByte(soap, "emi:EventSensorType", -1, &(((emi__SensorAttributesType*)a)->EventSensorType), ""); + soap_out_unsignedByte(soap, "emi:EventType", -1, &(((emi__SensorAttributesType*)a)->EventType), ""); + soap_out_unsignedByte(soap, "emi:EventOffset", -1, &(((emi__SensorAttributesType*)a)->EventOffset), ""); + soap_out_unsignedByte(soap, "emi:EventSourceType", -1, &(((emi__SensorAttributesType*)a)->EventSourceType), ""); + soap_out_emi__EventSeverityType(soap, "emi:EventSeverity", -1, &(((emi__SensorAttributesType*)a)->EventSeverity), ""); + soap_out_unsignedByte(soap, "emi:SensorNumber", -1, &(((emi__SensorAttributesType*)a)->SensorNumber), ""); + soap_out_unsignedByte(soap, "emi:Entity", -1, &(((emi__SensorAttributesType*)a)->Entity), ""); + soap_out_unsignedByte(soap, "emi:EntityInstance", -1, &(((emi__SensorAttributesType*)a)->EntityInstance), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__SensorAttributesType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__SensorAttributesType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__SensorAttributesType * SOAP_FMAC4 soap_get_emi__SensorAttributesType(struct soap *soap, emi__SensorAttributesType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__SensorAttributesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__SensorAttributesType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__SensorAttributesType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__SensorAttributesType * SOAP_FMAC4 soap_in_emi__SensorAttributesType(struct soap *soap, const char *tag, emi__SensorAttributesType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__SensorAttributesType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__SensorAttributesType, sizeof(emi__SensorAttributesType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__SensorAttributesType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__SensorAttributesType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_IsLegacySensor1 = 1, soap_flag_AssertionEvent1 = 1, soap_flag_DeassertionEvent1 = 1, soap_flag_Index1 = 1, soap_flag_DeviceAddress1 = 1, soap_flag_EventSensorType1 = 1, soap_flag_EventType1 = 1, soap_flag_EventOffset1 = 1, soap_flag_EventSourceType1 = 1, soap_flag_EventSeverity1 = 1, soap_flag_SensorNumber1 = 1, soap_flag_Entity1 = 1, soap_flag_EntityInstance1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_IsLegacySensor1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "emi:IsLegacySensor", &(((emi__SensorAttributesType*)a)->IsLegacySensor), "xsd:boolean")) + { soap_flag_IsLegacySensor1--; + continue; + } + if (soap_flag_AssertionEvent1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "emi:AssertionEvent", &(((emi__SensorAttributesType*)a)->AssertionEvent), "xsd:boolean")) + { soap_flag_AssertionEvent1--; + continue; + } + if (soap_flag_DeassertionEvent1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "emi:DeassertionEvent", &(((emi__SensorAttributesType*)a)->DeassertionEvent), "xsd:boolean")) + { soap_flag_DeassertionEvent1--; + continue; + } + if (soap_flag_Index1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:Index", &(((emi__SensorAttributesType*)a)->Index), "xsd:unsignedByte")) + { soap_flag_Index1--; + continue; + } + if (soap_flag_DeviceAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:DeviceAddress", &(((emi__SensorAttributesType*)a)->DeviceAddress), "xsd:unsignedByte")) + { soap_flag_DeviceAddress1--; + continue; + } + if (soap_flag_EventSensorType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventSensorType", &(((emi__SensorAttributesType*)a)->EventSensorType), "xsd:unsignedByte")) + { soap_flag_EventSensorType1--; + continue; + } + if (soap_flag_EventType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventType", &(((emi__SensorAttributesType*)a)->EventType), "xsd:unsignedByte")) + { soap_flag_EventType1--; + continue; + } + if (soap_flag_EventOffset1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventOffset", &(((emi__SensorAttributesType*)a)->EventOffset), "xsd:unsignedByte")) + { soap_flag_EventOffset1--; + continue; + } + if (soap_flag_EventSourceType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventSourceType", &(((emi__SensorAttributesType*)a)->EventSourceType), "xsd:unsignedByte")) + { soap_flag_EventSourceType1--; + continue; + } + if (soap_flag_EventSeverity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__EventSeverityType(soap, "emi:EventSeverity", &(((emi__SensorAttributesType*)a)->EventSeverity), "emi:EventSeverityType")) + { soap_flag_EventSeverity1--; + continue; + } + if (soap_flag_SensorNumber1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:SensorNumber", &(((emi__SensorAttributesType*)a)->SensorNumber), "xsd:unsignedByte")) + { soap_flag_SensorNumber1--; + continue; + } + if (soap_flag_Entity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:Entity", &(((emi__SensorAttributesType*)a)->Entity), "xsd:unsignedByte")) + { soap_flag_Entity1--; + continue; + } + if (soap_flag_EntityInstance1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EntityInstance", &(((emi__SensorAttributesType*)a)->EntityInstance), "xsd:unsignedByte")) + { soap_flag_EntityInstance1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_IsLegacySensor1 > 0 || soap_flag_AssertionEvent1 > 0 || soap_flag_DeassertionEvent1 > 0 || soap_flag_Index1 > 0 || soap_flag_DeviceAddress1 > 0 || soap_flag_EventSensorType1 > 0 || soap_flag_EventType1 > 0 || soap_flag_EventOffset1 > 0 || soap_flag_EventSourceType1 > 0 || soap_flag_EventSeverity1 > 0 || soap_flag_SensorNumber1 > 0 || soap_flag_Entity1 > 0 || soap_flag_EntityInstance1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__SensorAttributesType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__SensorAttributesType, 0, sizeof(emi__SensorAttributesType), 0, soap_copy_emi__SensorAttributesType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__SensorAttributesType * SOAP_FMAC6 soap_new_emi__SensorAttributesType(struct soap *soap, int n) +{ return soap_instantiate_emi__SensorAttributesType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__SensorAttributesType(struct soap *soap, emi__SensorAttributesType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__SensorAttributesType * SOAP_FMAC4 soap_instantiate_emi__SensorAttributesType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__SensorAttributesType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__SensorAttributesType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__SensorAttributesType; + if (size) + *size = sizeof(emi__SensorAttributesType); + ((emi__SensorAttributesType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__SensorAttributesType[n]; + if (size) + *size = n * sizeof(emi__SensorAttributesType); + for (int i = 0; i < n; i++) + ((emi__SensorAttributesType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__SensorAttributesType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__SensorAttributesType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__SensorAttributesType %p -> %p\n", q, p)); + *(emi__SensorAttributesType*)p = *(emi__SensorAttributesType*)q; +} + +void emi__SensorHandleArrayType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfemi__SensorHandleType(soap, &((emi__SensorHandleArrayType*)this)->SensorHandle); + /* transient soap skipped */ +} + +void emi__SensorHandleArrayType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfemi__SensorHandleType(soap, &((emi__SensorHandleArrayType*)this)->SensorHandle); + /* transient soap skipped */ +} + +int emi__SensorHandleArrayType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__SensorHandleArrayType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__SensorHandleArrayType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__SensorHandleArrayType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__SensorHandleArrayType(struct soap *soap, const char *tag, int id, const emi__SensorHandleArrayType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__SensorHandleArrayType), type); + soap_out_std__vectorTemplateOfemi__SensorHandleType(soap, "emi:SensorHandle", -1, &(((emi__SensorHandleArrayType*)a)->SensorHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__SensorHandleArrayType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__SensorHandleArrayType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__SensorHandleArrayType * SOAP_FMAC4 soap_get_emi__SensorHandleArrayType(struct soap *soap, emi__SensorHandleArrayType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__SensorHandleArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__SensorHandleArrayType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__SensorHandleArrayType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__SensorHandleArrayType * SOAP_FMAC4 soap_in_emi__SensorHandleArrayType(struct soap *soap, const char *tag, emi__SensorHandleArrayType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__SensorHandleArrayType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__SensorHandleArrayType, sizeof(emi__SensorHandleArrayType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__SensorHandleArrayType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__SensorHandleArrayType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfemi__SensorHandleType(soap, "emi:SensorHandle", &(((emi__SensorHandleArrayType*)a)->SensorHandle), "emi:SensorHandleType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__SensorHandleArrayType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__SensorHandleArrayType, 0, sizeof(emi__SensorHandleArrayType), 0, soap_copy_emi__SensorHandleArrayType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__SensorHandleArrayType * SOAP_FMAC6 soap_new_emi__SensorHandleArrayType(struct soap *soap, int n) +{ return soap_instantiate_emi__SensorHandleArrayType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__SensorHandleArrayType(struct soap *soap, emi__SensorHandleArrayType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__SensorHandleArrayType * SOAP_FMAC4 soap_instantiate_emi__SensorHandleArrayType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__SensorHandleArrayType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__SensorHandleArrayType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__SensorHandleArrayType; + if (size) + *size = sizeof(emi__SensorHandleArrayType); + ((emi__SensorHandleArrayType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__SensorHandleArrayType[n]; + if (size) + *size = n * sizeof(emi__SensorHandleArrayType); + for (int i = 0; i < n; i++) + ((emi__SensorHandleArrayType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__SensorHandleArrayType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__SensorHandleArrayType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__SensorHandleArrayType %p -> %p\n", q, p)); + *(emi__SensorHandleArrayType*)p = *(emi__SensorHandleArrayType*)q; +} + +void emi__EventLogRecordArrayType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerToemi__EventLogRecordType(soap, &((emi__EventLogRecordArrayType*)this)->EventLogRecord); + /* transient soap skipped */ +} + +void emi__EventLogRecordArrayType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfPointerToemi__EventLogRecordType(soap, &((emi__EventLogRecordArrayType*)this)->EventLogRecord); + /* transient soap skipped */ +} + +int emi__EventLogRecordArrayType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__EventLogRecordArrayType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__EventLogRecordArrayType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__EventLogRecordArrayType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventLogRecordArrayType(struct soap *soap, const char *tag, int id, const emi__EventLogRecordArrayType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__EventLogRecordArrayType), type); + soap_out_std__vectorTemplateOfPointerToemi__EventLogRecordType(soap, "emi:EventLogRecord", -1, &(((emi__EventLogRecordArrayType*)a)->EventLogRecord), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__EventLogRecordArrayType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__EventLogRecordArrayType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__EventLogRecordArrayType * SOAP_FMAC4 soap_get_emi__EventLogRecordArrayType(struct soap *soap, emi__EventLogRecordArrayType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__EventLogRecordArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__EventLogRecordArrayType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__EventLogRecordArrayType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__EventLogRecordArrayType * SOAP_FMAC4 soap_in_emi__EventLogRecordArrayType(struct soap *soap, const char *tag, emi__EventLogRecordArrayType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__EventLogRecordArrayType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__EventLogRecordArrayType, sizeof(emi__EventLogRecordArrayType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__EventLogRecordArrayType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__EventLogRecordArrayType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerToemi__EventLogRecordType(soap, "emi:EventLogRecord", &(((emi__EventLogRecordArrayType*)a)->EventLogRecord), "emi:EventLogRecordType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__EventLogRecordArrayType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__EventLogRecordArrayType, 0, sizeof(emi__EventLogRecordArrayType), 0, soap_copy_emi__EventLogRecordArrayType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__EventLogRecordArrayType * SOAP_FMAC6 soap_new_emi__EventLogRecordArrayType(struct soap *soap, int n) +{ return soap_instantiate_emi__EventLogRecordArrayType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__EventLogRecordArrayType(struct soap *soap, emi__EventLogRecordArrayType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__EventLogRecordArrayType * SOAP_FMAC4 soap_instantiate_emi__EventLogRecordArrayType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__EventLogRecordArrayType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__EventLogRecordArrayType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__EventLogRecordArrayType; + if (size) + *size = sizeof(emi__EventLogRecordArrayType); + ((emi__EventLogRecordArrayType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__EventLogRecordArrayType[n]; + if (size) + *size = n * sizeof(emi__EventLogRecordArrayType); + for (int i = 0; i < n; i++) + ((emi__EventLogRecordArrayType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__EventLogRecordArrayType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__EventLogRecordArrayType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__EventLogRecordArrayType %p -> %p\n", q, p)); + *(emi__EventLogRecordArrayType*)p = *(emi__EventLogRecordArrayType*)q; +} + +void emi__EventFilterHandleArrayType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfemi__EventFilterHandleType(soap, &((emi__EventFilterHandleArrayType*)this)->EventFilterHandle); + /* transient soap skipped */ +} + +void emi__EventFilterHandleArrayType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfemi__EventFilterHandleType(soap, &((emi__EventFilterHandleArrayType*)this)->EventFilterHandle); + /* transient soap skipped */ +} + +int emi__EventFilterHandleArrayType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__EventFilterHandleArrayType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__EventFilterHandleArrayType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__EventFilterHandleArrayType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventFilterHandleArrayType(struct soap *soap, const char *tag, int id, const emi__EventFilterHandleArrayType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__EventFilterHandleArrayType), type); + soap_out_std__vectorTemplateOfemi__EventFilterHandleType(soap, "emi:EventFilterHandle", -1, &(((emi__EventFilterHandleArrayType*)a)->EventFilterHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__EventFilterHandleArrayType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__EventFilterHandleArrayType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__EventFilterHandleArrayType * SOAP_FMAC4 soap_get_emi__EventFilterHandleArrayType(struct soap *soap, emi__EventFilterHandleArrayType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__EventFilterHandleArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__EventFilterHandleArrayType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__EventFilterHandleArrayType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__EventFilterHandleArrayType * SOAP_FMAC4 soap_in_emi__EventFilterHandleArrayType(struct soap *soap, const char *tag, emi__EventFilterHandleArrayType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__EventFilterHandleArrayType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__EventFilterHandleArrayType, sizeof(emi__EventFilterHandleArrayType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__EventFilterHandleArrayType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__EventFilterHandleArrayType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfemi__EventFilterHandleType(soap, "emi:EventFilterHandle", &(((emi__EventFilterHandleArrayType*)a)->EventFilterHandle), "emi:EventFilterHandleType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__EventFilterHandleArrayType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__EventFilterHandleArrayType, 0, sizeof(emi__EventFilterHandleArrayType), 0, soap_copy_emi__EventFilterHandleArrayType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__EventFilterHandleArrayType * SOAP_FMAC6 soap_new_emi__EventFilterHandleArrayType(struct soap *soap, int n) +{ return soap_instantiate_emi__EventFilterHandleArrayType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__EventFilterHandleArrayType(struct soap *soap, emi__EventFilterHandleArrayType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__EventFilterHandleArrayType * SOAP_FMAC4 soap_instantiate_emi__EventFilterHandleArrayType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__EventFilterHandleArrayType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__EventFilterHandleArrayType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__EventFilterHandleArrayType; + if (size) + *size = sizeof(emi__EventFilterHandleArrayType); + ((emi__EventFilterHandleArrayType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__EventFilterHandleArrayType[n]; + if (size) + *size = n * sizeof(emi__EventFilterHandleArrayType); + for (int i = 0; i < n; i++) + ((emi__EventFilterHandleArrayType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__EventFilterHandleArrayType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__EventFilterHandleArrayType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__EventFilterHandleArrayType %p -> %p\n", q, p)); + *(emi__EventFilterHandleArrayType*)p = *(emi__EventFilterHandleArrayType*)q; +} + +void emi__AlertSubscriptionHandleArrayType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, &((emi__AlertSubscriptionHandleArrayType*)this)->AlertSubscriptionHandle); + /* transient soap skipped */ +} + +void emi__AlertSubscriptionHandleArrayType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, &((emi__AlertSubscriptionHandleArrayType*)this)->AlertSubscriptionHandle); + /* transient soap skipped */ +} + +int emi__AlertSubscriptionHandleArrayType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__AlertSubscriptionHandleArrayType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__AlertSubscriptionHandleArrayType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__AlertSubscriptionHandleArrayType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionHandleArrayType(struct soap *soap, const char *tag, int id, const emi__AlertSubscriptionHandleArrayType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__AlertSubscriptionHandleArrayType), type); + soap_out_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, "emi:AlertSubscriptionHandle", -1, &(((emi__AlertSubscriptionHandleArrayType*)a)->AlertSubscriptionHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__AlertSubscriptionHandleArrayType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__AlertSubscriptionHandleArrayType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionHandleArrayType(struct soap *soap, emi__AlertSubscriptionHandleArrayType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertSubscriptionHandleArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__AlertSubscriptionHandleArrayType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__AlertSubscriptionHandleArrayType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionHandleArrayType(struct soap *soap, const char *tag, emi__AlertSubscriptionHandleArrayType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__AlertSubscriptionHandleArrayType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__AlertSubscriptionHandleArrayType, sizeof(emi__AlertSubscriptionHandleArrayType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__AlertSubscriptionHandleArrayType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__AlertSubscriptionHandleArrayType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, "emi:AlertSubscriptionHandle", &(((emi__AlertSubscriptionHandleArrayType*)a)->AlertSubscriptionHandle), "emi:AlertSubscriptionHandleType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__AlertSubscriptionHandleArrayType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__AlertSubscriptionHandleArrayType, 0, sizeof(emi__AlertSubscriptionHandleArrayType), 0, soap_copy_emi__AlertSubscriptionHandleArrayType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__AlertSubscriptionHandleArrayType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionHandleArrayType(struct soap *soap, int n) +{ return soap_instantiate_emi__AlertSubscriptionHandleArrayType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionHandleArrayType(struct soap *soap, emi__AlertSubscriptionHandleArrayType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionHandleArrayType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__AlertSubscriptionHandleArrayType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__AlertSubscriptionHandleArrayType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__AlertSubscriptionHandleArrayType; + if (size) + *size = sizeof(emi__AlertSubscriptionHandleArrayType); + ((emi__AlertSubscriptionHandleArrayType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__AlertSubscriptionHandleArrayType[n]; + if (size) + *size = n * sizeof(emi__AlertSubscriptionHandleArrayType); + for (int i = 0; i < n; i++) + ((emi__AlertSubscriptionHandleArrayType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__AlertSubscriptionHandleArrayType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionHandleArrayType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__AlertSubscriptionHandleArrayType %p -> %p\n", q, p)); + *(emi__AlertSubscriptionHandleArrayType*)p = *(emi__AlertSubscriptionHandleArrayType*)q; +} + +void emi__AlertSubscriptionType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((emi__AlertSubscriptionType*)this)->AlertSubscriptionPolicyID, SOAP_TYPE_emi__AlertSubscriptionPolicyIDType); + /* transient soap skipped */ +} + +void emi__AlertSubscriptionType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__AlertSubscriptionPolicyIDType(soap, &((emi__AlertSubscriptionType*)this)->AlertSubscriptionPolicyID); + soap_default_emi__IPv4AddressType(soap, &((emi__AlertSubscriptionType*)this)->DestinationAddress); + /* transient soap skipped */ +} + +int emi__AlertSubscriptionType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__AlertSubscriptionType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__AlertSubscriptionType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__AlertSubscriptionType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionType(struct soap *soap, const char *tag, int id, const emi__AlertSubscriptionType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__AlertSubscriptionType), type); + soap_out_emi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", -1, &(((emi__AlertSubscriptionType*)a)->AlertSubscriptionPolicyID), ""); + soap_out_emi__IPv4AddressType(soap, "emi:DestinationAddress", -1, &(((emi__AlertSubscriptionType*)a)->DestinationAddress), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__AlertSubscriptionType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__AlertSubscriptionType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionType(struct soap *soap, emi__AlertSubscriptionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertSubscriptionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__AlertSubscriptionType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__AlertSubscriptionType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionType(struct soap *soap, const char *tag, emi__AlertSubscriptionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__AlertSubscriptionType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__AlertSubscriptionType, sizeof(emi__AlertSubscriptionType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__AlertSubscriptionType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__AlertSubscriptionType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AlertSubscriptionPolicyID1 = 1, soap_flag_DestinationAddress1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AlertSubscriptionPolicyID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", &(((emi__AlertSubscriptionType*)a)->AlertSubscriptionPolicyID), "emi:AlertSubscriptionPolicyIDType")) + { soap_flag_AlertSubscriptionPolicyID1--; + continue; + } + if (soap_flag_DestinationAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__IPv4AddressType(soap, "emi:DestinationAddress", &(((emi__AlertSubscriptionType*)a)->DestinationAddress), "emi:IPv4AddressType")) + { soap_flag_DestinationAddress1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AlertSubscriptionPolicyID1 > 0 || soap_flag_DestinationAddress1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__AlertSubscriptionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__AlertSubscriptionType, 0, sizeof(emi__AlertSubscriptionType), 0, soap_copy_emi__AlertSubscriptionType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__AlertSubscriptionType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionType(struct soap *soap, int n) +{ return soap_instantiate_emi__AlertSubscriptionType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionType(struct soap *soap, emi__AlertSubscriptionType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__AlertSubscriptionType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__AlertSubscriptionType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__AlertSubscriptionType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__AlertSubscriptionType; + if (size) + *size = sizeof(emi__AlertSubscriptionType); + ((emi__AlertSubscriptionType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__AlertSubscriptionType[n]; + if (size) + *size = n * sizeof(emi__AlertSubscriptionType); + for (int i = 0; i < n; i++) + ((emi__AlertSubscriptionType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__AlertSubscriptionType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__AlertSubscriptionType %p -> %p\n", q, p)); + *(emi__AlertSubscriptionType*)p = *(emi__AlertSubscriptionType*)q; +} + +void emi__EventFilterType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((emi__EventFilterType*)this)->FilterConfiguration, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventFilterType*)this)->FilterAction, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventFilterType*)this)->AlertSubscriptionPolicyID, SOAP_TYPE_emi__AlertSubscriptionPolicyIDType); + soap_embedded(soap, &((emi__EventFilterType*)this)->DeviceAddress, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventFilterType*)this)->EventSensorType, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventFilterType*)this)->EventType, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventFilterType*)this)->EventOffset, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventFilterType*)this)->EventSourceType, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventFilterType*)this)->SensorNumber, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventFilterType*)this)->Entity, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventFilterType*)this)->EntityInstance, SOAP_TYPE_unsignedByte); + /* transient soap skipped */ +} + +void emi__EventFilterType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->FilterConfiguration); + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->FilterAction); + soap_default_emi__AlertSubscriptionPolicyIDType(soap, &((emi__EventFilterType*)this)->AlertSubscriptionPolicyID); + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->DeviceAddress); + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->EventSensorType); + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->EventType); + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->EventOffset); + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->EventSourceType); + soap_default_emi__EventSeverityType(soap, &((emi__EventFilterType*)this)->EventSeverity); + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->SensorNumber); + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->Entity); + soap_default_unsignedByte(soap, &((emi__EventFilterType*)this)->EntityInstance); + /* transient soap skipped */ +} + +int emi__EventFilterType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__EventFilterType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__EventFilterType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__EventFilterType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventFilterType(struct soap *soap, const char *tag, int id, const emi__EventFilterType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__EventFilterType), type); + soap_out_unsignedByte(soap, "emi:FilterConfiguration", -1, &(((emi__EventFilterType*)a)->FilterConfiguration), ""); + soap_out_unsignedByte(soap, "emi:FilterAction", -1, &(((emi__EventFilterType*)a)->FilterAction), ""); + soap_out_emi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", -1, &(((emi__EventFilterType*)a)->AlertSubscriptionPolicyID), ""); + soap_out_unsignedByte(soap, "emi:DeviceAddress", -1, &(((emi__EventFilterType*)a)->DeviceAddress), ""); + soap_out_unsignedByte(soap, "emi:EventSensorType", -1, &(((emi__EventFilterType*)a)->EventSensorType), ""); + soap_out_unsignedByte(soap, "emi:EventType", -1, &(((emi__EventFilterType*)a)->EventType), ""); + soap_out_unsignedByte(soap, "emi:EventOffset", -1, &(((emi__EventFilterType*)a)->EventOffset), ""); + soap_out_unsignedByte(soap, "emi:EventSourceType", -1, &(((emi__EventFilterType*)a)->EventSourceType), ""); + soap_out_emi__EventSeverityType(soap, "emi:EventSeverity", -1, &(((emi__EventFilterType*)a)->EventSeverity), ""); + soap_out_unsignedByte(soap, "emi:SensorNumber", -1, &(((emi__EventFilterType*)a)->SensorNumber), ""); + soap_out_unsignedByte(soap, "emi:Entity", -1, &(((emi__EventFilterType*)a)->Entity), ""); + soap_out_unsignedByte(soap, "emi:EntityInstance", -1, &(((emi__EventFilterType*)a)->EntityInstance), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__EventFilterType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__EventFilterType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__EventFilterType * SOAP_FMAC4 soap_get_emi__EventFilterType(struct soap *soap, emi__EventFilterType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__EventFilterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__EventFilterType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__EventFilterType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__EventFilterType * SOAP_FMAC4 soap_in_emi__EventFilterType(struct soap *soap, const char *tag, emi__EventFilterType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__EventFilterType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__EventFilterType, sizeof(emi__EventFilterType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__EventFilterType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__EventFilterType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_FilterConfiguration1 = 1, soap_flag_FilterAction1 = 1, soap_flag_AlertSubscriptionPolicyID1 = 1, soap_flag_DeviceAddress1 = 1, soap_flag_EventSensorType1 = 1, soap_flag_EventType1 = 1, soap_flag_EventOffset1 = 1, soap_flag_EventSourceType1 = 1, soap_flag_EventSeverity1 = 1, soap_flag_SensorNumber1 = 1, soap_flag_Entity1 = 1, soap_flag_EntityInstance1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_FilterConfiguration1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:FilterConfiguration", &(((emi__EventFilterType*)a)->FilterConfiguration), "xsd:unsignedByte")) + { soap_flag_FilterConfiguration1--; + continue; + } + if (soap_flag_FilterAction1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:FilterAction", &(((emi__EventFilterType*)a)->FilterAction), "xsd:unsignedByte")) + { soap_flag_FilterAction1--; + continue; + } + if (soap_flag_AlertSubscriptionPolicyID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", &(((emi__EventFilterType*)a)->AlertSubscriptionPolicyID), "emi:AlertSubscriptionPolicyIDType")) + { soap_flag_AlertSubscriptionPolicyID1--; + continue; + } + if (soap_flag_DeviceAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:DeviceAddress", &(((emi__EventFilterType*)a)->DeviceAddress), "xsd:unsignedByte")) + { soap_flag_DeviceAddress1--; + continue; + } + if (soap_flag_EventSensorType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventSensorType", &(((emi__EventFilterType*)a)->EventSensorType), "xsd:unsignedByte")) + { soap_flag_EventSensorType1--; + continue; + } + if (soap_flag_EventType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventType", &(((emi__EventFilterType*)a)->EventType), "xsd:unsignedByte")) + { soap_flag_EventType1--; + continue; + } + if (soap_flag_EventOffset1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventOffset", &(((emi__EventFilterType*)a)->EventOffset), "xsd:unsignedByte")) + { soap_flag_EventOffset1--; + continue; + } + if (soap_flag_EventSourceType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventSourceType", &(((emi__EventFilterType*)a)->EventSourceType), "xsd:unsignedByte")) + { soap_flag_EventSourceType1--; + continue; + } + if (soap_flag_EventSeverity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__EventSeverityType(soap, "emi:EventSeverity", &(((emi__EventFilterType*)a)->EventSeverity), "emi:EventSeverityType")) + { soap_flag_EventSeverity1--; + continue; + } + if (soap_flag_SensorNumber1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:SensorNumber", &(((emi__EventFilterType*)a)->SensorNumber), "xsd:unsignedByte")) + { soap_flag_SensorNumber1--; + continue; + } + if (soap_flag_Entity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:Entity", &(((emi__EventFilterType*)a)->Entity), "xsd:unsignedByte")) + { soap_flag_Entity1--; + continue; + } + if (soap_flag_EntityInstance1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EntityInstance", &(((emi__EventFilterType*)a)->EntityInstance), "xsd:unsignedByte")) + { soap_flag_EntityInstance1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_FilterConfiguration1 > 0 || soap_flag_FilterAction1 > 0 || soap_flag_AlertSubscriptionPolicyID1 > 0 || soap_flag_DeviceAddress1 > 0 || soap_flag_EventSensorType1 > 0 || soap_flag_EventType1 > 0 || soap_flag_EventOffset1 > 0 || soap_flag_EventSourceType1 > 0 || soap_flag_EventSeverity1 > 0 || soap_flag_SensorNumber1 > 0 || soap_flag_Entity1 > 0 || soap_flag_EntityInstance1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__EventFilterType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__EventFilterType, 0, sizeof(emi__EventFilterType), 0, soap_copy_emi__EventFilterType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__EventFilterType * SOAP_FMAC6 soap_new_emi__EventFilterType(struct soap *soap, int n) +{ return soap_instantiate_emi__EventFilterType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__EventFilterType(struct soap *soap, emi__EventFilterType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__EventFilterType * SOAP_FMAC4 soap_instantiate_emi__EventFilterType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__EventFilterType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__EventFilterType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__EventFilterType; + if (size) + *size = sizeof(emi__EventFilterType); + ((emi__EventFilterType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__EventFilterType[n]; + if (size) + *size = n * sizeof(emi__EventFilterType); + for (int i = 0; i < n; i++) + ((emi__EventFilterType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__EventFilterType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__EventFilterType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__EventFilterType %p -> %p\n", q, p)); + *(emi__EventFilterType*)p = *(emi__EventFilterType*)q; +} + +void emi__EventLogRecordType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((emi__EventLogRecordType*)this)->DeviceAddress, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventLogRecordType*)this)->EventSensorType, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventLogRecordType*)this)->EventType, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventLogRecordType*)this)->EventOffset, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventLogRecordType*)this)->EventSourceType, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventLogRecordType*)this)->SensorNumber, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventLogRecordType*)this)->Entity, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((emi__EventLogRecordType*)this)->EntityInstance, SOAP_TYPE_unsignedByte); + soap_serialize_PointerToemi__ByteData(soap, &((emi__EventLogRecordType*)this)->EventData); + /* transient soap skipped */ +} + +void emi__EventLogRecordType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_emi__TimeType(soap, &((emi__EventLogRecordType*)this)->TimeStamp); + soap_default_unsignedByte(soap, &((emi__EventLogRecordType*)this)->DeviceAddress); + soap_default_unsignedByte(soap, &((emi__EventLogRecordType*)this)->EventSensorType); + soap_default_unsignedByte(soap, &((emi__EventLogRecordType*)this)->EventType); + soap_default_unsignedByte(soap, &((emi__EventLogRecordType*)this)->EventOffset); + soap_default_unsignedByte(soap, &((emi__EventLogRecordType*)this)->EventSourceType); + soap_default_emi__EventSeverityType(soap, &((emi__EventLogRecordType*)this)->EventSeverity); + soap_default_unsignedByte(soap, &((emi__EventLogRecordType*)this)->SensorNumber); + soap_default_unsignedByte(soap, &((emi__EventLogRecordType*)this)->Entity); + soap_default_unsignedByte(soap, &((emi__EventLogRecordType*)this)->EntityInstance); + ((emi__EventLogRecordType*)this)->EventData = NULL; + /* transient soap skipped */ +} + +int emi__EventLogRecordType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__EventLogRecordType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__EventLogRecordType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__EventLogRecordType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__EventLogRecordType(struct soap *soap, const char *tag, int id, const emi__EventLogRecordType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__EventLogRecordType), type); + soap_out_emi__TimeType(soap, "emi:TimeStamp", -1, &(((emi__EventLogRecordType*)a)->TimeStamp), ""); + soap_out_unsignedByte(soap, "emi:DeviceAddress", -1, &(((emi__EventLogRecordType*)a)->DeviceAddress), ""); + soap_out_unsignedByte(soap, "emi:EventSensorType", -1, &(((emi__EventLogRecordType*)a)->EventSensorType), ""); + soap_out_unsignedByte(soap, "emi:EventType", -1, &(((emi__EventLogRecordType*)a)->EventType), ""); + soap_out_unsignedByte(soap, "emi:EventOffset", -1, &(((emi__EventLogRecordType*)a)->EventOffset), ""); + soap_out_unsignedByte(soap, "emi:EventSourceType", -1, &(((emi__EventLogRecordType*)a)->EventSourceType), ""); + soap_out_emi__EventSeverityType(soap, "emi:EventSeverity", -1, &(((emi__EventLogRecordType*)a)->EventSeverity), ""); + soap_out_unsignedByte(soap, "emi:SensorNumber", -1, &(((emi__EventLogRecordType*)a)->SensorNumber), ""); + soap_out_unsignedByte(soap, "emi:Entity", -1, &(((emi__EventLogRecordType*)a)->Entity), ""); + soap_out_unsignedByte(soap, "emi:EntityInstance", -1, &(((emi__EventLogRecordType*)a)->EntityInstance), ""); + soap_out_PointerToemi__ByteData(soap, "emi:EventData", -1, &(((emi__EventLogRecordType*)a)->EventData), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__EventLogRecordType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__EventLogRecordType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__EventLogRecordType * SOAP_FMAC4 soap_get_emi__EventLogRecordType(struct soap *soap, emi__EventLogRecordType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__EventLogRecordType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__EventLogRecordType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__EventLogRecordType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__EventLogRecordType * SOAP_FMAC4 soap_in_emi__EventLogRecordType(struct soap *soap, const char *tag, emi__EventLogRecordType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__EventLogRecordType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__EventLogRecordType, sizeof(emi__EventLogRecordType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__EventLogRecordType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__EventLogRecordType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_TimeStamp1 = 1, soap_flag_DeviceAddress1 = 1, soap_flag_EventSensorType1 = 1, soap_flag_EventType1 = 1, soap_flag_EventOffset1 = 1, soap_flag_EventSourceType1 = 1, soap_flag_EventSeverity1 = 1, soap_flag_SensorNumber1 = 1, soap_flag_Entity1 = 1, soap_flag_EntityInstance1 = 1, soap_flag_EventData1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_TimeStamp1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__TimeType(soap, "emi:TimeStamp", &(((emi__EventLogRecordType*)a)->TimeStamp), "emi:TimeType")) + { soap_flag_TimeStamp1--; + continue; + } + if (soap_flag_DeviceAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:DeviceAddress", &(((emi__EventLogRecordType*)a)->DeviceAddress), "xsd:unsignedByte")) + { soap_flag_DeviceAddress1--; + continue; + } + if (soap_flag_EventSensorType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventSensorType", &(((emi__EventLogRecordType*)a)->EventSensorType), "xsd:unsignedByte")) + { soap_flag_EventSensorType1--; + continue; + } + if (soap_flag_EventType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventType", &(((emi__EventLogRecordType*)a)->EventType), "xsd:unsignedByte")) + { soap_flag_EventType1--; + continue; + } + if (soap_flag_EventOffset1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventOffset", &(((emi__EventLogRecordType*)a)->EventOffset), "xsd:unsignedByte")) + { soap_flag_EventOffset1--; + continue; + } + if (soap_flag_EventSourceType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EventSourceType", &(((emi__EventLogRecordType*)a)->EventSourceType), "xsd:unsignedByte")) + { soap_flag_EventSourceType1--; + continue; + } + if (soap_flag_EventSeverity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_emi__EventSeverityType(soap, "emi:EventSeverity", &(((emi__EventLogRecordType*)a)->EventSeverity), "emi:EventSeverityType")) + { soap_flag_EventSeverity1--; + continue; + } + if (soap_flag_SensorNumber1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:SensorNumber", &(((emi__EventLogRecordType*)a)->SensorNumber), "xsd:unsignedByte")) + { soap_flag_SensorNumber1--; + continue; + } + if (soap_flag_Entity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:Entity", &(((emi__EventLogRecordType*)a)->Entity), "xsd:unsignedByte")) + { soap_flag_Entity1--; + continue; + } + if (soap_flag_EntityInstance1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "emi:EntityInstance", &(((emi__EventLogRecordType*)a)->EntityInstance), "xsd:unsignedByte")) + { soap_flag_EntityInstance1--; + continue; + } + if (soap_flag_EventData1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToemi__ByteData(soap, "emi:EventData", &(((emi__EventLogRecordType*)a)->EventData), "emi:ByteData")) + { soap_flag_EventData1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_TimeStamp1 > 0 || soap_flag_DeviceAddress1 > 0 || soap_flag_EventSensorType1 > 0 || soap_flag_EventType1 > 0 || soap_flag_EventOffset1 > 0 || soap_flag_EventSourceType1 > 0 || soap_flag_EventSeverity1 > 0 || soap_flag_SensorNumber1 > 0 || soap_flag_Entity1 > 0 || soap_flag_EntityInstance1 > 0 || soap_flag_EventData1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__EventLogRecordType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__EventLogRecordType, 0, sizeof(emi__EventLogRecordType), 0, soap_copy_emi__EventLogRecordType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__EventLogRecordType * SOAP_FMAC6 soap_new_emi__EventLogRecordType(struct soap *soap, int n) +{ return soap_instantiate_emi__EventLogRecordType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__EventLogRecordType(struct soap *soap, emi__EventLogRecordType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__EventLogRecordType * SOAP_FMAC4 soap_instantiate_emi__EventLogRecordType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__EventLogRecordType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__EventLogRecordType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__EventLogRecordType; + if (size) + *size = sizeof(emi__EventLogRecordType); + ((emi__EventLogRecordType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__EventLogRecordType[n]; + if (size) + *size = n * sizeof(emi__EventLogRecordType); + for (int i = 0; i < n; i++) + ((emi__EventLogRecordType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__EventLogRecordType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__EventLogRecordType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__EventLogRecordType %p -> %p\n", q, p)); + *(emi__EventLogRecordType*)p = *(emi__EventLogRecordType*)q; +} + +void emi__ByteData::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((emi__ByteData*)this)->Byte); + /* transient soap skipped */ +} + +void emi__ByteData::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfunsignedByte(soap, &((emi__ByteData*)this)->Byte); + /* transient soap skipped */ +} + +int emi__ByteData::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__ByteData); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__ByteData::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__ByteData(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__ByteData(struct soap *soap, const char *tag, int id, const emi__ByteData *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__ByteData), type); + soap_out_std__vectorTemplateOfunsignedByte(soap, "emi:Byte", -1, &(((emi__ByteData*)a)->Byte), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__ByteData::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__ByteData(soap, this, tag, type); +} + +SOAP_FMAC3 emi__ByteData * SOAP_FMAC4 soap_get_emi__ByteData(struct soap *soap, emi__ByteData *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__ByteData(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__ByteData::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__ByteData(soap, tag, this, type); +} + +SOAP_FMAC3 emi__ByteData * SOAP_FMAC4 soap_in_emi__ByteData(struct soap *soap, const char *tag, emi__ByteData *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__ByteData *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__ByteData, sizeof(emi__ByteData), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__ByteData) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__ByteData *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "emi:Byte", &(((emi__ByteData*)a)->Byte), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((emi__ByteData*)a)->Byte.size() < 8 || ((emi__ByteData*)a)->Byte.size() > 8)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__ByteData *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__ByteData, 0, sizeof(emi__ByteData), 0, soap_copy_emi__ByteData); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__ByteData * SOAP_FMAC6 soap_new_emi__ByteData(struct soap *soap, int n) +{ return soap_instantiate_emi__ByteData(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__ByteData(struct soap *soap, emi__ByteData *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__ByteData * SOAP_FMAC4 soap_instantiate_emi__ByteData(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__ByteData(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__ByteData, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__ByteData; + if (size) + *size = sizeof(emi__ByteData); + ((emi__ByteData*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__ByteData[n]; + if (size) + *size = n * sizeof(emi__ByteData); + for (int i = 0; i < n; i++) + ((emi__ByteData*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__ByteData*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__ByteData(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__ByteData %p -> %p\n", q, p)); + *(emi__ByteData*)p = *(emi__ByteData*)q; +} + +void emi__AlertSubscriptionPolicyIDArrayType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(soap, &((emi__AlertSubscriptionPolicyIDArrayType*)this)->AlertSubscriptionPolicyID); + /* transient soap skipped */ +} + +void emi__AlertSubscriptionPolicyIDArrayType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(soap, &((emi__AlertSubscriptionPolicyIDArrayType*)this)->AlertSubscriptionPolicyID); + /* transient soap skipped */ +} + +int emi__AlertSubscriptionPolicyIDArrayType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int emi__AlertSubscriptionPolicyIDArrayType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_emi__AlertSubscriptionPolicyIDArrayType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_emi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, const char *tag, int id, const emi__AlertSubscriptionPolicyIDArrayType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType), type); + soap_out_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", -1, &(((emi__AlertSubscriptionPolicyIDArrayType*)a)->AlertSubscriptionPolicyID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *emi__AlertSubscriptionPolicyIDArrayType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_emi__AlertSubscriptionPolicyIDArrayType(soap, this, tag, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType * SOAP_FMAC4 soap_get_emi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, emi__AlertSubscriptionPolicyIDArrayType *p, const char *tag, const char *type) +{ + if ((p = soap_in_emi__AlertSubscriptionPolicyIDArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *emi__AlertSubscriptionPolicyIDArrayType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_emi__AlertSubscriptionPolicyIDArrayType(soap, tag, this, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType * SOAP_FMAC4 soap_in_emi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, const char *tag, emi__AlertSubscriptionPolicyIDArrayType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (emi__AlertSubscriptionPolicyIDArrayType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType, sizeof(emi__AlertSubscriptionPolicyIDArrayType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType) + { soap_revert(soap); + *soap->id = '\0'; + return (emi__AlertSubscriptionPolicyIDArrayType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(soap, "emi:AlertSubscriptionPolicyID", &(((emi__AlertSubscriptionPolicyIDArrayType*)a)->AlertSubscriptionPolicyID), "emi:AlertSubscriptionPolicyIDType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (emi__AlertSubscriptionPolicyIDArrayType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType, 0, sizeof(emi__AlertSubscriptionPolicyIDArrayType), 0, soap_copy_emi__AlertSubscriptionPolicyIDArrayType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 emi__AlertSubscriptionPolicyIDArrayType * SOAP_FMAC6 soap_new_emi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, int n) +{ return soap_instantiate_emi__AlertSubscriptionPolicyIDArrayType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_emi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, emi__AlertSubscriptionPolicyIDArrayType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType * SOAP_FMAC4 soap_instantiate_emi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_emi__AlertSubscriptionPolicyIDArrayType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new emi__AlertSubscriptionPolicyIDArrayType; + if (size) + *size = sizeof(emi__AlertSubscriptionPolicyIDArrayType); + ((emi__AlertSubscriptionPolicyIDArrayType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new emi__AlertSubscriptionPolicyIDArrayType[n]; + if (size) + *size = n * sizeof(emi__AlertSubscriptionPolicyIDArrayType); + for (int i = 0; i < n; i++) + ((emi__AlertSubscriptionPolicyIDArrayType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (emi__AlertSubscriptionPolicyIDArrayType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_emi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying emi__AlertSubscriptionPolicyIDArrayType %p -> %p\n", q, p)); + *(emi__AlertSubscriptionPolicyIDArrayType*)p = *(emi__AlertSubscriptionPolicyIDArrayType*)q; +} + +void _stra__RemoveStorageFpaclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__RemoveStorageFpaclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__RemoveStorageFpaclEntryResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _stra__RemoveStorageFpaclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__RemoveStorageFpaclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__RemoveStorageFpaclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__RemoveStorageFpaclEntryResponse(struct soap *soap, const char *tag, int id, const _stra__RemoveStorageFpaclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__RemoveStorageFpaclEntryResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__RemoveStorageFpaclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__RemoveStorageFpaclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse * SOAP_FMAC4 soap_get__stra__RemoveStorageFpaclEntryResponse(struct soap *soap, _stra__RemoveStorageFpaclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__RemoveStorageFpaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__RemoveStorageFpaclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__RemoveStorageFpaclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse * SOAP_FMAC4 soap_in__stra__RemoveStorageFpaclEntryResponse(struct soap *soap, const char *tag, _stra__RemoveStorageFpaclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__RemoveStorageFpaclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse, sizeof(_stra__RemoveStorageFpaclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__RemoveStorageFpaclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__RemoveStorageFpaclEntryResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__RemoveStorageFpaclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse, 0, sizeof(_stra__RemoveStorageFpaclEntryResponse), 0, soap_copy__stra__RemoveStorageFpaclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__RemoveStorageFpaclEntryResponse * SOAP_FMAC6 soap_new__stra__RemoveStorageFpaclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__RemoveStorageFpaclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__RemoveStorageFpaclEntryResponse(struct soap *soap, _stra__RemoveStorageFpaclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__RemoveStorageFpaclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__RemoveStorageFpaclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__RemoveStorageFpaclEntryResponse; + if (size) + *size = sizeof(_stra__RemoveStorageFpaclEntryResponse); + ((_stra__RemoveStorageFpaclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__RemoveStorageFpaclEntryResponse[n]; + if (size) + *size = n * sizeof(_stra__RemoveStorageFpaclEntryResponse); + for (int i = 0; i < n; i++) + ((_stra__RemoveStorageFpaclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__RemoveStorageFpaclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__RemoveStorageFpaclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__RemoveStorageFpaclEntryResponse %p -> %p\n", q, p)); + *(_stra__RemoveStorageFpaclEntryResponse*)p = *(_stra__RemoveStorageFpaclEntryResponse*)q; +} + +void _stra__RemoveStorageFpaclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__RemoveStorageFpaclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__StorageAllocEntryHandleType(soap, &((_stra__RemoveStorageFpaclEntry*)this)->Handle); + /* transient soap skipped */ +} + +int _stra__RemoveStorageFpaclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__RemoveStorageFpaclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__RemoveStorageFpaclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__RemoveStorageFpaclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__RemoveStorageFpaclEntry(struct soap *soap, const char *tag, int id, const _stra__RemoveStorageFpaclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__RemoveStorageFpaclEntry), type); + soap_out_stra__StorageAllocEntryHandleType(soap, "stra:Handle", -1, &(((_stra__RemoveStorageFpaclEntry*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__RemoveStorageFpaclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__RemoveStorageFpaclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_get__stra__RemoveStorageFpaclEntry(struct soap *soap, _stra__RemoveStorageFpaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__RemoveStorageFpaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__RemoveStorageFpaclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__RemoveStorageFpaclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_in__stra__RemoveStorageFpaclEntry(struct soap *soap, const char *tag, _stra__RemoveStorageFpaclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__RemoveStorageFpaclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__RemoveStorageFpaclEntry, sizeof(_stra__RemoveStorageFpaclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__RemoveStorageFpaclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__RemoveStorageFpaclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__StorageAllocEntryHandleType(soap, "stra:Handle", &(((_stra__RemoveStorageFpaclEntry*)a)->Handle), "stra:StorageAllocEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__RemoveStorageFpaclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__RemoveStorageFpaclEntry, 0, sizeof(_stra__RemoveStorageFpaclEntry), 0, soap_copy__stra__RemoveStorageFpaclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__RemoveStorageFpaclEntry * SOAP_FMAC6 soap_new__stra__RemoveStorageFpaclEntry(struct soap *soap, int n) +{ return soap_instantiate__stra__RemoveStorageFpaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__RemoveStorageFpaclEntry(struct soap *soap, _stra__RemoveStorageFpaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_instantiate__stra__RemoveStorageFpaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__RemoveStorageFpaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__RemoveStorageFpaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__RemoveStorageFpaclEntry; + if (size) + *size = sizeof(_stra__RemoveStorageFpaclEntry); + ((_stra__RemoveStorageFpaclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__RemoveStorageFpaclEntry[n]; + if (size) + *size = n * sizeof(_stra__RemoveStorageFpaclEntry); + for (int i = 0; i < n; i++) + ((_stra__RemoveStorageFpaclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__RemoveStorageFpaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__RemoveStorageFpaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__RemoveStorageFpaclEntry %p -> %p\n", q, p)); + *(_stra__RemoveStorageFpaclEntry*)p = *(_stra__RemoveStorageFpaclEntry*)q; +} + +void _stra__UpdateStorageFpaclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__UpdateStorageFpaclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__UpdateStorageFpaclEntryResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _stra__UpdateStorageFpaclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__UpdateStorageFpaclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__UpdateStorageFpaclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__UpdateStorageFpaclEntryResponse(struct soap *soap, const char *tag, int id, const _stra__UpdateStorageFpaclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__UpdateStorageFpaclEntryResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__UpdateStorageFpaclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__UpdateStorageFpaclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse * SOAP_FMAC4 soap_get__stra__UpdateStorageFpaclEntryResponse(struct soap *soap, _stra__UpdateStorageFpaclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__UpdateStorageFpaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__UpdateStorageFpaclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__UpdateStorageFpaclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse * SOAP_FMAC4 soap_in__stra__UpdateStorageFpaclEntryResponse(struct soap *soap, const char *tag, _stra__UpdateStorageFpaclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__UpdateStorageFpaclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse, sizeof(_stra__UpdateStorageFpaclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__UpdateStorageFpaclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__UpdateStorageFpaclEntryResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__UpdateStorageFpaclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse, 0, sizeof(_stra__UpdateStorageFpaclEntryResponse), 0, soap_copy__stra__UpdateStorageFpaclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__UpdateStorageFpaclEntryResponse * SOAP_FMAC6 soap_new__stra__UpdateStorageFpaclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__UpdateStorageFpaclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__UpdateStorageFpaclEntryResponse(struct soap *soap, _stra__UpdateStorageFpaclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__UpdateStorageFpaclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__UpdateStorageFpaclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__UpdateStorageFpaclEntryResponse; + if (size) + *size = sizeof(_stra__UpdateStorageFpaclEntryResponse); + ((_stra__UpdateStorageFpaclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__UpdateStorageFpaclEntryResponse[n]; + if (size) + *size = n * sizeof(_stra__UpdateStorageFpaclEntryResponse); + for (int i = 0; i < n; i++) + ((_stra__UpdateStorageFpaclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__UpdateStorageFpaclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__UpdateStorageFpaclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__UpdateStorageFpaclEntryResponse %p -> %p\n", q, p)); + *(_stra__UpdateStorageFpaclEntryResponse*)p = *(_stra__UpdateStorageFpaclEntryResponse*)q; +} + +void _stra__UpdateStorageFpaclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_stra__UpdateStorageFpaclEntry*)this)->NewAllocationSize, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _stra__UpdateStorageFpaclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__StorageAllocEntryHandleType(soap, &((_stra__UpdateStorageFpaclEntry*)this)->Handle); + soap_default_unsignedInt(soap, &((_stra__UpdateStorageFpaclEntry*)this)->NewAllocationSize); + /* transient soap skipped */ +} + +int _stra__UpdateStorageFpaclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__UpdateStorageFpaclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__UpdateStorageFpaclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__UpdateStorageFpaclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__UpdateStorageFpaclEntry(struct soap *soap, const char *tag, int id, const _stra__UpdateStorageFpaclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__UpdateStorageFpaclEntry), type); + soap_out_stra__StorageAllocEntryHandleType(soap, "stra:Handle", -1, &(((_stra__UpdateStorageFpaclEntry*)a)->Handle), ""); + soap_out_unsignedInt(soap, "stra:NewAllocationSize", -1, &(((_stra__UpdateStorageFpaclEntry*)a)->NewAllocationSize), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__UpdateStorageFpaclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__UpdateStorageFpaclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_get__stra__UpdateStorageFpaclEntry(struct soap *soap, _stra__UpdateStorageFpaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__UpdateStorageFpaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__UpdateStorageFpaclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__UpdateStorageFpaclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_in__stra__UpdateStorageFpaclEntry(struct soap *soap, const char *tag, _stra__UpdateStorageFpaclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__UpdateStorageFpaclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__UpdateStorageFpaclEntry, sizeof(_stra__UpdateStorageFpaclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__UpdateStorageFpaclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__UpdateStorageFpaclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1, soap_flag_NewAllocationSize1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__StorageAllocEntryHandleType(soap, "stra:Handle", &(((_stra__UpdateStorageFpaclEntry*)a)->Handle), "stra:StorageAllocEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + if (soap_flag_NewAllocationSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:NewAllocationSize", &(((_stra__UpdateStorageFpaclEntry*)a)->NewAllocationSize), "xsd:unsignedInt")) + { soap_flag_NewAllocationSize1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0 || soap_flag_NewAllocationSize1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__UpdateStorageFpaclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__UpdateStorageFpaclEntry, 0, sizeof(_stra__UpdateStorageFpaclEntry), 0, soap_copy__stra__UpdateStorageFpaclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__UpdateStorageFpaclEntry * SOAP_FMAC6 soap_new__stra__UpdateStorageFpaclEntry(struct soap *soap, int n) +{ return soap_instantiate__stra__UpdateStorageFpaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__UpdateStorageFpaclEntry(struct soap *soap, _stra__UpdateStorageFpaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_instantiate__stra__UpdateStorageFpaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__UpdateStorageFpaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__UpdateStorageFpaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__UpdateStorageFpaclEntry; + if (size) + *size = sizeof(_stra__UpdateStorageFpaclEntry); + ((_stra__UpdateStorageFpaclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__UpdateStorageFpaclEntry[n]; + if (size) + *size = n * sizeof(_stra__UpdateStorageFpaclEntry); + for (int i = 0; i < n; i++) + ((_stra__UpdateStorageFpaclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__UpdateStorageFpaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__UpdateStorageFpaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__UpdateStorageFpaclEntry %p -> %p\n", q, p)); + *(_stra__UpdateStorageFpaclEntry*)p = *(_stra__UpdateStorageFpaclEntry*)q; +} + +void _stra__GetStorageAllocEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostra__StorageAllocEntryType(soap, &((_stra__GetStorageAllocEntryResponse*)this)->Entry); + /* transient soap skipped */ +} + +void _stra__GetStorageAllocEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__GetStorageAllocEntryResponse*)this)->StatusCode); + ((_stra__GetStorageAllocEntryResponse*)this)->Entry = NULL; + /* transient soap skipped */ +} + +int _stra__GetStorageAllocEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__GetStorageAllocEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__GetStorageAllocEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__GetStorageAllocEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetStorageAllocEntryResponse(struct soap *soap, const char *tag, int id, const _stra__GetStorageAllocEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__GetStorageAllocEntryResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__GetStorageAllocEntryResponse*)a)->StatusCode), ""); + soap_out_PointerTostra__StorageAllocEntryType(soap, "stra:Entry", -1, &(((_stra__GetStorageAllocEntryResponse*)a)->Entry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__GetStorageAllocEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__GetStorageAllocEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse * SOAP_FMAC4 soap_get__stra__GetStorageAllocEntryResponse(struct soap *soap, _stra__GetStorageAllocEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__GetStorageAllocEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__GetStorageAllocEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__GetStorageAllocEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse * SOAP_FMAC4 soap_in__stra__GetStorageAllocEntryResponse(struct soap *soap, const char *tag, _stra__GetStorageAllocEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__GetStorageAllocEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__GetStorageAllocEntryResponse, sizeof(_stra__GetStorageAllocEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__GetStorageAllocEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__GetStorageAllocEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Entry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__GetStorageAllocEntryResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Entry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageAllocEntryType(soap, "stra:Entry", &(((_stra__GetStorageAllocEntryResponse*)a)->Entry), "stra:StorageAllocEntryType")) + { soap_flag_Entry1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Entry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__GetStorageAllocEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__GetStorageAllocEntryResponse, 0, sizeof(_stra__GetStorageAllocEntryResponse), 0, soap_copy__stra__GetStorageAllocEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__GetStorageAllocEntryResponse * SOAP_FMAC6 soap_new__stra__GetStorageAllocEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__GetStorageAllocEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetStorageAllocEntryResponse(struct soap *soap, _stra__GetStorageAllocEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse * SOAP_FMAC4 soap_instantiate__stra__GetStorageAllocEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__GetStorageAllocEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__GetStorageAllocEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__GetStorageAllocEntryResponse; + if (size) + *size = sizeof(_stra__GetStorageAllocEntryResponse); + ((_stra__GetStorageAllocEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__GetStorageAllocEntryResponse[n]; + if (size) + *size = n * sizeof(_stra__GetStorageAllocEntryResponse); + for (int i = 0; i < n; i++) + ((_stra__GetStorageAllocEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__GetStorageAllocEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetStorageAllocEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__GetStorageAllocEntryResponse %p -> %p\n", q, p)); + *(_stra__GetStorageAllocEntryResponse*)p = *(_stra__GetStorageAllocEntryResponse*)q; +} + +void _stra__GetStorageAllocEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__GetStorageAllocEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__StorageAllocEntryHandleType(soap, &((_stra__GetStorageAllocEntry*)this)->Handle); + /* transient soap skipped */ +} + +int _stra__GetStorageAllocEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__GetStorageAllocEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__GetStorageAllocEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__GetStorageAllocEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetStorageAllocEntry(struct soap *soap, const char *tag, int id, const _stra__GetStorageAllocEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__GetStorageAllocEntry), type); + soap_out_stra__StorageAllocEntryHandleType(soap, "stra:Handle", -1, &(((_stra__GetStorageAllocEntry*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__GetStorageAllocEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__GetStorageAllocEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__GetStorageAllocEntry * SOAP_FMAC4 soap_get__stra__GetStorageAllocEntry(struct soap *soap, _stra__GetStorageAllocEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__GetStorageAllocEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__GetStorageAllocEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__GetStorageAllocEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__GetStorageAllocEntry * SOAP_FMAC4 soap_in__stra__GetStorageAllocEntry(struct soap *soap, const char *tag, _stra__GetStorageAllocEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__GetStorageAllocEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__GetStorageAllocEntry, sizeof(_stra__GetStorageAllocEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__GetStorageAllocEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__GetStorageAllocEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__StorageAllocEntryHandleType(soap, "stra:Handle", &(((_stra__GetStorageAllocEntry*)a)->Handle), "stra:StorageAllocEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__GetStorageAllocEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__GetStorageAllocEntry, 0, sizeof(_stra__GetStorageAllocEntry), 0, soap_copy__stra__GetStorageAllocEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__GetStorageAllocEntry * SOAP_FMAC6 soap_new__stra__GetStorageAllocEntry(struct soap *soap, int n) +{ return soap_instantiate__stra__GetStorageAllocEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetStorageAllocEntry(struct soap *soap, _stra__GetStorageAllocEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__GetStorageAllocEntry * SOAP_FMAC4 soap_instantiate__stra__GetStorageAllocEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__GetStorageAllocEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__GetStorageAllocEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__GetStorageAllocEntry; + if (size) + *size = sizeof(_stra__GetStorageAllocEntry); + ((_stra__GetStorageAllocEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__GetStorageAllocEntry[n]; + if (size) + *size = n * sizeof(_stra__GetStorageAllocEntry); + for (int i = 0; i < n; i++) + ((_stra__GetStorageAllocEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__GetStorageAllocEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetStorageAllocEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__GetStorageAllocEntry %p -> %p\n", q, p)); + *(_stra__GetStorageAllocEntry*)p = *(_stra__GetStorageAllocEntry*)q; +} + +void _stra__EnumerateStorageAllocEntriesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_stra__EnumerateStorageAllocEntriesResponse*)this)->TotalCount, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((_stra__EnumerateStorageAllocEntriesResponse*)this)->HandlesCount, SOAP_TYPE_unsignedShort); + soap_serialize_PointerTostra__StorageAllocEntryHandleListType(soap, &((_stra__EnumerateStorageAllocEntriesResponse*)this)->Handles); + /* transient soap skipped */ +} + +void _stra__EnumerateStorageAllocEntriesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__EnumerateStorageAllocEntriesResponse*)this)->StatusCode); + soap_default_unsignedShort(soap, &((_stra__EnumerateStorageAllocEntriesResponse*)this)->TotalCount); + soap_default_unsignedShort(soap, &((_stra__EnumerateStorageAllocEntriesResponse*)this)->HandlesCount); + ((_stra__EnumerateStorageAllocEntriesResponse*)this)->Handles = NULL; + /* transient soap skipped */ +} + +int _stra__EnumerateStorageAllocEntriesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__EnumerateStorageAllocEntriesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__EnumerateStorageAllocEntriesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, const char *tag, int id, const _stra__EnumerateStorageAllocEntriesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__EnumerateStorageAllocEntriesResponse*)a)->StatusCode), ""); + soap_out_unsignedShort(soap, "stra:TotalCount", -1, &(((_stra__EnumerateStorageAllocEntriesResponse*)a)->TotalCount), ""); + soap_out_unsignedShort(soap, "stra:HandlesCount", -1, &(((_stra__EnumerateStorageAllocEntriesResponse*)a)->HandlesCount), ""); + soap_out_PointerTostra__StorageAllocEntryHandleListType(soap, "stra:Handles", -1, &(((_stra__EnumerateStorageAllocEntriesResponse*)a)->Handles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__EnumerateStorageAllocEntriesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__EnumerateStorageAllocEntriesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse * SOAP_FMAC4 soap_get__stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, _stra__EnumerateStorageAllocEntriesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__EnumerateStorageAllocEntriesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__EnumerateStorageAllocEntriesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__EnumerateStorageAllocEntriesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse * SOAP_FMAC4 soap_in__stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, const char *tag, _stra__EnumerateStorageAllocEntriesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__EnumerateStorageAllocEntriesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse, sizeof(_stra__EnumerateStorageAllocEntriesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__EnumerateStorageAllocEntriesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_TotalCount1 = 1, soap_flag_HandlesCount1 = 1, soap_flag_Handles1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__EnumerateStorageAllocEntriesResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_TotalCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:TotalCount", &(((_stra__EnumerateStorageAllocEntriesResponse*)a)->TotalCount), "xsd:unsignedShort")) + { soap_flag_TotalCount1--; + continue; + } + if (soap_flag_HandlesCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:HandlesCount", &(((_stra__EnumerateStorageAllocEntriesResponse*)a)->HandlesCount), "xsd:unsignedShort")) + { soap_flag_HandlesCount1--; + continue; + } + if (soap_flag_Handles1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageAllocEntryHandleListType(soap, "stra:Handles", &(((_stra__EnumerateStorageAllocEntriesResponse*)a)->Handles), "stra:StorageAllocEntryHandleListType")) + { soap_flag_Handles1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_TotalCount1 > 0 || soap_flag_HandlesCount1 > 0 || soap_flag_Handles1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__EnumerateStorageAllocEntriesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse, 0, sizeof(_stra__EnumerateStorageAllocEntriesResponse), 0, soap_copy__stra__EnumerateStorageAllocEntriesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__EnumerateStorageAllocEntriesResponse * SOAP_FMAC6 soap_new__stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__EnumerateStorageAllocEntriesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, _stra__EnumerateStorageAllocEntriesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse * SOAP_FMAC4 soap_instantiate__stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__EnumerateStorageAllocEntriesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__EnumerateStorageAllocEntriesResponse; + if (size) + *size = sizeof(_stra__EnumerateStorageAllocEntriesResponse); + ((_stra__EnumerateStorageAllocEntriesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__EnumerateStorageAllocEntriesResponse[n]; + if (size) + *size = n * sizeof(_stra__EnumerateStorageAllocEntriesResponse); + for (int i = 0; i < n; i++) + ((_stra__EnumerateStorageAllocEntriesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__EnumerateStorageAllocEntriesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__EnumerateStorageAllocEntriesResponse %p -> %p\n", q, p)); + *(_stra__EnumerateStorageAllocEntriesResponse*)p = *(_stra__EnumerateStorageAllocEntriesResponse*)q; +} + +void _stra__EnumerateStorageAllocEntries::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_stra__EnumerateStorageAllocEntries*)this)->StartIndex, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void _stra__EnumerateStorageAllocEntries::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedShort(soap, &((_stra__EnumerateStorageAllocEntries*)this)->StartIndex); + /* transient soap skipped */ +} + +int _stra__EnumerateStorageAllocEntries::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__EnumerateStorageAllocEntries); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__EnumerateStorageAllocEntries::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__EnumerateStorageAllocEntries(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__EnumerateStorageAllocEntries(struct soap *soap, const char *tag, int id, const _stra__EnumerateStorageAllocEntries *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__EnumerateStorageAllocEntries), type); + soap_out_unsignedShort(soap, "stra:StartIndex", -1, &(((_stra__EnumerateStorageAllocEntries*)a)->StartIndex), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__EnumerateStorageAllocEntries::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__EnumerateStorageAllocEntries(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_get__stra__EnumerateStorageAllocEntries(struct soap *soap, _stra__EnumerateStorageAllocEntries *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__EnumerateStorageAllocEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__EnumerateStorageAllocEntries::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__EnumerateStorageAllocEntries(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_in__stra__EnumerateStorageAllocEntries(struct soap *soap, const char *tag, _stra__EnumerateStorageAllocEntries *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__EnumerateStorageAllocEntries *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__EnumerateStorageAllocEntries, sizeof(_stra__EnumerateStorageAllocEntries), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__EnumerateStorageAllocEntries) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__EnumerateStorageAllocEntries *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StartIndex1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StartIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:StartIndex", &(((_stra__EnumerateStorageAllocEntries*)a)->StartIndex), "xsd:unsignedShort")) + { soap_flag_StartIndex1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StartIndex1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__EnumerateStorageAllocEntries *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__EnumerateStorageAllocEntries, 0, sizeof(_stra__EnumerateStorageAllocEntries), 0, soap_copy__stra__EnumerateStorageAllocEntries); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__EnumerateStorageAllocEntries * SOAP_FMAC6 soap_new__stra__EnumerateStorageAllocEntries(struct soap *soap, int n) +{ return soap_instantiate__stra__EnumerateStorageAllocEntries(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__EnumerateStorageAllocEntries(struct soap *soap, _stra__EnumerateStorageAllocEntries *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_instantiate__stra__EnumerateStorageAllocEntries(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__EnumerateStorageAllocEntries(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__EnumerateStorageAllocEntries, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__EnumerateStorageAllocEntries; + if (size) + *size = sizeof(_stra__EnumerateStorageAllocEntries); + ((_stra__EnumerateStorageAllocEntries*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__EnumerateStorageAllocEntries[n]; + if (size) + *size = n * sizeof(_stra__EnumerateStorageAllocEntries); + for (int i = 0; i < n; i++) + ((_stra__EnumerateStorageAllocEntries*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__EnumerateStorageAllocEntries*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__EnumerateStorageAllocEntries(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__EnumerateStorageAllocEntries %p -> %p\n", q, p)); + *(_stra__EnumerateStorageAllocEntries*)p = *(_stra__EnumerateStorageAllocEntries*)q; +} + +void _stra__AddStorageFpaclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__AddStorageFpaclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__AddStorageFpaclEntryResponse*)this)->StatusCode); + soap_default_stra__StorageAllocEntryHandleType(soap, &((_stra__AddStorageFpaclEntryResponse*)this)->Handle); + /* transient soap skipped */ +} + +int _stra__AddStorageFpaclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AddStorageFpaclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AddStorageFpaclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AddStorageFpaclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AddStorageFpaclEntryResponse(struct soap *soap, const char *tag, int id, const _stra__AddStorageFpaclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AddStorageFpaclEntryResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__AddStorageFpaclEntryResponse*)a)->StatusCode), ""); + soap_out_stra__StorageAllocEntryHandleType(soap, "stra:Handle", -1, &(((_stra__AddStorageFpaclEntryResponse*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AddStorageFpaclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AddStorageFpaclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse * SOAP_FMAC4 soap_get__stra__AddStorageFpaclEntryResponse(struct soap *soap, _stra__AddStorageFpaclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AddStorageFpaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AddStorageFpaclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AddStorageFpaclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse * SOAP_FMAC4 soap_in__stra__AddStorageFpaclEntryResponse(struct soap *soap, const char *tag, _stra__AddStorageFpaclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AddStorageFpaclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AddStorageFpaclEntryResponse, sizeof(_stra__AddStorageFpaclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AddStorageFpaclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AddStorageFpaclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__AddStorageFpaclEntryResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__StorageAllocEntryHandleType(soap, "stra:Handle", &(((_stra__AddStorageFpaclEntryResponse*)a)->Handle), "stra:StorageAllocEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AddStorageFpaclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AddStorageFpaclEntryResponse, 0, sizeof(_stra__AddStorageFpaclEntryResponse), 0, soap_copy__stra__AddStorageFpaclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AddStorageFpaclEntryResponse * SOAP_FMAC6 soap_new__stra__AddStorageFpaclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__AddStorageFpaclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AddStorageFpaclEntryResponse(struct soap *soap, _stra__AddStorageFpaclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__AddStorageFpaclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AddStorageFpaclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AddStorageFpaclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AddStorageFpaclEntryResponse; + if (size) + *size = sizeof(_stra__AddStorageFpaclEntryResponse); + ((_stra__AddStorageFpaclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AddStorageFpaclEntryResponse[n]; + if (size) + *size = n * sizeof(_stra__AddStorageFpaclEntryResponse); + for (int i = 0; i < n; i++) + ((_stra__AddStorageFpaclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AddStorageFpaclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AddStorageFpaclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AddStorageFpaclEntryResponse %p -> %p\n", q, p)); + *(_stra__AddStorageFpaclEntryResponse*)p = *(_stra__AddStorageFpaclEntryResponse*)q; +} + +void _stra__AddStorageFpaclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostra__StorageAllocEntryType(soap, &((_stra__AddStorageFpaclEntry*)this)->Entry); + /* transient soap skipped */ +} + +void _stra__AddStorageFpaclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_stra__AddStorageFpaclEntry*)this)->Entry = NULL; + /* transient soap skipped */ +} + +int _stra__AddStorageFpaclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AddStorageFpaclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AddStorageFpaclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AddStorageFpaclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AddStorageFpaclEntry(struct soap *soap, const char *tag, int id, const _stra__AddStorageFpaclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AddStorageFpaclEntry), type); + soap_out_PointerTostra__StorageAllocEntryType(soap, "stra:Entry", -1, &(((_stra__AddStorageFpaclEntry*)a)->Entry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AddStorageFpaclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AddStorageFpaclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_get__stra__AddStorageFpaclEntry(struct soap *soap, _stra__AddStorageFpaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AddStorageFpaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AddStorageFpaclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AddStorageFpaclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_in__stra__AddStorageFpaclEntry(struct soap *soap, const char *tag, _stra__AddStorageFpaclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AddStorageFpaclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AddStorageFpaclEntry, sizeof(_stra__AddStorageFpaclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AddStorageFpaclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AddStorageFpaclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Entry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Entry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageAllocEntryType(soap, "stra:Entry", &(((_stra__AddStorageFpaclEntry*)a)->Entry), "stra:StorageAllocEntryType")) + { soap_flag_Entry1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Entry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AddStorageFpaclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AddStorageFpaclEntry, 0, sizeof(_stra__AddStorageFpaclEntry), 0, soap_copy__stra__AddStorageFpaclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AddStorageFpaclEntry * SOAP_FMAC6 soap_new__stra__AddStorageFpaclEntry(struct soap *soap, int n) +{ return soap_instantiate__stra__AddStorageFpaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AddStorageFpaclEntry(struct soap *soap, _stra__AddStorageFpaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_instantiate__stra__AddStorageFpaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AddStorageFpaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AddStorageFpaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AddStorageFpaclEntry; + if (size) + *size = sizeof(_stra__AddStorageFpaclEntry); + ((_stra__AddStorageFpaclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AddStorageFpaclEntry[n]; + if (size) + *size = n * sizeof(_stra__AddStorageFpaclEntry); + for (int i = 0; i < n; i++) + ((_stra__AddStorageFpaclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AddStorageFpaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AddStorageFpaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AddStorageFpaclEntry %p -> %p\n", q, p)); + *(_stra__AddStorageFpaclEntry*)p = *(_stra__AddStorageFpaclEntry*)q; +} + +void _stra__RemoveStorageEaclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__RemoveStorageEaclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__RemoveStorageEaclEntryResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _stra__RemoveStorageEaclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__RemoveStorageEaclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__RemoveStorageEaclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__RemoveStorageEaclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__RemoveStorageEaclEntryResponse(struct soap *soap, const char *tag, int id, const _stra__RemoveStorageEaclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__RemoveStorageEaclEntryResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__RemoveStorageEaclEntryResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__RemoveStorageEaclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__RemoveStorageEaclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse * SOAP_FMAC4 soap_get__stra__RemoveStorageEaclEntryResponse(struct soap *soap, _stra__RemoveStorageEaclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__RemoveStorageEaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__RemoveStorageEaclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__RemoveStorageEaclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse * SOAP_FMAC4 soap_in__stra__RemoveStorageEaclEntryResponse(struct soap *soap, const char *tag, _stra__RemoveStorageEaclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__RemoveStorageEaclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__RemoveStorageEaclEntryResponse, sizeof(_stra__RemoveStorageEaclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__RemoveStorageEaclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__RemoveStorageEaclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__RemoveStorageEaclEntryResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__RemoveStorageEaclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__RemoveStorageEaclEntryResponse, 0, sizeof(_stra__RemoveStorageEaclEntryResponse), 0, soap_copy__stra__RemoveStorageEaclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__RemoveStorageEaclEntryResponse * SOAP_FMAC6 soap_new__stra__RemoveStorageEaclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__RemoveStorageEaclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__RemoveStorageEaclEntryResponse(struct soap *soap, _stra__RemoveStorageEaclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__RemoveStorageEaclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__RemoveStorageEaclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__RemoveStorageEaclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__RemoveStorageEaclEntryResponse; + if (size) + *size = sizeof(_stra__RemoveStorageEaclEntryResponse); + ((_stra__RemoveStorageEaclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__RemoveStorageEaclEntryResponse[n]; + if (size) + *size = n * sizeof(_stra__RemoveStorageEaclEntryResponse); + for (int i = 0; i < n; i++) + ((_stra__RemoveStorageEaclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__RemoveStorageEaclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__RemoveStorageEaclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__RemoveStorageEaclEntryResponse %p -> %p\n", q, p)); + *(_stra__RemoveStorageEaclEntryResponse*)p = *(_stra__RemoveStorageEaclEntryResponse*)q; +} + +void _stra__RemoveStorageEaclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__RemoveStorageEaclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__StorageEaclEntryHandleType(soap, &((_stra__RemoveStorageEaclEntry*)this)->Handle); + /* transient soap skipped */ +} + +int _stra__RemoveStorageEaclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__RemoveStorageEaclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__RemoveStorageEaclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__RemoveStorageEaclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__RemoveStorageEaclEntry(struct soap *soap, const char *tag, int id, const _stra__RemoveStorageEaclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__RemoveStorageEaclEntry), type); + soap_out_stra__StorageEaclEntryHandleType(soap, "stra:Handle", -1, &(((_stra__RemoveStorageEaclEntry*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__RemoveStorageEaclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__RemoveStorageEaclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_get__stra__RemoveStorageEaclEntry(struct soap *soap, _stra__RemoveStorageEaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__RemoveStorageEaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__RemoveStorageEaclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__RemoveStorageEaclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_in__stra__RemoveStorageEaclEntry(struct soap *soap, const char *tag, _stra__RemoveStorageEaclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__RemoveStorageEaclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__RemoveStorageEaclEntry, sizeof(_stra__RemoveStorageEaclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__RemoveStorageEaclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__RemoveStorageEaclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__StorageEaclEntryHandleType(soap, "stra:Handle", &(((_stra__RemoveStorageEaclEntry*)a)->Handle), "stra:StorageEaclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__RemoveStorageEaclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__RemoveStorageEaclEntry, 0, sizeof(_stra__RemoveStorageEaclEntry), 0, soap_copy__stra__RemoveStorageEaclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__RemoveStorageEaclEntry * SOAP_FMAC6 soap_new__stra__RemoveStorageEaclEntry(struct soap *soap, int n) +{ return soap_instantiate__stra__RemoveStorageEaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__RemoveStorageEaclEntry(struct soap *soap, _stra__RemoveStorageEaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_instantiate__stra__RemoveStorageEaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__RemoveStorageEaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__RemoveStorageEaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__RemoveStorageEaclEntry; + if (size) + *size = sizeof(_stra__RemoveStorageEaclEntry); + ((_stra__RemoveStorageEaclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__RemoveStorageEaclEntry[n]; + if (size) + *size = n * sizeof(_stra__RemoveStorageEaclEntry); + for (int i = 0; i < n; i++) + ((_stra__RemoveStorageEaclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__RemoveStorageEaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__RemoveStorageEaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__RemoveStorageEaclEntry %p -> %p\n", q, p)); + *(_stra__RemoveStorageEaclEntry*)p = *(_stra__RemoveStorageEaclEntry*)q; +} + +void _stra__GetStorageEaclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostra__StorageEaclEntryType(soap, &((_stra__GetStorageEaclEntryResponse*)this)->Entry); + /* transient soap skipped */ +} + +void _stra__GetStorageEaclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__GetStorageEaclEntryResponse*)this)->StatusCode); + ((_stra__GetStorageEaclEntryResponse*)this)->Entry = NULL; + /* transient soap skipped */ +} + +int _stra__GetStorageEaclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__GetStorageEaclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__GetStorageEaclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__GetStorageEaclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetStorageEaclEntryResponse(struct soap *soap, const char *tag, int id, const _stra__GetStorageEaclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__GetStorageEaclEntryResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__GetStorageEaclEntryResponse*)a)->StatusCode), ""); + soap_out_PointerTostra__StorageEaclEntryType(soap, "stra:Entry", -1, &(((_stra__GetStorageEaclEntryResponse*)a)->Entry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__GetStorageEaclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__GetStorageEaclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse * SOAP_FMAC4 soap_get__stra__GetStorageEaclEntryResponse(struct soap *soap, _stra__GetStorageEaclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__GetStorageEaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__GetStorageEaclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__GetStorageEaclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse * SOAP_FMAC4 soap_in__stra__GetStorageEaclEntryResponse(struct soap *soap, const char *tag, _stra__GetStorageEaclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__GetStorageEaclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__GetStorageEaclEntryResponse, sizeof(_stra__GetStorageEaclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__GetStorageEaclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__GetStorageEaclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Entry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__GetStorageEaclEntryResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Entry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageEaclEntryType(soap, "stra:Entry", &(((_stra__GetStorageEaclEntryResponse*)a)->Entry), "stra:StorageEaclEntryType")) + { soap_flag_Entry1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Entry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__GetStorageEaclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__GetStorageEaclEntryResponse, 0, sizeof(_stra__GetStorageEaclEntryResponse), 0, soap_copy__stra__GetStorageEaclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__GetStorageEaclEntryResponse * SOAP_FMAC6 soap_new__stra__GetStorageEaclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__GetStorageEaclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetStorageEaclEntryResponse(struct soap *soap, _stra__GetStorageEaclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__GetStorageEaclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__GetStorageEaclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__GetStorageEaclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__GetStorageEaclEntryResponse; + if (size) + *size = sizeof(_stra__GetStorageEaclEntryResponse); + ((_stra__GetStorageEaclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__GetStorageEaclEntryResponse[n]; + if (size) + *size = n * sizeof(_stra__GetStorageEaclEntryResponse); + for (int i = 0; i < n; i++) + ((_stra__GetStorageEaclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__GetStorageEaclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetStorageEaclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__GetStorageEaclEntryResponse %p -> %p\n", q, p)); + *(_stra__GetStorageEaclEntryResponse*)p = *(_stra__GetStorageEaclEntryResponse*)q; +} + +void _stra__GetStorageEaclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__GetStorageEaclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__StorageEaclEntryHandleType(soap, &((_stra__GetStorageEaclEntry*)this)->Handle); + /* transient soap skipped */ +} + +int _stra__GetStorageEaclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__GetStorageEaclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__GetStorageEaclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__GetStorageEaclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetStorageEaclEntry(struct soap *soap, const char *tag, int id, const _stra__GetStorageEaclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__GetStorageEaclEntry), type); + soap_out_stra__StorageEaclEntryHandleType(soap, "stra:Handle", -1, &(((_stra__GetStorageEaclEntry*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__GetStorageEaclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__GetStorageEaclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__GetStorageEaclEntry * SOAP_FMAC4 soap_get__stra__GetStorageEaclEntry(struct soap *soap, _stra__GetStorageEaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__GetStorageEaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__GetStorageEaclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__GetStorageEaclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__GetStorageEaclEntry * SOAP_FMAC4 soap_in__stra__GetStorageEaclEntry(struct soap *soap, const char *tag, _stra__GetStorageEaclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__GetStorageEaclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__GetStorageEaclEntry, sizeof(_stra__GetStorageEaclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__GetStorageEaclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__GetStorageEaclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__StorageEaclEntryHandleType(soap, "stra:Handle", &(((_stra__GetStorageEaclEntry*)a)->Handle), "stra:StorageEaclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__GetStorageEaclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__GetStorageEaclEntry, 0, sizeof(_stra__GetStorageEaclEntry), 0, soap_copy__stra__GetStorageEaclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__GetStorageEaclEntry * SOAP_FMAC6 soap_new__stra__GetStorageEaclEntry(struct soap *soap, int n) +{ return soap_instantiate__stra__GetStorageEaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetStorageEaclEntry(struct soap *soap, _stra__GetStorageEaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__GetStorageEaclEntry * SOAP_FMAC4 soap_instantiate__stra__GetStorageEaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__GetStorageEaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__GetStorageEaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__GetStorageEaclEntry; + if (size) + *size = sizeof(_stra__GetStorageEaclEntry); + ((_stra__GetStorageEaclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__GetStorageEaclEntry[n]; + if (size) + *size = n * sizeof(_stra__GetStorageEaclEntry); + for (int i = 0; i < n; i++) + ((_stra__GetStorageEaclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__GetStorageEaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetStorageEaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__GetStorageEaclEntry %p -> %p\n", q, p)); + *(_stra__GetStorageEaclEntry*)p = *(_stra__GetStorageEaclEntry*)q; +} + +void _stra__EnumerateStorageEaclEntriesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_stra__EnumerateStorageEaclEntriesResponse*)this)->TotalCount, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((_stra__EnumerateStorageEaclEntriesResponse*)this)->HandlesCount, SOAP_TYPE_unsignedShort); + soap_serialize_PointerTostra__StorageEaclEntryHandleListType(soap, &((_stra__EnumerateStorageEaclEntriesResponse*)this)->Handles); + /* transient soap skipped */ +} + +void _stra__EnumerateStorageEaclEntriesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__EnumerateStorageEaclEntriesResponse*)this)->StatusCode); + soap_default_unsignedShort(soap, &((_stra__EnumerateStorageEaclEntriesResponse*)this)->TotalCount); + soap_default_unsignedShort(soap, &((_stra__EnumerateStorageEaclEntriesResponse*)this)->HandlesCount); + ((_stra__EnumerateStorageEaclEntriesResponse*)this)->Handles = NULL; + /* transient soap skipped */ +} + +int _stra__EnumerateStorageEaclEntriesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__EnumerateStorageEaclEntriesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__EnumerateStorageEaclEntriesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, const char *tag, int id, const _stra__EnumerateStorageEaclEntriesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__EnumerateStorageEaclEntriesResponse*)a)->StatusCode), ""); + soap_out_unsignedShort(soap, "stra:TotalCount", -1, &(((_stra__EnumerateStorageEaclEntriesResponse*)a)->TotalCount), ""); + soap_out_unsignedShort(soap, "stra:HandlesCount", -1, &(((_stra__EnumerateStorageEaclEntriesResponse*)a)->HandlesCount), ""); + soap_out_PointerTostra__StorageEaclEntryHandleListType(soap, "stra:Handles", -1, &(((_stra__EnumerateStorageEaclEntriesResponse*)a)->Handles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__EnumerateStorageEaclEntriesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__EnumerateStorageEaclEntriesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse * SOAP_FMAC4 soap_get__stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, _stra__EnumerateStorageEaclEntriesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__EnumerateStorageEaclEntriesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__EnumerateStorageEaclEntriesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__EnumerateStorageEaclEntriesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse * SOAP_FMAC4 soap_in__stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, const char *tag, _stra__EnumerateStorageEaclEntriesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__EnumerateStorageEaclEntriesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse, sizeof(_stra__EnumerateStorageEaclEntriesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__EnumerateStorageEaclEntriesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_TotalCount1 = 1, soap_flag_HandlesCount1 = 1, soap_flag_Handles1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__EnumerateStorageEaclEntriesResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_TotalCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:TotalCount", &(((_stra__EnumerateStorageEaclEntriesResponse*)a)->TotalCount), "xsd:unsignedShort")) + { soap_flag_TotalCount1--; + continue; + } + if (soap_flag_HandlesCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:HandlesCount", &(((_stra__EnumerateStorageEaclEntriesResponse*)a)->HandlesCount), "xsd:unsignedShort")) + { soap_flag_HandlesCount1--; + continue; + } + if (soap_flag_Handles1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageEaclEntryHandleListType(soap, "stra:Handles", &(((_stra__EnumerateStorageEaclEntriesResponse*)a)->Handles), "stra:StorageEaclEntryHandleListType")) + { soap_flag_Handles1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_TotalCount1 > 0 || soap_flag_HandlesCount1 > 0 || soap_flag_Handles1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__EnumerateStorageEaclEntriesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse, 0, sizeof(_stra__EnumerateStorageEaclEntriesResponse), 0, soap_copy__stra__EnumerateStorageEaclEntriesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__EnumerateStorageEaclEntriesResponse * SOAP_FMAC6 soap_new__stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__EnumerateStorageEaclEntriesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, _stra__EnumerateStorageEaclEntriesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse * SOAP_FMAC4 soap_instantiate__stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__EnumerateStorageEaclEntriesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__EnumerateStorageEaclEntriesResponse; + if (size) + *size = sizeof(_stra__EnumerateStorageEaclEntriesResponse); + ((_stra__EnumerateStorageEaclEntriesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__EnumerateStorageEaclEntriesResponse[n]; + if (size) + *size = n * sizeof(_stra__EnumerateStorageEaclEntriesResponse); + for (int i = 0; i < n; i++) + ((_stra__EnumerateStorageEaclEntriesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__EnumerateStorageEaclEntriesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__EnumerateStorageEaclEntriesResponse %p -> %p\n", q, p)); + *(_stra__EnumerateStorageEaclEntriesResponse*)p = *(_stra__EnumerateStorageEaclEntriesResponse*)q; +} + +void _stra__EnumerateStorageEaclEntries::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_stra__EnumerateStorageEaclEntries*)this)->StartIndex, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void _stra__EnumerateStorageEaclEntries::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedShort(soap, &((_stra__EnumerateStorageEaclEntries*)this)->StartIndex); + /* transient soap skipped */ +} + +int _stra__EnumerateStorageEaclEntries::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__EnumerateStorageEaclEntries); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__EnumerateStorageEaclEntries::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__EnumerateStorageEaclEntries(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__EnumerateStorageEaclEntries(struct soap *soap, const char *tag, int id, const _stra__EnumerateStorageEaclEntries *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__EnumerateStorageEaclEntries), type); + soap_out_unsignedShort(soap, "stra:StartIndex", -1, &(((_stra__EnumerateStorageEaclEntries*)a)->StartIndex), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__EnumerateStorageEaclEntries::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__EnumerateStorageEaclEntries(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_get__stra__EnumerateStorageEaclEntries(struct soap *soap, _stra__EnumerateStorageEaclEntries *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__EnumerateStorageEaclEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__EnumerateStorageEaclEntries::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__EnumerateStorageEaclEntries(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_in__stra__EnumerateStorageEaclEntries(struct soap *soap, const char *tag, _stra__EnumerateStorageEaclEntries *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__EnumerateStorageEaclEntries *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__EnumerateStorageEaclEntries, sizeof(_stra__EnumerateStorageEaclEntries), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__EnumerateStorageEaclEntries) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__EnumerateStorageEaclEntries *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StartIndex1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StartIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:StartIndex", &(((_stra__EnumerateStorageEaclEntries*)a)->StartIndex), "xsd:unsignedShort")) + { soap_flag_StartIndex1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StartIndex1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__EnumerateStorageEaclEntries *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__EnumerateStorageEaclEntries, 0, sizeof(_stra__EnumerateStorageEaclEntries), 0, soap_copy__stra__EnumerateStorageEaclEntries); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__EnumerateStorageEaclEntries * SOAP_FMAC6 soap_new__stra__EnumerateStorageEaclEntries(struct soap *soap, int n) +{ return soap_instantiate__stra__EnumerateStorageEaclEntries(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__EnumerateStorageEaclEntries(struct soap *soap, _stra__EnumerateStorageEaclEntries *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_instantiate__stra__EnumerateStorageEaclEntries(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__EnumerateStorageEaclEntries(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__EnumerateStorageEaclEntries, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__EnumerateStorageEaclEntries; + if (size) + *size = sizeof(_stra__EnumerateStorageEaclEntries); + ((_stra__EnumerateStorageEaclEntries*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__EnumerateStorageEaclEntries[n]; + if (size) + *size = n * sizeof(_stra__EnumerateStorageEaclEntries); + for (int i = 0; i < n; i++) + ((_stra__EnumerateStorageEaclEntries*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__EnumerateStorageEaclEntries*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__EnumerateStorageEaclEntries(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__EnumerateStorageEaclEntries %p -> %p\n", q, p)); + *(_stra__EnumerateStorageEaclEntries*)p = *(_stra__EnumerateStorageEaclEntries*)q; +} + +void _stra__AddStorageEaclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__AddStorageEaclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__AddStorageEaclEntryResponse*)this)->StatusCode); + soap_default_stra__StorageEaclEntryHandleType(soap, &((_stra__AddStorageEaclEntryResponse*)this)->Handle); + /* transient soap skipped */ +} + +int _stra__AddStorageEaclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AddStorageEaclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AddStorageEaclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AddStorageEaclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AddStorageEaclEntryResponse(struct soap *soap, const char *tag, int id, const _stra__AddStorageEaclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AddStorageEaclEntryResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__AddStorageEaclEntryResponse*)a)->StatusCode), ""); + soap_out_stra__StorageEaclEntryHandleType(soap, "stra:Handle", -1, &(((_stra__AddStorageEaclEntryResponse*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AddStorageEaclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AddStorageEaclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse * SOAP_FMAC4 soap_get__stra__AddStorageEaclEntryResponse(struct soap *soap, _stra__AddStorageEaclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AddStorageEaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AddStorageEaclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AddStorageEaclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse * SOAP_FMAC4 soap_in__stra__AddStorageEaclEntryResponse(struct soap *soap, const char *tag, _stra__AddStorageEaclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AddStorageEaclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AddStorageEaclEntryResponse, sizeof(_stra__AddStorageEaclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AddStorageEaclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AddStorageEaclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__AddStorageEaclEntryResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__StorageEaclEntryHandleType(soap, "stra:Handle", &(((_stra__AddStorageEaclEntryResponse*)a)->Handle), "stra:StorageEaclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AddStorageEaclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AddStorageEaclEntryResponse, 0, sizeof(_stra__AddStorageEaclEntryResponse), 0, soap_copy__stra__AddStorageEaclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AddStorageEaclEntryResponse * SOAP_FMAC6 soap_new__stra__AddStorageEaclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__AddStorageEaclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AddStorageEaclEntryResponse(struct soap *soap, _stra__AddStorageEaclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse * SOAP_FMAC4 soap_instantiate__stra__AddStorageEaclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AddStorageEaclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AddStorageEaclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AddStorageEaclEntryResponse; + if (size) + *size = sizeof(_stra__AddStorageEaclEntryResponse); + ((_stra__AddStorageEaclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AddStorageEaclEntryResponse[n]; + if (size) + *size = n * sizeof(_stra__AddStorageEaclEntryResponse); + for (int i = 0; i < n; i++) + ((_stra__AddStorageEaclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AddStorageEaclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AddStorageEaclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AddStorageEaclEntryResponse %p -> %p\n", q, p)); + *(_stra__AddStorageEaclEntryResponse*)p = *(_stra__AddStorageEaclEntryResponse*)q; +} + +void _stra__AddStorageEaclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostra__StorageEaclEntryType(soap, &((_stra__AddStorageEaclEntry*)this)->Entry); + /* transient soap skipped */ +} + +void _stra__AddStorageEaclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_stra__AddStorageEaclEntry*)this)->Entry = NULL; + /* transient soap skipped */ +} + +int _stra__AddStorageEaclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AddStorageEaclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AddStorageEaclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AddStorageEaclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AddStorageEaclEntry(struct soap *soap, const char *tag, int id, const _stra__AddStorageEaclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AddStorageEaclEntry), type); + soap_out_PointerTostra__StorageEaclEntryType(soap, "stra:Entry", -1, &(((_stra__AddStorageEaclEntry*)a)->Entry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AddStorageEaclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AddStorageEaclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AddStorageEaclEntry * SOAP_FMAC4 soap_get__stra__AddStorageEaclEntry(struct soap *soap, _stra__AddStorageEaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AddStorageEaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AddStorageEaclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AddStorageEaclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AddStorageEaclEntry * SOAP_FMAC4 soap_in__stra__AddStorageEaclEntry(struct soap *soap, const char *tag, _stra__AddStorageEaclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AddStorageEaclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AddStorageEaclEntry, sizeof(_stra__AddStorageEaclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AddStorageEaclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AddStorageEaclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Entry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Entry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageEaclEntryType(soap, "stra:Entry", &(((_stra__AddStorageEaclEntry*)a)->Entry), "stra:StorageEaclEntryType")) + { soap_flag_Entry1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Entry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AddStorageEaclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AddStorageEaclEntry, 0, sizeof(_stra__AddStorageEaclEntry), 0, soap_copy__stra__AddStorageEaclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AddStorageEaclEntry * SOAP_FMAC6 soap_new__stra__AddStorageEaclEntry(struct soap *soap, int n) +{ return soap_instantiate__stra__AddStorageEaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AddStorageEaclEntry(struct soap *soap, _stra__AddStorageEaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AddStorageEaclEntry * SOAP_FMAC4 soap_instantiate__stra__AddStorageEaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AddStorageEaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AddStorageEaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AddStorageEaclEntry; + if (size) + *size = sizeof(_stra__AddStorageEaclEntry); + ((_stra__AddStorageEaclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AddStorageEaclEntry[n]; + if (size) + *size = n * sizeof(_stra__AddStorageEaclEntry); + for (int i = 0; i < n; i++) + ((_stra__AddStorageEaclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AddStorageEaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AddStorageEaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AddStorageEaclEntry %p -> %p\n", q, p)); + *(_stra__AddStorageEaclEntry*)p = *(_stra__AddStorageEaclEntry*)q; +} + +void _stra__AdminRemoveApplicationResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__AdminRemoveApplicationResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__AdminRemoveApplicationResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _stra__AdminRemoveApplicationResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AdminRemoveApplicationResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AdminRemoveApplicationResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AdminRemoveApplicationResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminRemoveApplicationResponse(struct soap *soap, const char *tag, int id, const _stra__AdminRemoveApplicationResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AdminRemoveApplicationResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__AdminRemoveApplicationResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AdminRemoveApplicationResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AdminRemoveApplicationResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse * SOAP_FMAC4 soap_get__stra__AdminRemoveApplicationResponse(struct soap *soap, _stra__AdminRemoveApplicationResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AdminRemoveApplicationResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AdminRemoveApplicationResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AdminRemoveApplicationResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse * SOAP_FMAC4 soap_in__stra__AdminRemoveApplicationResponse(struct soap *soap, const char *tag, _stra__AdminRemoveApplicationResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AdminRemoveApplicationResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AdminRemoveApplicationResponse, sizeof(_stra__AdminRemoveApplicationResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AdminRemoveApplicationResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AdminRemoveApplicationResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__AdminRemoveApplicationResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AdminRemoveApplicationResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AdminRemoveApplicationResponse, 0, sizeof(_stra__AdminRemoveApplicationResponse), 0, soap_copy__stra__AdminRemoveApplicationResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AdminRemoveApplicationResponse * SOAP_FMAC6 soap_new__stra__AdminRemoveApplicationResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__AdminRemoveApplicationResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminRemoveApplicationResponse(struct soap *soap, _stra__AdminRemoveApplicationResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse * SOAP_FMAC4 soap_instantiate__stra__AdminRemoveApplicationResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AdminRemoveApplicationResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AdminRemoveApplicationResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AdminRemoveApplicationResponse; + if (size) + *size = sizeof(_stra__AdminRemoveApplicationResponse); + ((_stra__AdminRemoveApplicationResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AdminRemoveApplicationResponse[n]; + if (size) + *size = n * sizeof(_stra__AdminRemoveApplicationResponse); + for (int i = 0; i < n; i++) + ((_stra__AdminRemoveApplicationResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AdminRemoveApplicationResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminRemoveApplicationResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AdminRemoveApplicationResponse %p -> %p\n", q, p)); + *(_stra__AdminRemoveApplicationResponse*)p = *(_stra__AdminRemoveApplicationResponse*)q; +} + +void _stra__AdminRemoveApplication::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__AdminRemoveApplication::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__StorageApplicationHandleType(soap, &((_stra__AdminRemoveApplication*)this)->Handle); + /* transient soap skipped */ +} + +int _stra__AdminRemoveApplication::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AdminRemoveApplication); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AdminRemoveApplication::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AdminRemoveApplication(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminRemoveApplication(struct soap *soap, const char *tag, int id, const _stra__AdminRemoveApplication *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AdminRemoveApplication), type); + soap_out_stra__StorageApplicationHandleType(soap, "stra:Handle", -1, &(((_stra__AdminRemoveApplication*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AdminRemoveApplication::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AdminRemoveApplication(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AdminRemoveApplication * SOAP_FMAC4 soap_get__stra__AdminRemoveApplication(struct soap *soap, _stra__AdminRemoveApplication *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AdminRemoveApplication(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AdminRemoveApplication::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AdminRemoveApplication(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AdminRemoveApplication * SOAP_FMAC4 soap_in__stra__AdminRemoveApplication(struct soap *soap, const char *tag, _stra__AdminRemoveApplication *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AdminRemoveApplication *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AdminRemoveApplication, sizeof(_stra__AdminRemoveApplication), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AdminRemoveApplication) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AdminRemoveApplication *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__StorageApplicationHandleType(soap, "stra:Handle", &(((_stra__AdminRemoveApplication*)a)->Handle), "stra:StorageApplicationHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AdminRemoveApplication *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AdminRemoveApplication, 0, sizeof(_stra__AdminRemoveApplication), 0, soap_copy__stra__AdminRemoveApplication); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AdminRemoveApplication * SOAP_FMAC6 soap_new__stra__AdminRemoveApplication(struct soap *soap, int n) +{ return soap_instantiate__stra__AdminRemoveApplication(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminRemoveApplication(struct soap *soap, _stra__AdminRemoveApplication *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AdminRemoveApplication * SOAP_FMAC4 soap_instantiate__stra__AdminRemoveApplication(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AdminRemoveApplication(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AdminRemoveApplication, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AdminRemoveApplication; + if (size) + *size = sizeof(_stra__AdminRemoveApplication); + ((_stra__AdminRemoveApplication*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AdminRemoveApplication[n]; + if (size) + *size = n * sizeof(_stra__AdminRemoveApplication); + for (int i = 0; i < n; i++) + ((_stra__AdminRemoveApplication*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AdminRemoveApplication*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminRemoveApplication(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AdminRemoveApplication %p -> %p\n", q, p)); + *(_stra__AdminRemoveApplication*)p = *(_stra__AdminRemoveApplication*)q; +} + +void _stra__AdminGetApplicationAttributesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostra__StorageApplicationAttributesType(soap, &((_stra__AdminGetApplicationAttributesResponse*)this)->Attributes); + /* transient soap skipped */ +} + +void _stra__AdminGetApplicationAttributesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__AdminGetApplicationAttributesResponse*)this)->StatusCode); + ((_stra__AdminGetApplicationAttributesResponse*)this)->Attributes = NULL; + /* transient soap skipped */ +} + +int _stra__AdminGetApplicationAttributesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AdminGetApplicationAttributesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AdminGetApplicationAttributesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AdminGetApplicationAttributesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminGetApplicationAttributesResponse(struct soap *soap, const char *tag, int id, const _stra__AdminGetApplicationAttributesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AdminGetApplicationAttributesResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__AdminGetApplicationAttributesResponse*)a)->StatusCode), ""); + soap_out_PointerTostra__StorageApplicationAttributesType(soap, "stra:Attributes", -1, &(((_stra__AdminGetApplicationAttributesResponse*)a)->Attributes), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AdminGetApplicationAttributesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AdminGetApplicationAttributesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse * SOAP_FMAC4 soap_get__stra__AdminGetApplicationAttributesResponse(struct soap *soap, _stra__AdminGetApplicationAttributesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AdminGetApplicationAttributesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AdminGetApplicationAttributesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AdminGetApplicationAttributesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse * SOAP_FMAC4 soap_in__stra__AdminGetApplicationAttributesResponse(struct soap *soap, const char *tag, _stra__AdminGetApplicationAttributesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AdminGetApplicationAttributesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AdminGetApplicationAttributesResponse, sizeof(_stra__AdminGetApplicationAttributesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AdminGetApplicationAttributesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AdminGetApplicationAttributesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Attributes1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__AdminGetApplicationAttributesResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Attributes1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageApplicationAttributesType(soap, "stra:Attributes", &(((_stra__AdminGetApplicationAttributesResponse*)a)->Attributes), "stra:StorageApplicationAttributesType")) + { soap_flag_Attributes1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AdminGetApplicationAttributesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AdminGetApplicationAttributesResponse, 0, sizeof(_stra__AdminGetApplicationAttributesResponse), 0, soap_copy__stra__AdminGetApplicationAttributesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AdminGetApplicationAttributesResponse * SOAP_FMAC6 soap_new__stra__AdminGetApplicationAttributesResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__AdminGetApplicationAttributesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminGetApplicationAttributesResponse(struct soap *soap, _stra__AdminGetApplicationAttributesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse * SOAP_FMAC4 soap_instantiate__stra__AdminGetApplicationAttributesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AdminGetApplicationAttributesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AdminGetApplicationAttributesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AdminGetApplicationAttributesResponse; + if (size) + *size = sizeof(_stra__AdminGetApplicationAttributesResponse); + ((_stra__AdminGetApplicationAttributesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AdminGetApplicationAttributesResponse[n]; + if (size) + *size = n * sizeof(_stra__AdminGetApplicationAttributesResponse); + for (int i = 0; i < n; i++) + ((_stra__AdminGetApplicationAttributesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AdminGetApplicationAttributesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminGetApplicationAttributesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AdminGetApplicationAttributesResponse %p -> %p\n", q, p)); + *(_stra__AdminGetApplicationAttributesResponse*)p = *(_stra__AdminGetApplicationAttributesResponse*)q; +} + +void _stra__AdminGetApplicationAttributes::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__AdminGetApplicationAttributes::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__StorageApplicationHandleType(soap, &((_stra__AdminGetApplicationAttributes*)this)->Handle); + /* transient soap skipped */ +} + +int _stra__AdminGetApplicationAttributes::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AdminGetApplicationAttributes); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AdminGetApplicationAttributes::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AdminGetApplicationAttributes(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminGetApplicationAttributes(struct soap *soap, const char *tag, int id, const _stra__AdminGetApplicationAttributes *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AdminGetApplicationAttributes), type); + soap_out_stra__StorageApplicationHandleType(soap, "stra:Handle", -1, &(((_stra__AdminGetApplicationAttributes*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AdminGetApplicationAttributes::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AdminGetApplicationAttributes(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_get__stra__AdminGetApplicationAttributes(struct soap *soap, _stra__AdminGetApplicationAttributes *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AdminGetApplicationAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AdminGetApplicationAttributes::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AdminGetApplicationAttributes(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_in__stra__AdminGetApplicationAttributes(struct soap *soap, const char *tag, _stra__AdminGetApplicationAttributes *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AdminGetApplicationAttributes *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AdminGetApplicationAttributes, sizeof(_stra__AdminGetApplicationAttributes), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AdminGetApplicationAttributes) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AdminGetApplicationAttributes *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__StorageApplicationHandleType(soap, "stra:Handle", &(((_stra__AdminGetApplicationAttributes*)a)->Handle), "stra:StorageApplicationHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AdminGetApplicationAttributes *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AdminGetApplicationAttributes, 0, sizeof(_stra__AdminGetApplicationAttributes), 0, soap_copy__stra__AdminGetApplicationAttributes); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AdminGetApplicationAttributes * SOAP_FMAC6 soap_new__stra__AdminGetApplicationAttributes(struct soap *soap, int n) +{ return soap_instantiate__stra__AdminGetApplicationAttributes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminGetApplicationAttributes(struct soap *soap, _stra__AdminGetApplicationAttributes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_instantiate__stra__AdminGetApplicationAttributes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AdminGetApplicationAttributes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AdminGetApplicationAttributes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AdminGetApplicationAttributes; + if (size) + *size = sizeof(_stra__AdminGetApplicationAttributes); + ((_stra__AdminGetApplicationAttributes*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AdminGetApplicationAttributes[n]; + if (size) + *size = n * sizeof(_stra__AdminGetApplicationAttributes); + for (int i = 0; i < n; i++) + ((_stra__AdminGetApplicationAttributes*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AdminGetApplicationAttributes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminGetApplicationAttributes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AdminGetApplicationAttributes %p -> %p\n", q, p)); + *(_stra__AdminGetApplicationAttributes*)p = *(_stra__AdminGetApplicationAttributes*)q; +} + +void _stra__AdminGetRegisteredApplicationsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_stra__AdminGetRegisteredApplicationsResponse*)this)->TotalCount, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_stra__AdminGetRegisteredApplicationsResponse*)this)->HandlesCount, SOAP_TYPE_unsignedInt); + soap_serialize_PointerTostra__StorageApplicationHandleListType(soap, &((_stra__AdminGetRegisteredApplicationsResponse*)this)->ApplicationHandles); + /* transient soap skipped */ +} + +void _stra__AdminGetRegisteredApplicationsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__AdminGetRegisteredApplicationsResponse*)this)->StatusCode); + soap_default_unsignedInt(soap, &((_stra__AdminGetRegisteredApplicationsResponse*)this)->TotalCount); + soap_default_unsignedInt(soap, &((_stra__AdminGetRegisteredApplicationsResponse*)this)->HandlesCount); + ((_stra__AdminGetRegisteredApplicationsResponse*)this)->ApplicationHandles = NULL; + /* transient soap skipped */ +} + +int _stra__AdminGetRegisteredApplicationsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AdminGetRegisteredApplicationsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AdminGetRegisteredApplicationsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, const char *tag, int id, const _stra__AdminGetRegisteredApplicationsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__AdminGetRegisteredApplicationsResponse*)a)->StatusCode), ""); + soap_out_unsignedInt(soap, "stra:TotalCount", -1, &(((_stra__AdminGetRegisteredApplicationsResponse*)a)->TotalCount), ""); + soap_out_unsignedInt(soap, "stra:HandlesCount", -1, &(((_stra__AdminGetRegisteredApplicationsResponse*)a)->HandlesCount), ""); + soap_out_PointerTostra__StorageApplicationHandleListType(soap, "stra:ApplicationHandles", -1, &(((_stra__AdminGetRegisteredApplicationsResponse*)a)->ApplicationHandles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AdminGetRegisteredApplicationsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AdminGetRegisteredApplicationsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse * SOAP_FMAC4 soap_get__stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, _stra__AdminGetRegisteredApplicationsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AdminGetRegisteredApplicationsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AdminGetRegisteredApplicationsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AdminGetRegisteredApplicationsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse * SOAP_FMAC4 soap_in__stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, const char *tag, _stra__AdminGetRegisteredApplicationsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AdminGetRegisteredApplicationsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse, sizeof(_stra__AdminGetRegisteredApplicationsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AdminGetRegisteredApplicationsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_TotalCount1 = 1, soap_flag_HandlesCount1 = 1, soap_flag_ApplicationHandles1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__AdminGetRegisteredApplicationsResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_TotalCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:TotalCount", &(((_stra__AdminGetRegisteredApplicationsResponse*)a)->TotalCount), "xsd:unsignedInt")) + { soap_flag_TotalCount1--; + continue; + } + if (soap_flag_HandlesCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:HandlesCount", &(((_stra__AdminGetRegisteredApplicationsResponse*)a)->HandlesCount), "xsd:unsignedInt")) + { soap_flag_HandlesCount1--; + continue; + } + if (soap_flag_ApplicationHandles1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageApplicationHandleListType(soap, "stra:ApplicationHandles", &(((_stra__AdminGetRegisteredApplicationsResponse*)a)->ApplicationHandles), "stra:StorageApplicationHandleListType")) + { soap_flag_ApplicationHandles1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_TotalCount1 > 0 || soap_flag_HandlesCount1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AdminGetRegisteredApplicationsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse, 0, sizeof(_stra__AdminGetRegisteredApplicationsResponse), 0, soap_copy__stra__AdminGetRegisteredApplicationsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AdminGetRegisteredApplicationsResponse * SOAP_FMAC6 soap_new__stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__AdminGetRegisteredApplicationsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, _stra__AdminGetRegisteredApplicationsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse * SOAP_FMAC4 soap_instantiate__stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AdminGetRegisteredApplicationsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AdminGetRegisteredApplicationsResponse; + if (size) + *size = sizeof(_stra__AdminGetRegisteredApplicationsResponse); + ((_stra__AdminGetRegisteredApplicationsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AdminGetRegisteredApplicationsResponse[n]; + if (size) + *size = n * sizeof(_stra__AdminGetRegisteredApplicationsResponse); + for (int i = 0; i < n; i++) + ((_stra__AdminGetRegisteredApplicationsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AdminGetRegisteredApplicationsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AdminGetRegisteredApplicationsResponse %p -> %p\n", q, p)); + *(_stra__AdminGetRegisteredApplicationsResponse*)p = *(_stra__AdminGetRegisteredApplicationsResponse*)q; +} + +void _stra__AdminGetRegisteredApplications::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_stra__AdminGetRegisteredApplications*)this)->StartIndex, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _stra__AdminGetRegisteredApplications::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_stra__AdminGetRegisteredApplications*)this)->StartIndex); + /* transient soap skipped */ +} + +int _stra__AdminGetRegisteredApplications::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__AdminGetRegisteredApplications); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__AdminGetRegisteredApplications::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__AdminGetRegisteredApplications(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__AdminGetRegisteredApplications(struct soap *soap, const char *tag, int id, const _stra__AdminGetRegisteredApplications *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__AdminGetRegisteredApplications), type); + soap_out_unsignedInt(soap, "stra:StartIndex", -1, &(((_stra__AdminGetRegisteredApplications*)a)->StartIndex), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__AdminGetRegisteredApplications::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__AdminGetRegisteredApplications(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_get__stra__AdminGetRegisteredApplications(struct soap *soap, _stra__AdminGetRegisteredApplications *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__AdminGetRegisteredApplications(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__AdminGetRegisteredApplications::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__AdminGetRegisteredApplications(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_in__stra__AdminGetRegisteredApplications(struct soap *soap, const char *tag, _stra__AdminGetRegisteredApplications *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__AdminGetRegisteredApplications *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__AdminGetRegisteredApplications, sizeof(_stra__AdminGetRegisteredApplications), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__AdminGetRegisteredApplications) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__AdminGetRegisteredApplications *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StartIndex1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StartIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:StartIndex", &(((_stra__AdminGetRegisteredApplications*)a)->StartIndex), "xsd:unsignedInt")) + { soap_flag_StartIndex1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StartIndex1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__AdminGetRegisteredApplications *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__AdminGetRegisteredApplications, 0, sizeof(_stra__AdminGetRegisteredApplications), 0, soap_copy__stra__AdminGetRegisteredApplications); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__AdminGetRegisteredApplications * SOAP_FMAC6 soap_new__stra__AdminGetRegisteredApplications(struct soap *soap, int n) +{ return soap_instantiate__stra__AdminGetRegisteredApplications(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__AdminGetRegisteredApplications(struct soap *soap, _stra__AdminGetRegisteredApplications *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_instantiate__stra__AdminGetRegisteredApplications(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__AdminGetRegisteredApplications(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__AdminGetRegisteredApplications, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__AdminGetRegisteredApplications; + if (size) + *size = sizeof(_stra__AdminGetRegisteredApplications); + ((_stra__AdminGetRegisteredApplications*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__AdminGetRegisteredApplications[n]; + if (size) + *size = n * sizeof(_stra__AdminGetRegisteredApplications); + for (int i = 0; i < n; i++) + ((_stra__AdminGetRegisteredApplications*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__AdminGetRegisteredApplications*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__AdminGetRegisteredApplications(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__AdminGetRegisteredApplications %p -> %p\n", q, p)); + *(_stra__AdminGetRegisteredApplications*)p = *(_stra__AdminGetRegisteredApplications*)q; +} + +void _stra__SetGlobalStorageAttributesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__SetGlobalStorageAttributesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__SetGlobalStorageAttributesResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _stra__SetGlobalStorageAttributesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__SetGlobalStorageAttributesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__SetGlobalStorageAttributesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__SetGlobalStorageAttributesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__SetGlobalStorageAttributesResponse(struct soap *soap, const char *tag, int id, const _stra__SetGlobalStorageAttributesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__SetGlobalStorageAttributesResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__SetGlobalStorageAttributesResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__SetGlobalStorageAttributesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__SetGlobalStorageAttributesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_get__stra__SetGlobalStorageAttributesResponse(struct soap *soap, _stra__SetGlobalStorageAttributesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__SetGlobalStorageAttributesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__SetGlobalStorageAttributesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__SetGlobalStorageAttributesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_in__stra__SetGlobalStorageAttributesResponse(struct soap *soap, const char *tag, _stra__SetGlobalStorageAttributesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__SetGlobalStorageAttributesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__SetGlobalStorageAttributesResponse, sizeof(_stra__SetGlobalStorageAttributesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__SetGlobalStorageAttributesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__SetGlobalStorageAttributesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__SetGlobalStorageAttributesResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__SetGlobalStorageAttributesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__SetGlobalStorageAttributesResponse, 0, sizeof(_stra__SetGlobalStorageAttributesResponse), 0, soap_copy__stra__SetGlobalStorageAttributesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__SetGlobalStorageAttributesResponse * SOAP_FMAC6 soap_new__stra__SetGlobalStorageAttributesResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__SetGlobalStorageAttributesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__SetGlobalStorageAttributesResponse(struct soap *soap, _stra__SetGlobalStorageAttributesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_instantiate__stra__SetGlobalStorageAttributesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__SetGlobalStorageAttributesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__SetGlobalStorageAttributesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__SetGlobalStorageAttributesResponse; + if (size) + *size = sizeof(_stra__SetGlobalStorageAttributesResponse); + ((_stra__SetGlobalStorageAttributesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__SetGlobalStorageAttributesResponse[n]; + if (size) + *size = n * sizeof(_stra__SetGlobalStorageAttributesResponse); + for (int i = 0; i < n; i++) + ((_stra__SetGlobalStorageAttributesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__SetGlobalStorageAttributesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__SetGlobalStorageAttributesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__SetGlobalStorageAttributesResponse %p -> %p\n", q, p)); + *(_stra__SetGlobalStorageAttributesResponse*)p = *(_stra__SetGlobalStorageAttributesResponse*)q; +} + +void _stra__SetGlobalStorageAttributes::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTounsignedInt(soap, &((_stra__SetGlobalStorageAttributes*)this)->MaxPartnerStorage); + soap_serialize_PointerTounsignedShort(soap, &((_stra__SetGlobalStorageAttributes*)this)->MaxNonPartnerTotalAllocationSize); + /* transient soap skipped */ +} + +void _stra__SetGlobalStorageAttributes::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_stra__SetGlobalStorageAttributes*)this)->MaxPartnerStorage = NULL; + ((_stra__SetGlobalStorageAttributes*)this)->MaxNonPartnerTotalAllocationSize = NULL; + /* transient soap skipped */ +} + +int _stra__SetGlobalStorageAttributes::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__SetGlobalStorageAttributes); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__SetGlobalStorageAttributes::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__SetGlobalStorageAttributes(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__SetGlobalStorageAttributes(struct soap *soap, const char *tag, int id, const _stra__SetGlobalStorageAttributes *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__SetGlobalStorageAttributes), type); + soap_out_PointerTounsignedInt(soap, "stra:MaxPartnerStorage", -1, &(((_stra__SetGlobalStorageAttributes*)a)->MaxPartnerStorage), ""); + soap_out_PointerTounsignedShort(soap, "stra:MaxNonPartnerTotalAllocationSize", -1, &(((_stra__SetGlobalStorageAttributes*)a)->MaxNonPartnerTotalAllocationSize), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__SetGlobalStorageAttributes::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__SetGlobalStorageAttributes(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_get__stra__SetGlobalStorageAttributes(struct soap *soap, _stra__SetGlobalStorageAttributes *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__SetGlobalStorageAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__SetGlobalStorageAttributes::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__SetGlobalStorageAttributes(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_in__stra__SetGlobalStorageAttributes(struct soap *soap, const char *tag, _stra__SetGlobalStorageAttributes *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__SetGlobalStorageAttributes *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__SetGlobalStorageAttributes, sizeof(_stra__SetGlobalStorageAttributes), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__SetGlobalStorageAttributes) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__SetGlobalStorageAttributes *)a->soap_in(soap, tag, type); + } + } + short soap_flag_MaxPartnerStorage1 = 1, soap_flag_MaxNonPartnerTotalAllocationSize1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_MaxPartnerStorage1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedInt(soap, "stra:MaxPartnerStorage", &(((_stra__SetGlobalStorageAttributes*)a)->MaxPartnerStorage), "xsd:unsignedInt")) + { soap_flag_MaxPartnerStorage1--; + continue; + } + if (soap_flag_MaxNonPartnerTotalAllocationSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedShort(soap, "stra:MaxNonPartnerTotalAllocationSize", &(((_stra__SetGlobalStorageAttributes*)a)->MaxNonPartnerTotalAllocationSize), "xsd:unsignedShort")) + { soap_flag_MaxNonPartnerTotalAllocationSize1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__SetGlobalStorageAttributes *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__SetGlobalStorageAttributes, 0, sizeof(_stra__SetGlobalStorageAttributes), 0, soap_copy__stra__SetGlobalStorageAttributes); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__SetGlobalStorageAttributes * SOAP_FMAC6 soap_new__stra__SetGlobalStorageAttributes(struct soap *soap, int n) +{ return soap_instantiate__stra__SetGlobalStorageAttributes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__SetGlobalStorageAttributes(struct soap *soap, _stra__SetGlobalStorageAttributes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_instantiate__stra__SetGlobalStorageAttributes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__SetGlobalStorageAttributes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__SetGlobalStorageAttributes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__SetGlobalStorageAttributes; + if (size) + *size = sizeof(_stra__SetGlobalStorageAttributes); + ((_stra__SetGlobalStorageAttributes*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__SetGlobalStorageAttributes[n]; + if (size) + *size = n * sizeof(_stra__SetGlobalStorageAttributes); + for (int i = 0; i < n; i++) + ((_stra__SetGlobalStorageAttributes*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__SetGlobalStorageAttributes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__SetGlobalStorageAttributes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__SetGlobalStorageAttributes %p -> %p\n", q, p)); + *(_stra__SetGlobalStorageAttributes*)p = *(_stra__SetGlobalStorageAttributes*)q; +} + +void _stra__GetGlobalStorageAttributesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostra__GlobalStorageAttributesType(soap, &((_stra__GetGlobalStorageAttributesResponse*)this)->Attributes); + /* transient soap skipped */ +} + +void _stra__GetGlobalStorageAttributesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__PT_USCORESTATUS(soap, &((_stra__GetGlobalStorageAttributesResponse*)this)->StatusCode); + ((_stra__GetGlobalStorageAttributesResponse*)this)->Attributes = NULL; + /* transient soap skipped */ +} + +int _stra__GetGlobalStorageAttributesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__GetGlobalStorageAttributesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__GetGlobalStorageAttributesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__GetGlobalStorageAttributesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetGlobalStorageAttributesResponse(struct soap *soap, const char *tag, int id, const _stra__GetGlobalStorageAttributesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__GetGlobalStorageAttributesResponse), type); + soap_element_result(soap, "stra:StatusCode"); + soap_out_stra__PT_USCORESTATUS(soap, "stra:StatusCode", -1, &(((_stra__GetGlobalStorageAttributesResponse*)a)->StatusCode), ""); + soap_out_PointerTostra__GlobalStorageAttributesType(soap, "stra:Attributes", -1, &(((_stra__GetGlobalStorageAttributesResponse*)a)->Attributes), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__GetGlobalStorageAttributesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__GetGlobalStorageAttributesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_get__stra__GetGlobalStorageAttributesResponse(struct soap *soap, _stra__GetGlobalStorageAttributesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__GetGlobalStorageAttributesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__GetGlobalStorageAttributesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__GetGlobalStorageAttributesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_in__stra__GetGlobalStorageAttributesResponse(struct soap *soap, const char *tag, _stra__GetGlobalStorageAttributesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__GetGlobalStorageAttributesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__GetGlobalStorageAttributesResponse, sizeof(_stra__GetGlobalStorageAttributesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__GetGlobalStorageAttributesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__GetGlobalStorageAttributesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Attributes1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__PT_USCORESTATUS(soap, "stra:StatusCode", &(((_stra__GetGlobalStorageAttributesResponse*)a)->StatusCode), "stra:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Attributes1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__GlobalStorageAttributesType(soap, "stra:Attributes", &(((_stra__GetGlobalStorageAttributesResponse*)a)->Attributes), "stra:GlobalStorageAttributesType")) + { soap_flag_Attributes1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "stra:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__GetGlobalStorageAttributesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__GetGlobalStorageAttributesResponse, 0, sizeof(_stra__GetGlobalStorageAttributesResponse), 0, soap_copy__stra__GetGlobalStorageAttributesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__GetGlobalStorageAttributesResponse * SOAP_FMAC6 soap_new__stra__GetGlobalStorageAttributesResponse(struct soap *soap, int n) +{ return soap_instantiate__stra__GetGlobalStorageAttributesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetGlobalStorageAttributesResponse(struct soap *soap, _stra__GetGlobalStorageAttributesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse * SOAP_FMAC4 soap_instantiate__stra__GetGlobalStorageAttributesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__GetGlobalStorageAttributesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__GetGlobalStorageAttributesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__GetGlobalStorageAttributesResponse; + if (size) + *size = sizeof(_stra__GetGlobalStorageAttributesResponse); + ((_stra__GetGlobalStorageAttributesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__GetGlobalStorageAttributesResponse[n]; + if (size) + *size = n * sizeof(_stra__GetGlobalStorageAttributesResponse); + for (int i = 0; i < n; i++) + ((_stra__GetGlobalStorageAttributesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__GetGlobalStorageAttributesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetGlobalStorageAttributesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__GetGlobalStorageAttributesResponse %p -> %p\n", q, p)); + *(_stra__GetGlobalStorageAttributesResponse*)p = *(_stra__GetGlobalStorageAttributesResponse*)q; +} + +void _stra__GetGlobalStorageAttributes::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _stra__GetGlobalStorageAttributes::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _stra__GetGlobalStorageAttributes::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__stra__GetGlobalStorageAttributes); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _stra__GetGlobalStorageAttributes::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__stra__GetGlobalStorageAttributes(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__stra__GetGlobalStorageAttributes(struct soap *soap, const char *tag, int id, const _stra__GetGlobalStorageAttributes *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__stra__GetGlobalStorageAttributes), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_stra__GetGlobalStorageAttributes::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__stra__GetGlobalStorageAttributes(soap, this, tag, type); +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_get__stra__GetGlobalStorageAttributes(struct soap *soap, _stra__GetGlobalStorageAttributes *p, const char *tag, const char *type) +{ + if ((p = soap_in__stra__GetGlobalStorageAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_stra__GetGlobalStorageAttributes::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__stra__GetGlobalStorageAttributes(soap, tag, this, type); +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_in__stra__GetGlobalStorageAttributes(struct soap *soap, const char *tag, _stra__GetGlobalStorageAttributes *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_stra__GetGlobalStorageAttributes *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__stra__GetGlobalStorageAttributes, sizeof(_stra__GetGlobalStorageAttributes), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__stra__GetGlobalStorageAttributes) + { soap_revert(soap); + *soap->id = '\0'; + return (_stra__GetGlobalStorageAttributes *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_stra__GetGlobalStorageAttributes *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__stra__GetGlobalStorageAttributes, 0, sizeof(_stra__GetGlobalStorageAttributes), 0, soap_copy__stra__GetGlobalStorageAttributes); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _stra__GetGlobalStorageAttributes * SOAP_FMAC6 soap_new__stra__GetGlobalStorageAttributes(struct soap *soap, int n) +{ return soap_instantiate__stra__GetGlobalStorageAttributes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__stra__GetGlobalStorageAttributes(struct soap *soap, _stra__GetGlobalStorageAttributes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_instantiate__stra__GetGlobalStorageAttributes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__stra__GetGlobalStorageAttributes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__stra__GetGlobalStorageAttributes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _stra__GetGlobalStorageAttributes; + if (size) + *size = sizeof(_stra__GetGlobalStorageAttributes); + ((_stra__GetGlobalStorageAttributes*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _stra__GetGlobalStorageAttributes[n]; + if (size) + *size = n * sizeof(_stra__GetGlobalStorageAttributes); + for (int i = 0; i < n; i++) + ((_stra__GetGlobalStorageAttributes*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_stra__GetGlobalStorageAttributes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__stra__GetGlobalStorageAttributes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _stra__GetGlobalStorageAttributes %p -> %p\n", q, p)); + *(_stra__GetGlobalStorageAttributes*)p = *(_stra__GetGlobalStorageAttributes*)q; +} + +void stra__StorageApplicationAttributesType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostra__StorageSnrpApplicationAttributeType(soap, &((stra__StorageApplicationAttributesType*)this)->ApplicationAttr); + soap_embedded(soap, &((stra__StorageApplicationAttributesType*)this)->CurrentAllocationSize, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((stra__StorageApplicationAttributesType*)this)->ActiveSession, SOAP_TYPE_bool); + soap_embedded(soap, &((stra__StorageApplicationAttributesType*)this)->Partner, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void stra__StorageApplicationAttributesType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, &((stra__StorageApplicationAttributesType*)this)->AttrType); + ((stra__StorageApplicationAttributesType*)this)->ApplicationAttr = NULL; + soap_default_unsignedInt(soap, &((stra__StorageApplicationAttributesType*)this)->CurrentAllocationSize); + soap_default_bool(soap, &((stra__StorageApplicationAttributesType*)this)->ActiveSession); + soap_default_bool(soap, &((stra__StorageApplicationAttributesType*)this)->Partner); + /* transient soap skipped */ +} + +int stra__StorageApplicationAttributesType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__StorageApplicationAttributesType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__StorageApplicationAttributesType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__StorageApplicationAttributesType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageApplicationAttributesType(struct soap *soap, const char *tag, int id, const stra__StorageApplicationAttributesType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__StorageApplicationAttributesType), type); + soap_out_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, "stra:AttrType", -1, &(((stra__StorageApplicationAttributesType*)a)->AttrType), ""); + soap_out_PointerTostra__StorageSnrpApplicationAttributeType(soap, "stra:ApplicationAttr", -1, &(((stra__StorageApplicationAttributesType*)a)->ApplicationAttr), ""); + soap_out_unsignedInt(soap, "stra:CurrentAllocationSize", -1, &(((stra__StorageApplicationAttributesType*)a)->CurrentAllocationSize), ""); + soap_out_bool(soap, "stra:ActiveSession", -1, &(((stra__StorageApplicationAttributesType*)a)->ActiveSession), ""); + soap_out_bool(soap, "stra:Partner", -1, &(((stra__StorageApplicationAttributesType*)a)->Partner), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__StorageApplicationAttributesType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__StorageApplicationAttributesType(soap, this, tag, type); +} + +SOAP_FMAC3 stra__StorageApplicationAttributesType * SOAP_FMAC4 soap_get_stra__StorageApplicationAttributesType(struct soap *soap, stra__StorageApplicationAttributesType *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageApplicationAttributesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__StorageApplicationAttributesType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__StorageApplicationAttributesType(soap, tag, this, type); +} + +SOAP_FMAC3 stra__StorageApplicationAttributesType * SOAP_FMAC4 soap_in_stra__StorageApplicationAttributesType(struct soap *soap, const char *tag, stra__StorageApplicationAttributesType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__StorageApplicationAttributesType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__StorageApplicationAttributesType, sizeof(stra__StorageApplicationAttributesType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__StorageApplicationAttributesType) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__StorageApplicationAttributesType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AttrType1 = 1, soap_flag_ApplicationAttr1 = 1, soap_flag_CurrentAllocationSize1 = 1, soap_flag_ActiveSession1 = 1, soap_flag_Partner1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AttrType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, "stra:AttrType", &(((stra__StorageApplicationAttributesType*)a)->AttrType), "stra:ISVS_APP_ATTR_TYPE")) + { soap_flag_AttrType1--; + continue; + } + if (soap_flag_ApplicationAttr1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageSnrpApplicationAttributeType(soap, "stra:ApplicationAttr", &(((stra__StorageApplicationAttributesType*)a)->ApplicationAttr), "stra:StorageSnrpApplicationAttributeType")) + { soap_flag_ApplicationAttr1--; + continue; + } + if (soap_flag_CurrentAllocationSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:CurrentAllocationSize", &(((stra__StorageApplicationAttributesType*)a)->CurrentAllocationSize), "xsd:unsignedInt")) + { soap_flag_CurrentAllocationSize1--; + continue; + } + if (soap_flag_ActiveSession1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "stra:ActiveSession", &(((stra__StorageApplicationAttributesType*)a)->ActiveSession), "xsd:boolean")) + { soap_flag_ActiveSession1--; + continue; + } + if (soap_flag_Partner1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "stra:Partner", &(((stra__StorageApplicationAttributesType*)a)->Partner), "xsd:boolean")) + { soap_flag_Partner1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AttrType1 > 0 || soap_flag_ApplicationAttr1 > 0 || soap_flag_CurrentAllocationSize1 > 0 || soap_flag_ActiveSession1 > 0 || soap_flag_Partner1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__StorageApplicationAttributesType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__StorageApplicationAttributesType, 0, sizeof(stra__StorageApplicationAttributesType), 0, soap_copy_stra__StorageApplicationAttributesType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__StorageApplicationAttributesType * SOAP_FMAC6 soap_new_stra__StorageApplicationAttributesType(struct soap *soap, int n) +{ return soap_instantiate_stra__StorageApplicationAttributesType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageApplicationAttributesType(struct soap *soap, stra__StorageApplicationAttributesType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__StorageApplicationAttributesType * SOAP_FMAC4 soap_instantiate_stra__StorageApplicationAttributesType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__StorageApplicationAttributesType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__StorageApplicationAttributesType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__StorageApplicationAttributesType; + if (size) + *size = sizeof(stra__StorageApplicationAttributesType); + ((stra__StorageApplicationAttributesType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__StorageApplicationAttributesType[n]; + if (size) + *size = n * sizeof(stra__StorageApplicationAttributesType); + for (int i = 0; i < n; i++) + ((stra__StorageApplicationAttributesType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__StorageApplicationAttributesType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageApplicationAttributesType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__StorageApplicationAttributesType %p -> %p\n", q, p)); + *(stra__StorageApplicationAttributesType*)p = *(stra__StorageApplicationAttributesType*)q; +} + +void stra__StorageSnrpApplicationAttributeType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostra__GUID(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->UUID); + soap_embedded(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->VendorName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->VendorName); + soap_embedded(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->ApplicationName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->ApplicationName); + soap_embedded(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->EnterpriseName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->EnterpriseName); + /* transient soap skipped */ +} + +void stra__StorageSnrpApplicationAttributeType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((stra__StorageSnrpApplicationAttributeType*)this)->UUID = NULL; + soap_default_std__string(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->VendorName); + soap_default_std__string(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->ApplicationName); + soap_default_std__string(soap, &((stra__StorageSnrpApplicationAttributeType*)this)->EnterpriseName); + /* transient soap skipped */ +} + +int stra__StorageSnrpApplicationAttributeType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__StorageSnrpApplicationAttributeType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__StorageSnrpApplicationAttributeType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__StorageSnrpApplicationAttributeType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageSnrpApplicationAttributeType(struct soap *soap, const char *tag, int id, const stra__StorageSnrpApplicationAttributeType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__StorageSnrpApplicationAttributeType), type); + soap_out_PointerTostra__GUID(soap, "stra:UUID", -1, &(((stra__StorageSnrpApplicationAttributeType*)a)->UUID), ""); + soap_out_std__string(soap, "stra:VendorName", -1, &(((stra__StorageSnrpApplicationAttributeType*)a)->VendorName), ""); + soap_out_std__string(soap, "stra:ApplicationName", -1, &(((stra__StorageSnrpApplicationAttributeType*)a)->ApplicationName), ""); + soap_out_std__string(soap, "stra:EnterpriseName", -1, &(((stra__StorageSnrpApplicationAttributeType*)a)->EnterpriseName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__StorageSnrpApplicationAttributeType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__StorageSnrpApplicationAttributeType(soap, this, tag, type); +} + +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType * SOAP_FMAC4 soap_get_stra__StorageSnrpApplicationAttributeType(struct soap *soap, stra__StorageSnrpApplicationAttributeType *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageSnrpApplicationAttributeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__StorageSnrpApplicationAttributeType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__StorageSnrpApplicationAttributeType(soap, tag, this, type); +} + +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType * SOAP_FMAC4 soap_in_stra__StorageSnrpApplicationAttributeType(struct soap *soap, const char *tag, stra__StorageSnrpApplicationAttributeType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__StorageSnrpApplicationAttributeType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__StorageSnrpApplicationAttributeType, sizeof(stra__StorageSnrpApplicationAttributeType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__StorageSnrpApplicationAttributeType) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__StorageSnrpApplicationAttributeType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_UUID1 = 1, soap_flag_VendorName1 = 1, soap_flag_ApplicationName1 = 1, soap_flag_EnterpriseName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_UUID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__GUID(soap, "stra:UUID", &(((stra__StorageSnrpApplicationAttributeType*)a)->UUID), "stra:GUID")) + { soap_flag_UUID1--; + continue; + } + if (soap_flag_VendorName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "stra:VendorName", &(((stra__StorageSnrpApplicationAttributeType*)a)->VendorName), "xsd:string")) + { soap_flag_VendorName1--; + continue; + } + if (soap_flag_ApplicationName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "stra:ApplicationName", &(((stra__StorageSnrpApplicationAttributeType*)a)->ApplicationName), "xsd:string")) + { soap_flag_ApplicationName1--; + continue; + } + if (soap_flag_EnterpriseName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "stra:EnterpriseName", &(((stra__StorageSnrpApplicationAttributeType*)a)->EnterpriseName), "xsd:string")) + { soap_flag_EnterpriseName1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_UUID1 > 0 || soap_flag_VendorName1 > 0 || soap_flag_ApplicationName1 > 0 || soap_flag_EnterpriseName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__StorageSnrpApplicationAttributeType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__StorageSnrpApplicationAttributeType, 0, sizeof(stra__StorageSnrpApplicationAttributeType), 0, soap_copy_stra__StorageSnrpApplicationAttributeType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__StorageSnrpApplicationAttributeType * SOAP_FMAC6 soap_new_stra__StorageSnrpApplicationAttributeType(struct soap *soap, int n) +{ return soap_instantiate_stra__StorageSnrpApplicationAttributeType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageSnrpApplicationAttributeType(struct soap *soap, stra__StorageSnrpApplicationAttributeType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType * SOAP_FMAC4 soap_instantiate_stra__StorageSnrpApplicationAttributeType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__StorageSnrpApplicationAttributeType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__StorageSnrpApplicationAttributeType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__StorageSnrpApplicationAttributeType; + if (size) + *size = sizeof(stra__StorageSnrpApplicationAttributeType); + ((stra__StorageSnrpApplicationAttributeType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__StorageSnrpApplicationAttributeType[n]; + if (size) + *size = n * sizeof(stra__StorageSnrpApplicationAttributeType); + for (int i = 0; i < n; i++) + ((stra__StorageSnrpApplicationAttributeType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__StorageSnrpApplicationAttributeType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageSnrpApplicationAttributeType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__StorageSnrpApplicationAttributeType %p -> %p\n", q, p)); + *(stra__StorageSnrpApplicationAttributeType*)p = *(stra__StorageSnrpApplicationAttributeType*)q; +} + +void stra__StorageApplicationHandleListType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfstra__StorageApplicationHandleType(soap, &((stra__StorageApplicationHandleListType*)this)->Handle); + /* transient soap skipped */ +} + +void stra__StorageApplicationHandleListType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfstra__StorageApplicationHandleType(soap, &((stra__StorageApplicationHandleListType*)this)->Handle); + /* transient soap skipped */ +} + +int stra__StorageApplicationHandleListType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__StorageApplicationHandleListType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__StorageApplicationHandleListType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__StorageApplicationHandleListType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageApplicationHandleListType(struct soap *soap, const char *tag, int id, const stra__StorageApplicationHandleListType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__StorageApplicationHandleListType), type); + soap_out_std__vectorTemplateOfstra__StorageApplicationHandleType(soap, "stra:Handle", -1, &(((stra__StorageApplicationHandleListType*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__StorageApplicationHandleListType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__StorageApplicationHandleListType(soap, this, tag, type); +} + +SOAP_FMAC3 stra__StorageApplicationHandleListType * SOAP_FMAC4 soap_get_stra__StorageApplicationHandleListType(struct soap *soap, stra__StorageApplicationHandleListType *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageApplicationHandleListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__StorageApplicationHandleListType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__StorageApplicationHandleListType(soap, tag, this, type); +} + +SOAP_FMAC3 stra__StorageApplicationHandleListType * SOAP_FMAC4 soap_in_stra__StorageApplicationHandleListType(struct soap *soap, const char *tag, stra__StorageApplicationHandleListType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__StorageApplicationHandleListType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__StorageApplicationHandleListType, sizeof(stra__StorageApplicationHandleListType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__StorageApplicationHandleListType) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__StorageApplicationHandleListType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfstra__StorageApplicationHandleType(soap, "stra:Handle", &(((stra__StorageApplicationHandleListType*)a)->Handle), "stra:StorageApplicationHandleType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((stra__StorageApplicationHandleListType*)a)->Handle.size() > 32)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__StorageApplicationHandleListType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__StorageApplicationHandleListType, 0, sizeof(stra__StorageApplicationHandleListType), 0, soap_copy_stra__StorageApplicationHandleListType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__StorageApplicationHandleListType * SOAP_FMAC6 soap_new_stra__StorageApplicationHandleListType(struct soap *soap, int n) +{ return soap_instantiate_stra__StorageApplicationHandleListType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageApplicationHandleListType(struct soap *soap, stra__StorageApplicationHandleListType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__StorageApplicationHandleListType * SOAP_FMAC4 soap_instantiate_stra__StorageApplicationHandleListType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__StorageApplicationHandleListType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__StorageApplicationHandleListType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__StorageApplicationHandleListType; + if (size) + *size = sizeof(stra__StorageApplicationHandleListType); + ((stra__StorageApplicationHandleListType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__StorageApplicationHandleListType[n]; + if (size) + *size = n * sizeof(stra__StorageApplicationHandleListType); + for (int i = 0; i < n; i++) + ((stra__StorageApplicationHandleListType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__StorageApplicationHandleListType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageApplicationHandleListType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__StorageApplicationHandleListType %p -> %p\n", q, p)); + *(stra__StorageApplicationHandleListType*)p = *(stra__StorageApplicationHandleListType*)q; +} + +void stra__GlobalStorageAttributesType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->TotalStorage, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->TotalAllocatedStorage, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->MaxPartnerStorage, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->TotalPartnerAllocatedStorage, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->MaxNonPartnerStorage, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->MaxFpaclEntries, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->MaxAslEntries, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->MaxEaclEntries, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->MaxGroupsPerBlock, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->MaxMembersPerGroup, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((stra__GlobalStorageAttributesType*)this)->MaxNonPartnerTotalAllocationSize, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void stra__GlobalStorageAttributesType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((stra__GlobalStorageAttributesType*)this)->TotalStorage); + soap_default_unsignedInt(soap, &((stra__GlobalStorageAttributesType*)this)->TotalAllocatedStorage); + soap_default_unsignedInt(soap, &((stra__GlobalStorageAttributesType*)this)->MaxPartnerStorage); + soap_default_unsignedInt(soap, &((stra__GlobalStorageAttributesType*)this)->TotalPartnerAllocatedStorage); + soap_default_unsignedInt(soap, &((stra__GlobalStorageAttributesType*)this)->MaxNonPartnerStorage); + soap_default_unsignedShort(soap, &((stra__GlobalStorageAttributesType*)this)->MaxFpaclEntries); + soap_default_unsignedShort(soap, &((stra__GlobalStorageAttributesType*)this)->MaxAslEntries); + soap_default_unsignedShort(soap, &((stra__GlobalStorageAttributesType*)this)->MaxEaclEntries); + soap_default_unsignedShort(soap, &((stra__GlobalStorageAttributesType*)this)->MaxGroupsPerBlock); + soap_default_unsignedShort(soap, &((stra__GlobalStorageAttributesType*)this)->MaxMembersPerGroup); + soap_default_unsignedShort(soap, &((stra__GlobalStorageAttributesType*)this)->MaxNonPartnerTotalAllocationSize); + /* transient soap skipped */ +} + +int stra__GlobalStorageAttributesType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__GlobalStorageAttributesType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__GlobalStorageAttributesType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__GlobalStorageAttributesType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__GlobalStorageAttributesType(struct soap *soap, const char *tag, int id, const stra__GlobalStorageAttributesType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__GlobalStorageAttributesType), type); + soap_out_unsignedInt(soap, "stra:TotalStorage", -1, &(((stra__GlobalStorageAttributesType*)a)->TotalStorage), ""); + soap_out_unsignedInt(soap, "stra:TotalAllocatedStorage", -1, &(((stra__GlobalStorageAttributesType*)a)->TotalAllocatedStorage), ""); + soap_out_unsignedInt(soap, "stra:MaxPartnerStorage", -1, &(((stra__GlobalStorageAttributesType*)a)->MaxPartnerStorage), ""); + soap_out_unsignedInt(soap, "stra:TotalPartnerAllocatedStorage", -1, &(((stra__GlobalStorageAttributesType*)a)->TotalPartnerAllocatedStorage), ""); + soap_out_unsignedInt(soap, "stra:MaxNonPartnerStorage", -1, &(((stra__GlobalStorageAttributesType*)a)->MaxNonPartnerStorage), ""); + soap_out_unsignedShort(soap, "stra:MaxFpaclEntries", -1, &(((stra__GlobalStorageAttributesType*)a)->MaxFpaclEntries), ""); + soap_out_unsignedShort(soap, "stra:MaxAslEntries", -1, &(((stra__GlobalStorageAttributesType*)a)->MaxAslEntries), ""); + soap_out_unsignedShort(soap, "stra:MaxEaclEntries", -1, &(((stra__GlobalStorageAttributesType*)a)->MaxEaclEntries), ""); + soap_out_unsignedShort(soap, "stra:MaxGroupsPerBlock", -1, &(((stra__GlobalStorageAttributesType*)a)->MaxGroupsPerBlock), ""); + soap_out_unsignedShort(soap, "stra:MaxMembersPerGroup", -1, &(((stra__GlobalStorageAttributesType*)a)->MaxMembersPerGroup), ""); + soap_out_unsignedShort(soap, "stra:MaxNonPartnerTotalAllocationSize", -1, &(((stra__GlobalStorageAttributesType*)a)->MaxNonPartnerTotalAllocationSize), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__GlobalStorageAttributesType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__GlobalStorageAttributesType(soap, this, tag, type); +} + +SOAP_FMAC3 stra__GlobalStorageAttributesType * SOAP_FMAC4 soap_get_stra__GlobalStorageAttributesType(struct soap *soap, stra__GlobalStorageAttributesType *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__GlobalStorageAttributesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__GlobalStorageAttributesType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__GlobalStorageAttributesType(soap, tag, this, type); +} + +SOAP_FMAC3 stra__GlobalStorageAttributesType * SOAP_FMAC4 soap_in_stra__GlobalStorageAttributesType(struct soap *soap, const char *tag, stra__GlobalStorageAttributesType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__GlobalStorageAttributesType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__GlobalStorageAttributesType, sizeof(stra__GlobalStorageAttributesType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__GlobalStorageAttributesType) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__GlobalStorageAttributesType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_TotalStorage1 = 1, soap_flag_TotalAllocatedStorage1 = 1, soap_flag_MaxPartnerStorage1 = 1, soap_flag_TotalPartnerAllocatedStorage1 = 1, soap_flag_MaxNonPartnerStorage1 = 1, soap_flag_MaxFpaclEntries1 = 1, soap_flag_MaxAslEntries1 = 1, soap_flag_MaxEaclEntries1 = 1, soap_flag_MaxGroupsPerBlock1 = 1, soap_flag_MaxMembersPerGroup1 = 1, soap_flag_MaxNonPartnerTotalAllocationSize1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_TotalStorage1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:TotalStorage", &(((stra__GlobalStorageAttributesType*)a)->TotalStorage), "xsd:unsignedInt")) + { soap_flag_TotalStorage1--; + continue; + } + if (soap_flag_TotalAllocatedStorage1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:TotalAllocatedStorage", &(((stra__GlobalStorageAttributesType*)a)->TotalAllocatedStorage), "xsd:unsignedInt")) + { soap_flag_TotalAllocatedStorage1--; + continue; + } + if (soap_flag_MaxPartnerStorage1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:MaxPartnerStorage", &(((stra__GlobalStorageAttributesType*)a)->MaxPartnerStorage), "xsd:unsignedInt")) + { soap_flag_MaxPartnerStorage1--; + continue; + } + if (soap_flag_TotalPartnerAllocatedStorage1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:TotalPartnerAllocatedStorage", &(((stra__GlobalStorageAttributesType*)a)->TotalPartnerAllocatedStorage), "xsd:unsignedInt")) + { soap_flag_TotalPartnerAllocatedStorage1--; + continue; + } + if (soap_flag_MaxNonPartnerStorage1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:MaxNonPartnerStorage", &(((stra__GlobalStorageAttributesType*)a)->MaxNonPartnerStorage), "xsd:unsignedInt")) + { soap_flag_MaxNonPartnerStorage1--; + continue; + } + if (soap_flag_MaxFpaclEntries1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:MaxFpaclEntries", &(((stra__GlobalStorageAttributesType*)a)->MaxFpaclEntries), "xsd:unsignedShort")) + { soap_flag_MaxFpaclEntries1--; + continue; + } + if (soap_flag_MaxAslEntries1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:MaxAslEntries", &(((stra__GlobalStorageAttributesType*)a)->MaxAslEntries), "xsd:unsignedShort")) + { soap_flag_MaxAslEntries1--; + continue; + } + if (soap_flag_MaxEaclEntries1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:MaxEaclEntries", &(((stra__GlobalStorageAttributesType*)a)->MaxEaclEntries), "xsd:unsignedShort")) + { soap_flag_MaxEaclEntries1--; + continue; + } + if (soap_flag_MaxGroupsPerBlock1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:MaxGroupsPerBlock", &(((stra__GlobalStorageAttributesType*)a)->MaxGroupsPerBlock), "xsd:unsignedShort")) + { soap_flag_MaxGroupsPerBlock1--; + continue; + } + if (soap_flag_MaxMembersPerGroup1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:MaxMembersPerGroup", &(((stra__GlobalStorageAttributesType*)a)->MaxMembersPerGroup), "xsd:unsignedShort")) + { soap_flag_MaxMembersPerGroup1--; + continue; + } + if (soap_flag_MaxNonPartnerTotalAllocationSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "stra:MaxNonPartnerTotalAllocationSize", &(((stra__GlobalStorageAttributesType*)a)->MaxNonPartnerTotalAllocationSize), "xsd:unsignedShort")) + { soap_flag_MaxNonPartnerTotalAllocationSize1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_TotalStorage1 > 0 || soap_flag_TotalAllocatedStorage1 > 0 || soap_flag_MaxPartnerStorage1 > 0 || soap_flag_TotalPartnerAllocatedStorage1 > 0 || soap_flag_MaxNonPartnerStorage1 > 0 || soap_flag_MaxFpaclEntries1 > 0 || soap_flag_MaxAslEntries1 > 0 || soap_flag_MaxEaclEntries1 > 0 || soap_flag_MaxGroupsPerBlock1 > 0 || soap_flag_MaxMembersPerGroup1 > 0 || soap_flag_MaxNonPartnerTotalAllocationSize1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__GlobalStorageAttributesType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__GlobalStorageAttributesType, 0, sizeof(stra__GlobalStorageAttributesType), 0, soap_copy_stra__GlobalStorageAttributesType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__GlobalStorageAttributesType * SOAP_FMAC6 soap_new_stra__GlobalStorageAttributesType(struct soap *soap, int n) +{ return soap_instantiate_stra__GlobalStorageAttributesType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__GlobalStorageAttributesType(struct soap *soap, stra__GlobalStorageAttributesType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__GlobalStorageAttributesType * SOAP_FMAC4 soap_instantiate_stra__GlobalStorageAttributesType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__GlobalStorageAttributesType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__GlobalStorageAttributesType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__GlobalStorageAttributesType; + if (size) + *size = sizeof(stra__GlobalStorageAttributesType); + ((stra__GlobalStorageAttributesType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__GlobalStorageAttributesType[n]; + if (size) + *size = n * sizeof(stra__GlobalStorageAttributesType); + for (int i = 0; i < n; i++) + ((stra__GlobalStorageAttributesType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__GlobalStorageAttributesType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__GlobalStorageAttributesType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__GlobalStorageAttributesType %p -> %p\n", q, p)); + *(stra__GlobalStorageAttributesType*)p = *(stra__GlobalStorageAttributesType*)q; +} + +void stra__GUID::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfunsignedByte(soap, &((stra__GUID*)this)->Byte); + /* transient soap skipped */ +} + +void stra__GUID::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfunsignedByte(soap, &((stra__GUID*)this)->Byte); + /* transient soap skipped */ +} + +int stra__GUID::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__GUID); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__GUID::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__GUID(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__GUID(struct soap *soap, const char *tag, int id, const stra__GUID *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__GUID), type); + soap_out_std__vectorTemplateOfunsignedByte(soap, "stra:Byte", -1, &(((stra__GUID*)a)->Byte), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__GUID::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__GUID(soap, this, tag, type); +} + +SOAP_FMAC3 stra__GUID * SOAP_FMAC4 soap_get_stra__GUID(struct soap *soap, stra__GUID *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__GUID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__GUID::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__GUID(soap, tag, this, type); +} + +SOAP_FMAC3 stra__GUID * SOAP_FMAC4 soap_in_stra__GUID(struct soap *soap, const char *tag, stra__GUID *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__GUID *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__GUID, sizeof(stra__GUID), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__GUID) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__GUID *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedByte(soap, "stra:Byte", &(((stra__GUID*)a)->Byte), "xsd:unsignedByte")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((stra__GUID*)a)->Byte.size() < 16 || ((stra__GUID*)a)->Byte.size() > 16)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__GUID *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__GUID, 0, sizeof(stra__GUID), 0, soap_copy_stra__GUID); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__GUID * SOAP_FMAC6 soap_new_stra__GUID(struct soap *soap, int n) +{ return soap_instantiate_stra__GUID(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__GUID(struct soap *soap, stra__GUID *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__GUID * SOAP_FMAC4 soap_instantiate_stra__GUID(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__GUID(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__GUID, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__GUID; + if (size) + *size = sizeof(stra__GUID); + ((stra__GUID*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__GUID[n]; + if (size) + *size = n * sizeof(stra__GUID); + for (int i = 0; i < n; i++) + ((stra__GUID*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__GUID*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__GUID(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__GUID %p -> %p\n", q, p)); + *(stra__GUID*)p = *(stra__GUID*)q; +} + +void stra__StorageAllocEntryHandleListType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfstra__StorageAllocEntryHandleType(soap, &((stra__StorageAllocEntryHandleListType*)this)->Handle); + /* transient soap skipped */ +} + +void stra__StorageAllocEntryHandleListType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfstra__StorageAllocEntryHandleType(soap, &((stra__StorageAllocEntryHandleListType*)this)->Handle); + /* transient soap skipped */ +} + +int stra__StorageAllocEntryHandleListType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__StorageAllocEntryHandleListType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__StorageAllocEntryHandleListType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__StorageAllocEntryHandleListType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageAllocEntryHandleListType(struct soap *soap, const char *tag, int id, const stra__StorageAllocEntryHandleListType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__StorageAllocEntryHandleListType), type); + soap_out_std__vectorTemplateOfstra__StorageAllocEntryHandleType(soap, "stra:Handle", -1, &(((stra__StorageAllocEntryHandleListType*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__StorageAllocEntryHandleListType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__StorageAllocEntryHandleListType(soap, this, tag, type); +} + +SOAP_FMAC3 stra__StorageAllocEntryHandleListType * SOAP_FMAC4 soap_get_stra__StorageAllocEntryHandleListType(struct soap *soap, stra__StorageAllocEntryHandleListType *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageAllocEntryHandleListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__StorageAllocEntryHandleListType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__StorageAllocEntryHandleListType(soap, tag, this, type); +} + +SOAP_FMAC3 stra__StorageAllocEntryHandleListType * SOAP_FMAC4 soap_in_stra__StorageAllocEntryHandleListType(struct soap *soap, const char *tag, stra__StorageAllocEntryHandleListType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__StorageAllocEntryHandleListType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__StorageAllocEntryHandleListType, sizeof(stra__StorageAllocEntryHandleListType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__StorageAllocEntryHandleListType) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__StorageAllocEntryHandleListType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfstra__StorageAllocEntryHandleType(soap, "stra:Handle", &(((stra__StorageAllocEntryHandleListType*)a)->Handle), "stra:StorageAllocEntryHandleType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((stra__StorageAllocEntryHandleListType*)a)->Handle.size() > 32)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__StorageAllocEntryHandleListType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__StorageAllocEntryHandleListType, 0, sizeof(stra__StorageAllocEntryHandleListType), 0, soap_copy_stra__StorageAllocEntryHandleListType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__StorageAllocEntryHandleListType * SOAP_FMAC6 soap_new_stra__StorageAllocEntryHandleListType(struct soap *soap, int n) +{ return soap_instantiate_stra__StorageAllocEntryHandleListType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageAllocEntryHandleListType(struct soap *soap, stra__StorageAllocEntryHandleListType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__StorageAllocEntryHandleListType * SOAP_FMAC4 soap_instantiate_stra__StorageAllocEntryHandleListType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__StorageAllocEntryHandleListType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__StorageAllocEntryHandleListType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__StorageAllocEntryHandleListType; + if (size) + *size = sizeof(stra__StorageAllocEntryHandleListType); + ((stra__StorageAllocEntryHandleListType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__StorageAllocEntryHandleListType[n]; + if (size) + *size = n * sizeof(stra__StorageAllocEntryHandleListType); + for (int i = 0; i < n; i++) + ((stra__StorageAllocEntryHandleListType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__StorageAllocEntryHandleListType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageAllocEntryHandleListType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__StorageAllocEntryHandleListType %p -> %p\n", q, p)); + *(stra__StorageAllocEntryHandleListType*)p = *(stra__StorageAllocEntryHandleListType*)q; +} + +void stra__StorageAllocSnrpEntryType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((stra__StorageAllocSnrpEntryType*)this)->ApplicationName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((stra__StorageAllocSnrpEntryType*)this)->ApplicationName); + soap_embedded(soap, &((stra__StorageAllocSnrpEntryType*)this)->VendorName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((stra__StorageAllocSnrpEntryType*)this)->VendorName); + /* transient soap skipped */ +} + +void stra__StorageAllocSnrpEntryType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((stra__StorageAllocSnrpEntryType*)this)->ApplicationName); + soap_default_std__string(soap, &((stra__StorageAllocSnrpEntryType*)this)->VendorName); + /* transient soap skipped */ +} + +int stra__StorageAllocSnrpEntryType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__StorageAllocSnrpEntryType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__StorageAllocSnrpEntryType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__StorageAllocSnrpEntryType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageAllocSnrpEntryType(struct soap *soap, const char *tag, int id, const stra__StorageAllocSnrpEntryType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__StorageAllocSnrpEntryType), type); + soap_out_std__string(soap, "stra:ApplicationName", -1, &(((stra__StorageAllocSnrpEntryType*)a)->ApplicationName), ""); + soap_out_std__string(soap, "stra:VendorName", -1, &(((stra__StorageAllocSnrpEntryType*)a)->VendorName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__StorageAllocSnrpEntryType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__StorageAllocSnrpEntryType(soap, this, tag, type); +} + +SOAP_FMAC3 stra__StorageAllocSnrpEntryType * SOAP_FMAC4 soap_get_stra__StorageAllocSnrpEntryType(struct soap *soap, stra__StorageAllocSnrpEntryType *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageAllocSnrpEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__StorageAllocSnrpEntryType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__StorageAllocSnrpEntryType(soap, tag, this, type); +} + +SOAP_FMAC3 stra__StorageAllocSnrpEntryType * SOAP_FMAC4 soap_in_stra__StorageAllocSnrpEntryType(struct soap *soap, const char *tag, stra__StorageAllocSnrpEntryType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__StorageAllocSnrpEntryType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__StorageAllocSnrpEntryType, sizeof(stra__StorageAllocSnrpEntryType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__StorageAllocSnrpEntryType) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__StorageAllocSnrpEntryType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ApplicationName1 = 1, soap_flag_VendorName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ApplicationName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "stra:ApplicationName", &(((stra__StorageAllocSnrpEntryType*)a)->ApplicationName), "xsd:string")) + { soap_flag_ApplicationName1--; + continue; + } + if (soap_flag_VendorName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "stra:VendorName", &(((stra__StorageAllocSnrpEntryType*)a)->VendorName), "xsd:string")) + { soap_flag_VendorName1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ApplicationName1 > 0 || soap_flag_VendorName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__StorageAllocSnrpEntryType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__StorageAllocSnrpEntryType, 0, sizeof(stra__StorageAllocSnrpEntryType), 0, soap_copy_stra__StorageAllocSnrpEntryType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__StorageAllocSnrpEntryType * SOAP_FMAC6 soap_new_stra__StorageAllocSnrpEntryType(struct soap *soap, int n) +{ return soap_instantiate_stra__StorageAllocSnrpEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageAllocSnrpEntryType(struct soap *soap, stra__StorageAllocSnrpEntryType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__StorageAllocSnrpEntryType * SOAP_FMAC4 soap_instantiate_stra__StorageAllocSnrpEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__StorageAllocSnrpEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__StorageAllocSnrpEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__StorageAllocSnrpEntryType; + if (size) + *size = sizeof(stra__StorageAllocSnrpEntryType); + ((stra__StorageAllocSnrpEntryType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__StorageAllocSnrpEntryType[n]; + if (size) + *size = n * sizeof(stra__StorageAllocSnrpEntryType); + for (int i = 0; i < n; i++) + ((stra__StorageAllocSnrpEntryType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__StorageAllocSnrpEntryType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageAllocSnrpEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__StorageAllocSnrpEntryType %p -> %p\n", q, p)); + *(stra__StorageAllocSnrpEntryType*)p = *(stra__StorageAllocSnrpEntryType*)q; +} + +void stra__StorageAllocEntryType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostra__StorageAllocSnrpEntryType(soap, &((stra__StorageAllocEntryType*)this)->StorageAllocSnrpEntry); + soap_embedded(soap, &((stra__StorageAllocEntryType*)this)->IsPartner, SOAP_TYPE_bool); + soap_embedded(soap, &((stra__StorageAllocEntryType*)this)->TotalAllocationSize, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void stra__StorageAllocEntryType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, &((stra__StorageAllocEntryType*)this)->AttrType); + ((stra__StorageAllocEntryType*)this)->StorageAllocSnrpEntry = NULL; + soap_default_bool(soap, &((stra__StorageAllocEntryType*)this)->IsPartner); + soap_default_unsignedInt(soap, &((stra__StorageAllocEntryType*)this)->TotalAllocationSize); + /* transient soap skipped */ +} + +int stra__StorageAllocEntryType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__StorageAllocEntryType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__StorageAllocEntryType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__StorageAllocEntryType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageAllocEntryType(struct soap *soap, const char *tag, int id, const stra__StorageAllocEntryType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__StorageAllocEntryType), type); + soap_out_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, "stra:AttrType", -1, &(((stra__StorageAllocEntryType*)a)->AttrType), ""); + soap_out_PointerTostra__StorageAllocSnrpEntryType(soap, "stra:StorageAllocSnrpEntry", -1, &(((stra__StorageAllocEntryType*)a)->StorageAllocSnrpEntry), ""); + soap_out_bool(soap, "stra:IsPartner", -1, &(((stra__StorageAllocEntryType*)a)->IsPartner), ""); + soap_out_unsignedInt(soap, "stra:TotalAllocationSize", -1, &(((stra__StorageAllocEntryType*)a)->TotalAllocationSize), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__StorageAllocEntryType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__StorageAllocEntryType(soap, this, tag, type); +} + +SOAP_FMAC3 stra__StorageAllocEntryType * SOAP_FMAC4 soap_get_stra__StorageAllocEntryType(struct soap *soap, stra__StorageAllocEntryType *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageAllocEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__StorageAllocEntryType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__StorageAllocEntryType(soap, tag, this, type); +} + +SOAP_FMAC3 stra__StorageAllocEntryType * SOAP_FMAC4 soap_in_stra__StorageAllocEntryType(struct soap *soap, const char *tag, stra__StorageAllocEntryType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__StorageAllocEntryType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__StorageAllocEntryType, sizeof(stra__StorageAllocEntryType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__StorageAllocEntryType) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__StorageAllocEntryType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AttrType1 = 1, soap_flag_StorageAllocSnrpEntry1 = 1, soap_flag_IsPartner1 = 1, soap_flag_TotalAllocationSize1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AttrType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_stra__ISVS_USCOREAPP_USCOREATTR_USCORETYPE(soap, "stra:AttrType", &(((stra__StorageAllocEntryType*)a)->AttrType), "stra:ISVS_APP_ATTR_TYPE")) + { soap_flag_AttrType1--; + continue; + } + if (soap_flag_StorageAllocSnrpEntry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTostra__StorageAllocSnrpEntryType(soap, "stra:StorageAllocSnrpEntry", &(((stra__StorageAllocEntryType*)a)->StorageAllocSnrpEntry), "stra:StorageAllocSnrpEntryType")) + { soap_flag_StorageAllocSnrpEntry1--; + continue; + } + if (soap_flag_IsPartner1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "stra:IsPartner", &(((stra__StorageAllocEntryType*)a)->IsPartner), "xsd:boolean")) + { soap_flag_IsPartner1--; + continue; + } + if (soap_flag_TotalAllocationSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "stra:TotalAllocationSize", &(((stra__StorageAllocEntryType*)a)->TotalAllocationSize), "xsd:unsignedInt")) + { soap_flag_TotalAllocationSize1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AttrType1 > 0 || soap_flag_StorageAllocSnrpEntry1 > 0 || soap_flag_IsPartner1 > 0 || soap_flag_TotalAllocationSize1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__StorageAllocEntryType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__StorageAllocEntryType, 0, sizeof(stra__StorageAllocEntryType), 0, soap_copy_stra__StorageAllocEntryType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__StorageAllocEntryType * SOAP_FMAC6 soap_new_stra__StorageAllocEntryType(struct soap *soap, int n) +{ return soap_instantiate_stra__StorageAllocEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageAllocEntryType(struct soap *soap, stra__StorageAllocEntryType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__StorageAllocEntryType * SOAP_FMAC4 soap_instantiate_stra__StorageAllocEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__StorageAllocEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__StorageAllocEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__StorageAllocEntryType; + if (size) + *size = sizeof(stra__StorageAllocEntryType); + ((stra__StorageAllocEntryType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__StorageAllocEntryType[n]; + if (size) + *size = n * sizeof(stra__StorageAllocEntryType); + for (int i = 0; i < n; i++) + ((stra__StorageAllocEntryType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__StorageAllocEntryType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageAllocEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__StorageAllocEntryType %p -> %p\n", q, p)); + *(stra__StorageAllocEntryType*)p = *(stra__StorageAllocEntryType*)q; +} + +void stra__StorageEaclEntryHandleListType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfstra__StorageEaclEntryHandleType(soap, &((stra__StorageEaclEntryHandleListType*)this)->Handle); + /* transient soap skipped */ +} + +void stra__StorageEaclEntryHandleListType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfstra__StorageEaclEntryHandleType(soap, &((stra__StorageEaclEntryHandleListType*)this)->Handle); + /* transient soap skipped */ +} + +int stra__StorageEaclEntryHandleListType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__StorageEaclEntryHandleListType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__StorageEaclEntryHandleListType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__StorageEaclEntryHandleListType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageEaclEntryHandleListType(struct soap *soap, const char *tag, int id, const stra__StorageEaclEntryHandleListType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__StorageEaclEntryHandleListType), type); + soap_out_std__vectorTemplateOfstra__StorageEaclEntryHandleType(soap, "stra:Handle", -1, &(((stra__StorageEaclEntryHandleListType*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__StorageEaclEntryHandleListType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__StorageEaclEntryHandleListType(soap, this, tag, type); +} + +SOAP_FMAC3 stra__StorageEaclEntryHandleListType * SOAP_FMAC4 soap_get_stra__StorageEaclEntryHandleListType(struct soap *soap, stra__StorageEaclEntryHandleListType *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageEaclEntryHandleListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__StorageEaclEntryHandleListType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__StorageEaclEntryHandleListType(soap, tag, this, type); +} + +SOAP_FMAC3 stra__StorageEaclEntryHandleListType * SOAP_FMAC4 soap_in_stra__StorageEaclEntryHandleListType(struct soap *soap, const char *tag, stra__StorageEaclEntryHandleListType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__StorageEaclEntryHandleListType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__StorageEaclEntryHandleListType, sizeof(stra__StorageEaclEntryHandleListType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__StorageEaclEntryHandleListType) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__StorageEaclEntryHandleListType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfstra__StorageEaclEntryHandleType(soap, "stra:Handle", &(((stra__StorageEaclEntryHandleListType*)a)->Handle), "stra:StorageEaclEntryHandleType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((stra__StorageEaclEntryHandleListType*)a)->Handle.size() > 8)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__StorageEaclEntryHandleListType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__StorageEaclEntryHandleListType, 0, sizeof(stra__StorageEaclEntryHandleListType), 0, soap_copy_stra__StorageEaclEntryHandleListType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__StorageEaclEntryHandleListType * SOAP_FMAC6 soap_new_stra__StorageEaclEntryHandleListType(struct soap *soap, int n) +{ return soap_instantiate_stra__StorageEaclEntryHandleListType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageEaclEntryHandleListType(struct soap *soap, stra__StorageEaclEntryHandleListType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__StorageEaclEntryHandleListType * SOAP_FMAC4 soap_instantiate_stra__StorageEaclEntryHandleListType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__StorageEaclEntryHandleListType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__StorageEaclEntryHandleListType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__StorageEaclEntryHandleListType; + if (size) + *size = sizeof(stra__StorageEaclEntryHandleListType); + ((stra__StorageEaclEntryHandleListType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__StorageEaclEntryHandleListType[n]; + if (size) + *size = n * sizeof(stra__StorageEaclEntryHandleListType); + for (int i = 0; i < n; i++) + ((stra__StorageEaclEntryHandleListType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__StorageEaclEntryHandleListType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageEaclEntryHandleListType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__StorageEaclEntryHandleListType %p -> %p\n", q, p)); + *(stra__StorageEaclEntryHandleListType*)p = *(stra__StorageEaclEntryHandleListType*)q; +} + +void stra__StorageEaclEntryType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((stra__StorageEaclEntryType*)this)->EnterpriseName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((stra__StorageEaclEntryType*)this)->EnterpriseName); + /* transient soap skipped */ +} + +void stra__StorageEaclEntryType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((stra__StorageEaclEntryType*)this)->EnterpriseName); + /* transient soap skipped */ +} + +int stra__StorageEaclEntryType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_stra__StorageEaclEntryType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int stra__StorageEaclEntryType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_stra__StorageEaclEntryType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_stra__StorageEaclEntryType(struct soap *soap, const char *tag, int id, const stra__StorageEaclEntryType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_stra__StorageEaclEntryType), type); + soap_out_std__string(soap, "stra:EnterpriseName", -1, &(((stra__StorageEaclEntryType*)a)->EnterpriseName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *stra__StorageEaclEntryType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_stra__StorageEaclEntryType(soap, this, tag, type); +} + +SOAP_FMAC3 stra__StorageEaclEntryType * SOAP_FMAC4 soap_get_stra__StorageEaclEntryType(struct soap *soap, stra__StorageEaclEntryType *p, const char *tag, const char *type) +{ + if ((p = soap_in_stra__StorageEaclEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *stra__StorageEaclEntryType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_stra__StorageEaclEntryType(soap, tag, this, type); +} + +SOAP_FMAC3 stra__StorageEaclEntryType * SOAP_FMAC4 soap_in_stra__StorageEaclEntryType(struct soap *soap, const char *tag, stra__StorageEaclEntryType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (stra__StorageEaclEntryType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_stra__StorageEaclEntryType, sizeof(stra__StorageEaclEntryType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_stra__StorageEaclEntryType) + { soap_revert(soap); + *soap->id = '\0'; + return (stra__StorageEaclEntryType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_EnterpriseName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_EnterpriseName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "stra:EnterpriseName", &(((stra__StorageEaclEntryType*)a)->EnterpriseName), "xsd:string")) + { soap_flag_EnterpriseName1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_EnterpriseName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (stra__StorageEaclEntryType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_stra__StorageEaclEntryType, 0, sizeof(stra__StorageEaclEntryType), 0, soap_copy_stra__StorageEaclEntryType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 stra__StorageEaclEntryType * SOAP_FMAC6 soap_new_stra__StorageEaclEntryType(struct soap *soap, int n) +{ return soap_instantiate_stra__StorageEaclEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_stra__StorageEaclEntryType(struct soap *soap, stra__StorageEaclEntryType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 stra__StorageEaclEntryType * SOAP_FMAC4 soap_instantiate_stra__StorageEaclEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_stra__StorageEaclEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_stra__StorageEaclEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new stra__StorageEaclEntryType; + if (size) + *size = sizeof(stra__StorageEaclEntryType); + ((stra__StorageEaclEntryType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new stra__StorageEaclEntryType[n]; + if (size) + *size = n * sizeof(stra__StorageEaclEntryType); + for (int i = 0; i < n; i++) + ((stra__StorageEaclEntryType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (stra__StorageEaclEntryType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_stra__StorageEaclEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying stra__StorageEaclEntryType %p -> %p\n", q, p)); + *(stra__StorageEaclEntryType*)p = *(stra__StorageEaclEntryType*)q; +} + +void _net__Get8021XPxeTimeoutResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__Get8021XPxeTimeoutResponse*)this)->Timeout, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _net__Get8021XPxeTimeoutResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_net__Get8021XPxeTimeoutResponse*)this)->StatusCode); + soap_default_unsignedInt(soap, &((_net__Get8021XPxeTimeoutResponse*)this)->Timeout); + /* transient soap skipped */ +} + +int _net__Get8021XPxeTimeoutResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Get8021XPxeTimeoutResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Get8021XPxeTimeoutResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Get8021XPxeTimeoutResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XPxeTimeoutResponse(struct soap *soap, const char *tag, int id, const _net__Get8021XPxeTimeoutResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Get8021XPxeTimeoutResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__Get8021XPxeTimeoutResponse*)a)->StatusCode), ""); + soap_out_unsignedInt(soap, "net:Timeout", -1, &(((_net__Get8021XPxeTimeoutResponse*)a)->Timeout), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Get8021XPxeTimeoutResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Get8021XPxeTimeoutResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse * SOAP_FMAC4 soap_get__net__Get8021XPxeTimeoutResponse(struct soap *soap, _net__Get8021XPxeTimeoutResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Get8021XPxeTimeoutResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Get8021XPxeTimeoutResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Get8021XPxeTimeoutResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse * SOAP_FMAC4 soap_in__net__Get8021XPxeTimeoutResponse(struct soap *soap, const char *tag, _net__Get8021XPxeTimeoutResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Get8021XPxeTimeoutResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Get8021XPxeTimeoutResponse, sizeof(_net__Get8021XPxeTimeoutResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Get8021XPxeTimeoutResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Get8021XPxeTimeoutResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Timeout1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__Get8021XPxeTimeoutResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Timeout1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "net:Timeout", &(((_net__Get8021XPxeTimeoutResponse*)a)->Timeout), "xsd:unsignedInt")) + { soap_flag_Timeout1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Timeout1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Get8021XPxeTimeoutResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Get8021XPxeTimeoutResponse, 0, sizeof(_net__Get8021XPxeTimeoutResponse), 0, soap_copy__net__Get8021XPxeTimeoutResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Get8021XPxeTimeoutResponse * SOAP_FMAC6 soap_new__net__Get8021XPxeTimeoutResponse(struct soap *soap, int n) +{ return soap_instantiate__net__Get8021XPxeTimeoutResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XPxeTimeoutResponse(struct soap *soap, _net__Get8021XPxeTimeoutResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse * SOAP_FMAC4 soap_instantiate__net__Get8021XPxeTimeoutResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Get8021XPxeTimeoutResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Get8021XPxeTimeoutResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Get8021XPxeTimeoutResponse; + if (size) + *size = sizeof(_net__Get8021XPxeTimeoutResponse); + ((_net__Get8021XPxeTimeoutResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Get8021XPxeTimeoutResponse[n]; + if (size) + *size = n * sizeof(_net__Get8021XPxeTimeoutResponse); + for (int i = 0; i < n; i++) + ((_net__Get8021XPxeTimeoutResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Get8021XPxeTimeoutResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XPxeTimeoutResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Get8021XPxeTimeoutResponse %p -> %p\n", q, p)); + *(_net__Get8021XPxeTimeoutResponse*)p = *(_net__Get8021XPxeTimeoutResponse*)q; +} + +void _net__Get8021XPxeTimeout::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__Get8021XPxeTimeout::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _net__Get8021XPxeTimeout::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Get8021XPxeTimeout); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Get8021XPxeTimeout::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Get8021XPxeTimeout(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XPxeTimeout(struct soap *soap, const char *tag, int id, const _net__Get8021XPxeTimeout *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Get8021XPxeTimeout), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Get8021XPxeTimeout::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Get8021XPxeTimeout(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Get8021XPxeTimeout * SOAP_FMAC4 soap_get__net__Get8021XPxeTimeout(struct soap *soap, _net__Get8021XPxeTimeout *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Get8021XPxeTimeout(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Get8021XPxeTimeout::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Get8021XPxeTimeout(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Get8021XPxeTimeout * SOAP_FMAC4 soap_in__net__Get8021XPxeTimeout(struct soap *soap, const char *tag, _net__Get8021XPxeTimeout *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Get8021XPxeTimeout *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Get8021XPxeTimeout, sizeof(_net__Get8021XPxeTimeout), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Get8021XPxeTimeout) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Get8021XPxeTimeout *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Get8021XPxeTimeout *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Get8021XPxeTimeout, 0, sizeof(_net__Get8021XPxeTimeout), 0, soap_copy__net__Get8021XPxeTimeout); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Get8021XPxeTimeout * SOAP_FMAC6 soap_new__net__Get8021XPxeTimeout(struct soap *soap, int n) +{ return soap_instantiate__net__Get8021XPxeTimeout(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XPxeTimeout(struct soap *soap, _net__Get8021XPxeTimeout *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Get8021XPxeTimeout * SOAP_FMAC4 soap_instantiate__net__Get8021XPxeTimeout(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Get8021XPxeTimeout(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Get8021XPxeTimeout, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Get8021XPxeTimeout; + if (size) + *size = sizeof(_net__Get8021XPxeTimeout); + ((_net__Get8021XPxeTimeout*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Get8021XPxeTimeout[n]; + if (size) + *size = n * sizeof(_net__Get8021XPxeTimeout); + for (int i = 0; i < n; i++) + ((_net__Get8021XPxeTimeout*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Get8021XPxeTimeout*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XPxeTimeout(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Get8021XPxeTimeout %p -> %p\n", q, p)); + *(_net__Get8021XPxeTimeout*)p = *(_net__Get8021XPxeTimeout*)q; +} + +void _net__Set8021XPxeTimeoutResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__Set8021XPxeTimeoutResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_net__Set8021XPxeTimeoutResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _net__Set8021XPxeTimeoutResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Set8021XPxeTimeoutResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Set8021XPxeTimeoutResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Set8021XPxeTimeoutResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XPxeTimeoutResponse(struct soap *soap, const char *tag, int id, const _net__Set8021XPxeTimeoutResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Set8021XPxeTimeoutResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__Set8021XPxeTimeoutResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Set8021XPxeTimeoutResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Set8021XPxeTimeoutResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse * SOAP_FMAC4 soap_get__net__Set8021XPxeTimeoutResponse(struct soap *soap, _net__Set8021XPxeTimeoutResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Set8021XPxeTimeoutResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Set8021XPxeTimeoutResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Set8021XPxeTimeoutResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse * SOAP_FMAC4 soap_in__net__Set8021XPxeTimeoutResponse(struct soap *soap, const char *tag, _net__Set8021XPxeTimeoutResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Set8021XPxeTimeoutResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Set8021XPxeTimeoutResponse, sizeof(_net__Set8021XPxeTimeoutResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Set8021XPxeTimeoutResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Set8021XPxeTimeoutResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__Set8021XPxeTimeoutResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Set8021XPxeTimeoutResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Set8021XPxeTimeoutResponse, 0, sizeof(_net__Set8021XPxeTimeoutResponse), 0, soap_copy__net__Set8021XPxeTimeoutResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Set8021XPxeTimeoutResponse * SOAP_FMAC6 soap_new__net__Set8021XPxeTimeoutResponse(struct soap *soap, int n) +{ return soap_instantiate__net__Set8021XPxeTimeoutResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XPxeTimeoutResponse(struct soap *soap, _net__Set8021XPxeTimeoutResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse * SOAP_FMAC4 soap_instantiate__net__Set8021XPxeTimeoutResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Set8021XPxeTimeoutResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Set8021XPxeTimeoutResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Set8021XPxeTimeoutResponse; + if (size) + *size = sizeof(_net__Set8021XPxeTimeoutResponse); + ((_net__Set8021XPxeTimeoutResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Set8021XPxeTimeoutResponse[n]; + if (size) + *size = n * sizeof(_net__Set8021XPxeTimeoutResponse); + for (int i = 0; i < n; i++) + ((_net__Set8021XPxeTimeoutResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Set8021XPxeTimeoutResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XPxeTimeoutResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Set8021XPxeTimeoutResponse %p -> %p\n", q, p)); + *(_net__Set8021XPxeTimeoutResponse*)p = *(_net__Set8021XPxeTimeoutResponse*)q; +} + +void _net__Set8021XPxeTimeout::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTounsignedInt(soap, &((_net__Set8021XPxeTimeout*)this)->Timeout); + /* transient soap skipped */ +} + +void _net__Set8021XPxeTimeout::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_net__Set8021XPxeTimeout*)this)->Timeout = NULL; + /* transient soap skipped */ +} + +int _net__Set8021XPxeTimeout::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Set8021XPxeTimeout); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Set8021XPxeTimeout::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Set8021XPxeTimeout(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XPxeTimeout(struct soap *soap, const char *tag, int id, const _net__Set8021XPxeTimeout *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Set8021XPxeTimeout), type); + soap_out_PointerTounsignedInt(soap, "net:Timeout", -1, &(((_net__Set8021XPxeTimeout*)a)->Timeout), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Set8021XPxeTimeout::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Set8021XPxeTimeout(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Set8021XPxeTimeout * SOAP_FMAC4 soap_get__net__Set8021XPxeTimeout(struct soap *soap, _net__Set8021XPxeTimeout *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Set8021XPxeTimeout(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Set8021XPxeTimeout::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Set8021XPxeTimeout(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Set8021XPxeTimeout * SOAP_FMAC4 soap_in__net__Set8021XPxeTimeout(struct soap *soap, const char *tag, _net__Set8021XPxeTimeout *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Set8021XPxeTimeout *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Set8021XPxeTimeout, sizeof(_net__Set8021XPxeTimeout), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Set8021XPxeTimeout) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Set8021XPxeTimeout *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Timeout1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Timeout1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedInt(soap, "net:Timeout", &(((_net__Set8021XPxeTimeout*)a)->Timeout), "xsd:unsignedInt")) + { soap_flag_Timeout1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Set8021XPxeTimeout *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Set8021XPxeTimeout, 0, sizeof(_net__Set8021XPxeTimeout), 0, soap_copy__net__Set8021XPxeTimeout); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Set8021XPxeTimeout * SOAP_FMAC6 soap_new__net__Set8021XPxeTimeout(struct soap *soap, int n) +{ return soap_instantiate__net__Set8021XPxeTimeout(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XPxeTimeout(struct soap *soap, _net__Set8021XPxeTimeout *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Set8021XPxeTimeout * SOAP_FMAC4 soap_instantiate__net__Set8021XPxeTimeout(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Set8021XPxeTimeout(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Set8021XPxeTimeout, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Set8021XPxeTimeout; + if (size) + *size = sizeof(_net__Set8021XPxeTimeout); + ((_net__Set8021XPxeTimeout*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Set8021XPxeTimeout[n]; + if (size) + *size = n * sizeof(_net__Set8021XPxeTimeout); + for (int i = 0; i < n; i++) + ((_net__Set8021XPxeTimeout*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Set8021XPxeTimeout*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XPxeTimeout(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Set8021XPxeTimeout %p -> %p\n", q, p)); + *(_net__Set8021XPxeTimeout*)p = *(_net__Set8021XPxeTimeout*)q; +} + +void _net__Get8021XActiveS0Response::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__Get8021XActiveS0Response*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _net__Get8021XActiveS0Response::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_net__Get8021XActiveS0Response*)this)->StatusCode); + soap_default_bool(soap, &((_net__Get8021XActiveS0Response*)this)->Enabled); + /* transient soap skipped */ +} + +int _net__Get8021XActiveS0Response::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Get8021XActiveS0Response); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Get8021XActiveS0Response::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Get8021XActiveS0Response(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XActiveS0Response(struct soap *soap, const char *tag, int id, const _net__Get8021XActiveS0Response *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Get8021XActiveS0Response), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__Get8021XActiveS0Response*)a)->StatusCode), ""); + soap_out_bool(soap, "net:Enabled", -1, &(((_net__Get8021XActiveS0Response*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Get8021XActiveS0Response::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Get8021XActiveS0Response(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Get8021XActiveS0Response * SOAP_FMAC4 soap_get__net__Get8021XActiveS0Response(struct soap *soap, _net__Get8021XActiveS0Response *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Get8021XActiveS0Response(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Get8021XActiveS0Response::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Get8021XActiveS0Response(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Get8021XActiveS0Response * SOAP_FMAC4 soap_in__net__Get8021XActiveS0Response(struct soap *soap, const char *tag, _net__Get8021XActiveS0Response *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Get8021XActiveS0Response *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Get8021XActiveS0Response, sizeof(_net__Get8021XActiveS0Response), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Get8021XActiveS0Response) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Get8021XActiveS0Response *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__Get8021XActiveS0Response*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "net:Enabled", &(((_net__Get8021XActiveS0Response*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Get8021XActiveS0Response *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Get8021XActiveS0Response, 0, sizeof(_net__Get8021XActiveS0Response), 0, soap_copy__net__Get8021XActiveS0Response); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Get8021XActiveS0Response * SOAP_FMAC6 soap_new__net__Get8021XActiveS0Response(struct soap *soap, int n) +{ return soap_instantiate__net__Get8021XActiveS0Response(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XActiveS0Response(struct soap *soap, _net__Get8021XActiveS0Response *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Get8021XActiveS0Response * SOAP_FMAC4 soap_instantiate__net__Get8021XActiveS0Response(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Get8021XActiveS0Response(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Get8021XActiveS0Response, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Get8021XActiveS0Response; + if (size) + *size = sizeof(_net__Get8021XActiveS0Response); + ((_net__Get8021XActiveS0Response*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Get8021XActiveS0Response[n]; + if (size) + *size = n * sizeof(_net__Get8021XActiveS0Response); + for (int i = 0; i < n; i++) + ((_net__Get8021XActiveS0Response*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Get8021XActiveS0Response*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XActiveS0Response(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Get8021XActiveS0Response %p -> %p\n", q, p)); + *(_net__Get8021XActiveS0Response*)p = *(_net__Get8021XActiveS0Response*)q; +} + +void _net__Get8021XActiveS0::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__Get8021XActiveS0::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _net__Get8021XActiveS0::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Get8021XActiveS0); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Get8021XActiveS0::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Get8021XActiveS0(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XActiveS0(struct soap *soap, const char *tag, int id, const _net__Get8021XActiveS0 *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Get8021XActiveS0), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Get8021XActiveS0::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Get8021XActiveS0(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Get8021XActiveS0 * SOAP_FMAC4 soap_get__net__Get8021XActiveS0(struct soap *soap, _net__Get8021XActiveS0 *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Get8021XActiveS0(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Get8021XActiveS0::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Get8021XActiveS0(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Get8021XActiveS0 * SOAP_FMAC4 soap_in__net__Get8021XActiveS0(struct soap *soap, const char *tag, _net__Get8021XActiveS0 *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Get8021XActiveS0 *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Get8021XActiveS0, sizeof(_net__Get8021XActiveS0), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Get8021XActiveS0) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Get8021XActiveS0 *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Get8021XActiveS0 *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Get8021XActiveS0, 0, sizeof(_net__Get8021XActiveS0), 0, soap_copy__net__Get8021XActiveS0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Get8021XActiveS0 * SOAP_FMAC6 soap_new__net__Get8021XActiveS0(struct soap *soap, int n) +{ return soap_instantiate__net__Get8021XActiveS0(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XActiveS0(struct soap *soap, _net__Get8021XActiveS0 *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Get8021XActiveS0 * SOAP_FMAC4 soap_instantiate__net__Get8021XActiveS0(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Get8021XActiveS0(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Get8021XActiveS0, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Get8021XActiveS0; + if (size) + *size = sizeof(_net__Get8021XActiveS0); + ((_net__Get8021XActiveS0*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Get8021XActiveS0[n]; + if (size) + *size = n * sizeof(_net__Get8021XActiveS0); + for (int i = 0; i < n; i++) + ((_net__Get8021XActiveS0*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Get8021XActiveS0*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XActiveS0(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Get8021XActiveS0 %p -> %p\n", q, p)); + *(_net__Get8021XActiveS0*)p = *(_net__Get8021XActiveS0*)q; +} + +void _net__Set8021XActiveS0Response::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__Set8021XActiveS0Response::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_net__Set8021XActiveS0Response*)this)->StatusCode); + /* transient soap skipped */ +} + +int _net__Set8021XActiveS0Response::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Set8021XActiveS0Response); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Set8021XActiveS0Response::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Set8021XActiveS0Response(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XActiveS0Response(struct soap *soap, const char *tag, int id, const _net__Set8021XActiveS0Response *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Set8021XActiveS0Response), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__Set8021XActiveS0Response*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Set8021XActiveS0Response::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Set8021XActiveS0Response(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Set8021XActiveS0Response * SOAP_FMAC4 soap_get__net__Set8021XActiveS0Response(struct soap *soap, _net__Set8021XActiveS0Response *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Set8021XActiveS0Response(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Set8021XActiveS0Response::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Set8021XActiveS0Response(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Set8021XActiveS0Response * SOAP_FMAC4 soap_in__net__Set8021XActiveS0Response(struct soap *soap, const char *tag, _net__Set8021XActiveS0Response *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Set8021XActiveS0Response *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Set8021XActiveS0Response, sizeof(_net__Set8021XActiveS0Response), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Set8021XActiveS0Response) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Set8021XActiveS0Response *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__Set8021XActiveS0Response*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Set8021XActiveS0Response *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Set8021XActiveS0Response, 0, sizeof(_net__Set8021XActiveS0Response), 0, soap_copy__net__Set8021XActiveS0Response); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Set8021XActiveS0Response * SOAP_FMAC6 soap_new__net__Set8021XActiveS0Response(struct soap *soap, int n) +{ return soap_instantiate__net__Set8021XActiveS0Response(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XActiveS0Response(struct soap *soap, _net__Set8021XActiveS0Response *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Set8021XActiveS0Response * SOAP_FMAC4 soap_instantiate__net__Set8021XActiveS0Response(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Set8021XActiveS0Response(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Set8021XActiveS0Response, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Set8021XActiveS0Response; + if (size) + *size = sizeof(_net__Set8021XActiveS0Response); + ((_net__Set8021XActiveS0Response*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Set8021XActiveS0Response[n]; + if (size) + *size = n * sizeof(_net__Set8021XActiveS0Response); + for (int i = 0; i < n; i++) + ((_net__Set8021XActiveS0Response*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Set8021XActiveS0Response*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XActiveS0Response(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Set8021XActiveS0Response %p -> %p\n", q, p)); + *(_net__Set8021XActiveS0Response*)p = *(_net__Set8021XActiveS0Response*)q; +} + +void _net__Set8021XActiveS0::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__Set8021XActiveS0*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _net__Set8021XActiveS0::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((_net__Set8021XActiveS0*)this)->Enabled); + /* transient soap skipped */ +} + +int _net__Set8021XActiveS0::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Set8021XActiveS0); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Set8021XActiveS0::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Set8021XActiveS0(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XActiveS0(struct soap *soap, const char *tag, int id, const _net__Set8021XActiveS0 *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Set8021XActiveS0), type); + soap_out_bool(soap, "net:Enabled", -1, &(((_net__Set8021XActiveS0*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Set8021XActiveS0::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Set8021XActiveS0(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Set8021XActiveS0 * SOAP_FMAC4 soap_get__net__Set8021XActiveS0(struct soap *soap, _net__Set8021XActiveS0 *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Set8021XActiveS0(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Set8021XActiveS0::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Set8021XActiveS0(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Set8021XActiveS0 * SOAP_FMAC4 soap_in__net__Set8021XActiveS0(struct soap *soap, const char *tag, _net__Set8021XActiveS0 *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Set8021XActiveS0 *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Set8021XActiveS0, sizeof(_net__Set8021XActiveS0), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Set8021XActiveS0) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Set8021XActiveS0 *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "net:Enabled", &(((_net__Set8021XActiveS0*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Set8021XActiveS0 *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Set8021XActiveS0, 0, sizeof(_net__Set8021XActiveS0), 0, soap_copy__net__Set8021XActiveS0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Set8021XActiveS0 * SOAP_FMAC6 soap_new__net__Set8021XActiveS0(struct soap *soap, int n) +{ return soap_instantiate__net__Set8021XActiveS0(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XActiveS0(struct soap *soap, _net__Set8021XActiveS0 *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Set8021XActiveS0 * SOAP_FMAC4 soap_instantiate__net__Set8021XActiveS0(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Set8021XActiveS0(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Set8021XActiveS0, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Set8021XActiveS0; + if (size) + *size = sizeof(_net__Set8021XActiveS0); + ((_net__Set8021XActiveS0*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Set8021XActiveS0[n]; + if (size) + *size = n * sizeof(_net__Set8021XActiveS0); + for (int i = 0; i < n; i++) + ((_net__Set8021XActiveS0*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Set8021XActiveS0*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XActiveS0(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Set8021XActiveS0 %p -> %p\n", q, p)); + *(_net__Set8021XActiveS0*)p = *(_net__Set8021XActiveS0*)q; +} + +void _net__Set8021XWiredProfileResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__Set8021XWiredProfileResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_net__Set8021XWiredProfileResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _net__Set8021XWiredProfileResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Set8021XWiredProfileResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Set8021XWiredProfileResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Set8021XWiredProfileResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XWiredProfileResponse(struct soap *soap, const char *tag, int id, const _net__Set8021XWiredProfileResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Set8021XWiredProfileResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__Set8021XWiredProfileResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Set8021XWiredProfileResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Set8021XWiredProfileResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Set8021XWiredProfileResponse * SOAP_FMAC4 soap_get__net__Set8021XWiredProfileResponse(struct soap *soap, _net__Set8021XWiredProfileResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Set8021XWiredProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Set8021XWiredProfileResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Set8021XWiredProfileResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Set8021XWiredProfileResponse * SOAP_FMAC4 soap_in__net__Set8021XWiredProfileResponse(struct soap *soap, const char *tag, _net__Set8021XWiredProfileResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Set8021XWiredProfileResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Set8021XWiredProfileResponse, sizeof(_net__Set8021XWiredProfileResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Set8021XWiredProfileResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Set8021XWiredProfileResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__Set8021XWiredProfileResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Set8021XWiredProfileResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Set8021XWiredProfileResponse, 0, sizeof(_net__Set8021XWiredProfileResponse), 0, soap_copy__net__Set8021XWiredProfileResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Set8021XWiredProfileResponse * SOAP_FMAC6 soap_new__net__Set8021XWiredProfileResponse(struct soap *soap, int n) +{ return soap_instantiate__net__Set8021XWiredProfileResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XWiredProfileResponse(struct soap *soap, _net__Set8021XWiredProfileResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Set8021XWiredProfileResponse * SOAP_FMAC4 soap_instantiate__net__Set8021XWiredProfileResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Set8021XWiredProfileResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Set8021XWiredProfileResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Set8021XWiredProfileResponse; + if (size) + *size = sizeof(_net__Set8021XWiredProfileResponse); + ((_net__Set8021XWiredProfileResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Set8021XWiredProfileResponse[n]; + if (size) + *size = n * sizeof(_net__Set8021XWiredProfileResponse); + for (int i = 0; i < n; i++) + ((_net__Set8021XWiredProfileResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Set8021XWiredProfileResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XWiredProfileResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Set8021XWiredProfileResponse %p -> %p\n", q, p)); + *(_net__Set8021XWiredProfileResponse*)p = *(_net__Set8021XWiredProfileResponse*)q; +} + +void _net__Set8021XWiredProfile::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__Set8021XWiredProfile*)this)->InterfaceHandle, SOAP_TYPE_cmn__InterfaceHandleType); + soap_serialize_PointerToxcfg__XProfileType(soap, &((_net__Set8021XWiredProfile*)this)->XProfile); + /* transient soap skipped */ +} + +void _net__Set8021XWiredProfile::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__InterfaceHandleType(soap, &((_net__Set8021XWiredProfile*)this)->InterfaceHandle); + ((_net__Set8021XWiredProfile*)this)->XProfile = NULL; + /* transient soap skipped */ +} + +int _net__Set8021XWiredProfile::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Set8021XWiredProfile); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Set8021XWiredProfile::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Set8021XWiredProfile(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Set8021XWiredProfile(struct soap *soap, const char *tag, int id, const _net__Set8021XWiredProfile *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Set8021XWiredProfile), type); + soap_out_cmn__InterfaceHandleType(soap, "net:InterfaceHandle", -1, &(((_net__Set8021XWiredProfile*)a)->InterfaceHandle), ""); + soap_out_PointerToxcfg__XProfileType(soap, "net:XProfile", -1, &(((_net__Set8021XWiredProfile*)a)->XProfile), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Set8021XWiredProfile::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Set8021XWiredProfile(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Set8021XWiredProfile * SOAP_FMAC4 soap_get__net__Set8021XWiredProfile(struct soap *soap, _net__Set8021XWiredProfile *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Set8021XWiredProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Set8021XWiredProfile::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Set8021XWiredProfile(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Set8021XWiredProfile * SOAP_FMAC4 soap_in__net__Set8021XWiredProfile(struct soap *soap, const char *tag, _net__Set8021XWiredProfile *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Set8021XWiredProfile *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Set8021XWiredProfile, sizeof(_net__Set8021XWiredProfile), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Set8021XWiredProfile) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Set8021XWiredProfile *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1, soap_flag_XProfile1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__InterfaceHandleType(soap, "net:InterfaceHandle", &(((_net__Set8021XWiredProfile*)a)->InterfaceHandle), "cmn:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + if (soap_flag_XProfile1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__XProfileType(soap, "net:XProfile", &(((_net__Set8021XWiredProfile*)a)->XProfile), "xcfg:XProfileType")) + { soap_flag_XProfile1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_InterfaceHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Set8021XWiredProfile *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Set8021XWiredProfile, 0, sizeof(_net__Set8021XWiredProfile), 0, soap_copy__net__Set8021XWiredProfile); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Set8021XWiredProfile * SOAP_FMAC6 soap_new__net__Set8021XWiredProfile(struct soap *soap, int n) +{ return soap_instantiate__net__Set8021XWiredProfile(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Set8021XWiredProfile(struct soap *soap, _net__Set8021XWiredProfile *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Set8021XWiredProfile * SOAP_FMAC4 soap_instantiate__net__Set8021XWiredProfile(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Set8021XWiredProfile(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Set8021XWiredProfile, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Set8021XWiredProfile; + if (size) + *size = sizeof(_net__Set8021XWiredProfile); + ((_net__Set8021XWiredProfile*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Set8021XWiredProfile[n]; + if (size) + *size = n * sizeof(_net__Set8021XWiredProfile); + for (int i = 0; i < n; i++) + ((_net__Set8021XWiredProfile*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Set8021XWiredProfile*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Set8021XWiredProfile(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Set8021XWiredProfile %p -> %p\n", q, p)); + *(_net__Set8021XWiredProfile*)p = *(_net__Set8021XWiredProfile*)q; +} + +void _net__Get8021XWiredProfileResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToxcfg__XProfileType(soap, &((_net__Get8021XWiredProfileResponse*)this)->XProfile); + /* transient soap skipped */ +} + +void _net__Get8021XWiredProfileResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_net__Get8021XWiredProfileResponse*)this)->StatusCode); + ((_net__Get8021XWiredProfileResponse*)this)->XProfile = NULL; + /* transient soap skipped */ +} + +int _net__Get8021XWiredProfileResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Get8021XWiredProfileResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Get8021XWiredProfileResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Get8021XWiredProfileResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XWiredProfileResponse(struct soap *soap, const char *tag, int id, const _net__Get8021XWiredProfileResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Get8021XWiredProfileResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__Get8021XWiredProfileResponse*)a)->StatusCode), ""); + soap_out_PointerToxcfg__XProfileType(soap, "net:XProfile", -1, &(((_net__Get8021XWiredProfileResponse*)a)->XProfile), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Get8021XWiredProfileResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Get8021XWiredProfileResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Get8021XWiredProfileResponse * SOAP_FMAC4 soap_get__net__Get8021XWiredProfileResponse(struct soap *soap, _net__Get8021XWiredProfileResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Get8021XWiredProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Get8021XWiredProfileResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Get8021XWiredProfileResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Get8021XWiredProfileResponse * SOAP_FMAC4 soap_in__net__Get8021XWiredProfileResponse(struct soap *soap, const char *tag, _net__Get8021XWiredProfileResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Get8021XWiredProfileResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Get8021XWiredProfileResponse, sizeof(_net__Get8021XWiredProfileResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Get8021XWiredProfileResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Get8021XWiredProfileResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_XProfile1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__Get8021XWiredProfileResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_XProfile1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__XProfileType(soap, "net:XProfile", &(((_net__Get8021XWiredProfileResponse*)a)->XProfile), "xcfg:XProfileType")) + { soap_flag_XProfile1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Get8021XWiredProfileResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Get8021XWiredProfileResponse, 0, sizeof(_net__Get8021XWiredProfileResponse), 0, soap_copy__net__Get8021XWiredProfileResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Get8021XWiredProfileResponse * SOAP_FMAC6 soap_new__net__Get8021XWiredProfileResponse(struct soap *soap, int n) +{ return soap_instantiate__net__Get8021XWiredProfileResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XWiredProfileResponse(struct soap *soap, _net__Get8021XWiredProfileResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Get8021XWiredProfileResponse * SOAP_FMAC4 soap_instantiate__net__Get8021XWiredProfileResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Get8021XWiredProfileResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Get8021XWiredProfileResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Get8021XWiredProfileResponse; + if (size) + *size = sizeof(_net__Get8021XWiredProfileResponse); + ((_net__Get8021XWiredProfileResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Get8021XWiredProfileResponse[n]; + if (size) + *size = n * sizeof(_net__Get8021XWiredProfileResponse); + for (int i = 0; i < n; i++) + ((_net__Get8021XWiredProfileResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Get8021XWiredProfileResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XWiredProfileResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Get8021XWiredProfileResponse %p -> %p\n", q, p)); + *(_net__Get8021XWiredProfileResponse*)p = *(_net__Get8021XWiredProfileResponse*)q; +} + +void _net__Get8021XWiredProfile::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__Get8021XWiredProfile*)this)->InterfaceHandle, SOAP_TYPE_cmn__InterfaceHandleType); + /* transient soap skipped */ +} + +void _net__Get8021XWiredProfile::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__InterfaceHandleType(soap, &((_net__Get8021XWiredProfile*)this)->InterfaceHandle); + /* transient soap skipped */ +} + +int _net__Get8021XWiredProfile::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__Get8021XWiredProfile); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__Get8021XWiredProfile::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__Get8021XWiredProfile(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__Get8021XWiredProfile(struct soap *soap, const char *tag, int id, const _net__Get8021XWiredProfile *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__Get8021XWiredProfile), type); + soap_out_cmn__InterfaceHandleType(soap, "net:InterfaceHandle", -1, &(((_net__Get8021XWiredProfile*)a)->InterfaceHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__Get8021XWiredProfile::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__Get8021XWiredProfile(soap, this, tag, type); +} + +SOAP_FMAC3 _net__Get8021XWiredProfile * SOAP_FMAC4 soap_get__net__Get8021XWiredProfile(struct soap *soap, _net__Get8021XWiredProfile *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__Get8021XWiredProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__Get8021XWiredProfile::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__Get8021XWiredProfile(soap, tag, this, type); +} + +SOAP_FMAC3 _net__Get8021XWiredProfile * SOAP_FMAC4 soap_in__net__Get8021XWiredProfile(struct soap *soap, const char *tag, _net__Get8021XWiredProfile *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__Get8021XWiredProfile *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__Get8021XWiredProfile, sizeof(_net__Get8021XWiredProfile), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__Get8021XWiredProfile) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__Get8021XWiredProfile *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__InterfaceHandleType(soap, "net:InterfaceHandle", &(((_net__Get8021XWiredProfile*)a)->InterfaceHandle), "cmn:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_InterfaceHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__Get8021XWiredProfile *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__Get8021XWiredProfile, 0, sizeof(_net__Get8021XWiredProfile), 0, soap_copy__net__Get8021XWiredProfile); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__Get8021XWiredProfile * SOAP_FMAC6 soap_new__net__Get8021XWiredProfile(struct soap *soap, int n) +{ return soap_instantiate__net__Get8021XWiredProfile(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__Get8021XWiredProfile(struct soap *soap, _net__Get8021XWiredProfile *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__Get8021XWiredProfile * SOAP_FMAC4 soap_instantiate__net__Get8021XWiredProfile(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__Get8021XWiredProfile(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__Get8021XWiredProfile, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__Get8021XWiredProfile; + if (size) + *size = sizeof(_net__Get8021XWiredProfile); + ((_net__Get8021XWiredProfile*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__Get8021XWiredProfile[n]; + if (size) + *size = n * sizeof(_net__Get8021XWiredProfile); + for (int i = 0; i < n; i++) + ((_net__Get8021XWiredProfile*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__Get8021XWiredProfile*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__Get8021XWiredProfile(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__Get8021XWiredProfile %p -> %p\n", q, p)); + *(_net__Get8021XWiredProfile*)p = *(_net__Get8021XWiredProfile*)q; +} + +void _net__SetInterfaceSettingsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__SetInterfaceSettingsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_net__SetInterfaceSettingsResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _net__SetInterfaceSettingsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetInterfaceSettingsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetInterfaceSettingsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetInterfaceSettingsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetInterfaceSettingsResponse(struct soap *soap, const char *tag, int id, const _net__SetInterfaceSettingsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetInterfaceSettingsResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__SetInterfaceSettingsResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetInterfaceSettingsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetInterfaceSettingsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetInterfaceSettingsResponse * SOAP_FMAC4 soap_get__net__SetInterfaceSettingsResponse(struct soap *soap, _net__SetInterfaceSettingsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetInterfaceSettingsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetInterfaceSettingsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetInterfaceSettingsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetInterfaceSettingsResponse * SOAP_FMAC4 soap_in__net__SetInterfaceSettingsResponse(struct soap *soap, const char *tag, _net__SetInterfaceSettingsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetInterfaceSettingsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetInterfaceSettingsResponse, sizeof(_net__SetInterfaceSettingsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetInterfaceSettingsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetInterfaceSettingsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__SetInterfaceSettingsResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetInterfaceSettingsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetInterfaceSettingsResponse, 0, sizeof(_net__SetInterfaceSettingsResponse), 0, soap_copy__net__SetInterfaceSettingsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetInterfaceSettingsResponse * SOAP_FMAC6 soap_new__net__SetInterfaceSettingsResponse(struct soap *soap, int n) +{ return soap_instantiate__net__SetInterfaceSettingsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetInterfaceSettingsResponse(struct soap *soap, _net__SetInterfaceSettingsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetInterfaceSettingsResponse * SOAP_FMAC4 soap_instantiate__net__SetInterfaceSettingsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetInterfaceSettingsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetInterfaceSettingsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetInterfaceSettingsResponse; + if (size) + *size = sizeof(_net__SetInterfaceSettingsResponse); + ((_net__SetInterfaceSettingsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetInterfaceSettingsResponse[n]; + if (size) + *size = n * sizeof(_net__SetInterfaceSettingsResponse); + for (int i = 0; i < n; i++) + ((_net__SetInterfaceSettingsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetInterfaceSettingsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetInterfaceSettingsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetInterfaceSettingsResponse %p -> %p\n", q, p)); + *(_net__SetInterfaceSettingsResponse*)p = *(_net__SetInterfaceSettingsResponse*)q; +} + +void _net__SetInterfaceSettings::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTonet__InterfaceDescriptorSetType(soap, &((_net__SetInterfaceSettings*)this)->InterfaceDescriptor); + /* transient soap skipped */ +} + +void _net__SetInterfaceSettings::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__InterfaceHandleType(soap, &((_net__SetInterfaceSettings*)this)->InterfaceHandle); + ((_net__SetInterfaceSettings*)this)->InterfaceDescriptor = NULL; + /* transient soap skipped */ +} + +int _net__SetInterfaceSettings::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetInterfaceSettings); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetInterfaceSettings::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetInterfaceSettings(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetInterfaceSettings(struct soap *soap, const char *tag, int id, const _net__SetInterfaceSettings *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetInterfaceSettings), type); + soap_out_net__InterfaceHandleType(soap, "net:InterfaceHandle", -1, &(((_net__SetInterfaceSettings*)a)->InterfaceHandle), ""); + soap_out_PointerTonet__InterfaceDescriptorSetType(soap, "net:InterfaceDescriptor", -1, &(((_net__SetInterfaceSettings*)a)->InterfaceDescriptor), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetInterfaceSettings::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetInterfaceSettings(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetInterfaceSettings * SOAP_FMAC4 soap_get__net__SetInterfaceSettings(struct soap *soap, _net__SetInterfaceSettings *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetInterfaceSettings(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetInterfaceSettings::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetInterfaceSettings(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetInterfaceSettings * SOAP_FMAC4 soap_in__net__SetInterfaceSettings(struct soap *soap, const char *tag, _net__SetInterfaceSettings *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetInterfaceSettings *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetInterfaceSettings, sizeof(_net__SetInterfaceSettings), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetInterfaceSettings) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetInterfaceSettings *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1, soap_flag_InterfaceDescriptor1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__InterfaceHandleType(soap, "net:InterfaceHandle", &(((_net__SetInterfaceSettings*)a)->InterfaceHandle), "net:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + if (soap_flag_InterfaceDescriptor1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTonet__InterfaceDescriptorSetType(soap, "net:InterfaceDescriptor", &(((_net__SetInterfaceSettings*)a)->InterfaceDescriptor), "net:InterfaceDescriptorSetType")) + { soap_flag_InterfaceDescriptor1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_InterfaceHandle1 > 0 || soap_flag_InterfaceDescriptor1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetInterfaceSettings *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetInterfaceSettings, 0, sizeof(_net__SetInterfaceSettings), 0, soap_copy__net__SetInterfaceSettings); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetInterfaceSettings * SOAP_FMAC6 soap_new__net__SetInterfaceSettings(struct soap *soap, int n) +{ return soap_instantiate__net__SetInterfaceSettings(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetInterfaceSettings(struct soap *soap, _net__SetInterfaceSettings *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetInterfaceSettings * SOAP_FMAC4 soap_instantiate__net__SetInterfaceSettings(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetInterfaceSettings(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetInterfaceSettings, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetInterfaceSettings; + if (size) + *size = sizeof(_net__SetInterfaceSettings); + ((_net__SetInterfaceSettings*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetInterfaceSettings[n]; + if (size) + *size = n * sizeof(_net__SetInterfaceSettings); + for (int i = 0; i < n; i++) + ((_net__SetInterfaceSettings*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetInterfaceSettings*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetInterfaceSettings(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetInterfaceSettings %p -> %p\n", q, p)); + *(_net__SetInterfaceSettings*)p = *(_net__SetInterfaceSettings*)q; +} + +void _net__GetInterfaceSettingsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTonet__InterfaceDescriptorGetType(soap, &((_net__GetInterfaceSettingsResponse*)this)->InterfaceDescriptor); + /* transient soap skipped */ +} + +void _net__GetInterfaceSettingsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_net__GetInterfaceSettingsResponse*)this)->StatusCode); + ((_net__GetInterfaceSettingsResponse*)this)->InterfaceDescriptor = NULL; + /* transient soap skipped */ +} + +int _net__GetInterfaceSettingsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetInterfaceSettingsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetInterfaceSettingsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetInterfaceSettingsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetInterfaceSettingsResponse(struct soap *soap, const char *tag, int id, const _net__GetInterfaceSettingsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetInterfaceSettingsResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__GetInterfaceSettingsResponse*)a)->StatusCode), ""); + soap_out_PointerTonet__InterfaceDescriptorGetType(soap, "net:InterfaceDescriptor", -1, &(((_net__GetInterfaceSettingsResponse*)a)->InterfaceDescriptor), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetInterfaceSettingsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetInterfaceSettingsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetInterfaceSettingsResponse * SOAP_FMAC4 soap_get__net__GetInterfaceSettingsResponse(struct soap *soap, _net__GetInterfaceSettingsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetInterfaceSettingsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetInterfaceSettingsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetInterfaceSettingsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetInterfaceSettingsResponse * SOAP_FMAC4 soap_in__net__GetInterfaceSettingsResponse(struct soap *soap, const char *tag, _net__GetInterfaceSettingsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetInterfaceSettingsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetInterfaceSettingsResponse, sizeof(_net__GetInterfaceSettingsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetInterfaceSettingsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetInterfaceSettingsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_InterfaceDescriptor1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__GetInterfaceSettingsResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_InterfaceDescriptor1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTonet__InterfaceDescriptorGetType(soap, "net:InterfaceDescriptor", &(((_net__GetInterfaceSettingsResponse*)a)->InterfaceDescriptor), "net:InterfaceDescriptorGetType")) + { soap_flag_InterfaceDescriptor1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_InterfaceDescriptor1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetInterfaceSettingsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetInterfaceSettingsResponse, 0, sizeof(_net__GetInterfaceSettingsResponse), 0, soap_copy__net__GetInterfaceSettingsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetInterfaceSettingsResponse * SOAP_FMAC6 soap_new__net__GetInterfaceSettingsResponse(struct soap *soap, int n) +{ return soap_instantiate__net__GetInterfaceSettingsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetInterfaceSettingsResponse(struct soap *soap, _net__GetInterfaceSettingsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetInterfaceSettingsResponse * SOAP_FMAC4 soap_instantiate__net__GetInterfaceSettingsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetInterfaceSettingsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetInterfaceSettingsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetInterfaceSettingsResponse; + if (size) + *size = sizeof(_net__GetInterfaceSettingsResponse); + ((_net__GetInterfaceSettingsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetInterfaceSettingsResponse[n]; + if (size) + *size = n * sizeof(_net__GetInterfaceSettingsResponse); + for (int i = 0; i < n; i++) + ((_net__GetInterfaceSettingsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetInterfaceSettingsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetInterfaceSettingsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetInterfaceSettingsResponse %p -> %p\n", q, p)); + *(_net__GetInterfaceSettingsResponse*)p = *(_net__GetInterfaceSettingsResponse*)q; +} + +void _net__GetInterfaceSettings::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__GetInterfaceSettings::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__InterfaceHandleType(soap, &((_net__GetInterfaceSettings*)this)->InterfaceHandle); + /* transient soap skipped */ +} + +int _net__GetInterfaceSettings::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetInterfaceSettings); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetInterfaceSettings::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetInterfaceSettings(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetInterfaceSettings(struct soap *soap, const char *tag, int id, const _net__GetInterfaceSettings *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetInterfaceSettings), type); + soap_out_net__InterfaceHandleType(soap, "net:InterfaceHandle", -1, &(((_net__GetInterfaceSettings*)a)->InterfaceHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetInterfaceSettings::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetInterfaceSettings(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetInterfaceSettings * SOAP_FMAC4 soap_get__net__GetInterfaceSettings(struct soap *soap, _net__GetInterfaceSettings *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetInterfaceSettings(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetInterfaceSettings::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetInterfaceSettings(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetInterfaceSettings * SOAP_FMAC4 soap_in__net__GetInterfaceSettings(struct soap *soap, const char *tag, _net__GetInterfaceSettings *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetInterfaceSettings *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetInterfaceSettings, sizeof(_net__GetInterfaceSettings), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetInterfaceSettings) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetInterfaceSettings *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__InterfaceHandleType(soap, "net:InterfaceHandle", &(((_net__GetInterfaceSettings*)a)->InterfaceHandle), "net:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_InterfaceHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetInterfaceSettings *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetInterfaceSettings, 0, sizeof(_net__GetInterfaceSettings), 0, soap_copy__net__GetInterfaceSettings); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetInterfaceSettings * SOAP_FMAC6 soap_new__net__GetInterfaceSettings(struct soap *soap, int n) +{ return soap_instantiate__net__GetInterfaceSettings(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetInterfaceSettings(struct soap *soap, _net__GetInterfaceSettings *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetInterfaceSettings * SOAP_FMAC4 soap_instantiate__net__GetInterfaceSettings(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetInterfaceSettings(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetInterfaceSettings, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetInterfaceSettings; + if (size) + *size = sizeof(_net__GetInterfaceSettings); + ((_net__GetInterfaceSettings*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetInterfaceSettings[n]; + if (size) + *size = n * sizeof(_net__GetInterfaceSettings); + for (int i = 0; i < n; i++) + ((_net__GetInterfaceSettings*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetInterfaceSettings*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetInterfaceSettings(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetInterfaceSettings %p -> %p\n", q, p)); + *(_net__GetInterfaceSettings*)p = *(_net__GetInterfaceSettings*)q; +} + +void _net__EnumerateInterfacesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfnet__InterfaceHandleType(soap, &((_net__EnumerateInterfacesResponse*)this)->InterfaceHandles); + /* transient soap skipped */ +} + +void _net__EnumerateInterfacesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_net__EnumerateInterfacesResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfnet__InterfaceHandleType(soap, &((_net__EnumerateInterfacesResponse*)this)->InterfaceHandles); + /* transient soap skipped */ +} + +int _net__EnumerateInterfacesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__EnumerateInterfacesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__EnumerateInterfacesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__EnumerateInterfacesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__EnumerateInterfacesResponse(struct soap *soap, const char *tag, int id, const _net__EnumerateInterfacesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__EnumerateInterfacesResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__EnumerateInterfacesResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfnet__InterfaceHandleType(soap, "net:InterfaceHandles", -1, &(((_net__EnumerateInterfacesResponse*)a)->InterfaceHandles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__EnumerateInterfacesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__EnumerateInterfacesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__EnumerateInterfacesResponse * SOAP_FMAC4 soap_get__net__EnumerateInterfacesResponse(struct soap *soap, _net__EnumerateInterfacesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__EnumerateInterfacesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__EnumerateInterfacesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__EnumerateInterfacesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__EnumerateInterfacesResponse * SOAP_FMAC4 soap_in__net__EnumerateInterfacesResponse(struct soap *soap, const char *tag, _net__EnumerateInterfacesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__EnumerateInterfacesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__EnumerateInterfacesResponse, sizeof(_net__EnumerateInterfacesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__EnumerateInterfacesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__EnumerateInterfacesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__EnumerateInterfacesResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfnet__InterfaceHandleType(soap, "net:InterfaceHandles", &(((_net__EnumerateInterfacesResponse*)a)->InterfaceHandles), "net:InterfaceHandleType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__EnumerateInterfacesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__EnumerateInterfacesResponse, 0, sizeof(_net__EnumerateInterfacesResponse), 0, soap_copy__net__EnumerateInterfacesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__EnumerateInterfacesResponse * SOAP_FMAC6 soap_new__net__EnumerateInterfacesResponse(struct soap *soap, int n) +{ return soap_instantiate__net__EnumerateInterfacesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__EnumerateInterfacesResponse(struct soap *soap, _net__EnumerateInterfacesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__EnumerateInterfacesResponse * SOAP_FMAC4 soap_instantiate__net__EnumerateInterfacesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__EnumerateInterfacesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__EnumerateInterfacesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__EnumerateInterfacesResponse; + if (size) + *size = sizeof(_net__EnumerateInterfacesResponse); + ((_net__EnumerateInterfacesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__EnumerateInterfacesResponse[n]; + if (size) + *size = n * sizeof(_net__EnumerateInterfacesResponse); + for (int i = 0; i < n; i++) + ((_net__EnumerateInterfacesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__EnumerateInterfacesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__EnumerateInterfacesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__EnumerateInterfacesResponse %p -> %p\n", q, p)); + *(_net__EnumerateInterfacesResponse*)p = *(_net__EnumerateInterfacesResponse*)q; +} + +void _net__EnumerateInterfaces::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__EnumerateInterfaces::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _net__EnumerateInterfaces::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__EnumerateInterfaces); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__EnumerateInterfaces::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__EnumerateInterfaces(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__EnumerateInterfaces(struct soap *soap, const char *tag, int id, const _net__EnumerateInterfaces *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__EnumerateInterfaces), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__EnumerateInterfaces::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__EnumerateInterfaces(soap, this, tag, type); +} + +SOAP_FMAC3 _net__EnumerateInterfaces * SOAP_FMAC4 soap_get__net__EnumerateInterfaces(struct soap *soap, _net__EnumerateInterfaces *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__EnumerateInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__EnumerateInterfaces::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__EnumerateInterfaces(soap, tag, this, type); +} + +SOAP_FMAC3 _net__EnumerateInterfaces * SOAP_FMAC4 soap_in__net__EnumerateInterfaces(struct soap *soap, const char *tag, _net__EnumerateInterfaces *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__EnumerateInterfaces *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__EnumerateInterfaces, sizeof(_net__EnumerateInterfaces), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__EnumerateInterfaces) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__EnumerateInterfaces *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__EnumerateInterfaces *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__EnumerateInterfaces, 0, sizeof(_net__EnumerateInterfaces), 0, soap_copy__net__EnumerateInterfaces); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__EnumerateInterfaces * SOAP_FMAC6 soap_new__net__EnumerateInterfaces(struct soap *soap, int n) +{ return soap_instantiate__net__EnumerateInterfaces(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__EnumerateInterfaces(struct soap *soap, _net__EnumerateInterfaces *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__EnumerateInterfaces * SOAP_FMAC4 soap_instantiate__net__EnumerateInterfaces(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__EnumerateInterfaces(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__EnumerateInterfaces, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__EnumerateInterfaces; + if (size) + *size = sizeof(_net__EnumerateInterfaces); + ((_net__EnumerateInterfaces*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__EnumerateInterfaces[n]; + if (size) + *size = n * sizeof(_net__EnumerateInterfaces); + for (int i = 0; i < n; i++) + ((_net__EnumerateInterfaces*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__EnumerateInterfaces*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__EnumerateInterfaces(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__EnumerateInterfaces %p -> %p\n", q, p)); + *(_net__EnumerateInterfaces*)p = *(_net__EnumerateInterfaces*)q; +} + +void _net__GetPingResponseResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__GetPingResponseResponse*)this)->enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _net__GetPingResponseResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__GetPingResponseResponse*)this)->StatusCode); + soap_default_bool(soap, &((_net__GetPingResponseResponse*)this)->enabled); + /* transient soap skipped */ +} + +int _net__GetPingResponseResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetPingResponseResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetPingResponseResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetPingResponseResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetPingResponseResponse(struct soap *soap, const char *tag, int id, const _net__GetPingResponseResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetPingResponseResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__GetPingResponseResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "net:enabled", -1, &(((_net__GetPingResponseResponse*)a)->enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetPingResponseResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetPingResponseResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetPingResponseResponse * SOAP_FMAC4 soap_get__net__GetPingResponseResponse(struct soap *soap, _net__GetPingResponseResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetPingResponseResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetPingResponseResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetPingResponseResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetPingResponseResponse * SOAP_FMAC4 soap_in__net__GetPingResponseResponse(struct soap *soap, const char *tag, _net__GetPingResponseResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetPingResponseResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetPingResponseResponse, sizeof(_net__GetPingResponseResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetPingResponseResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetPingResponseResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__GetPingResponseResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "net:enabled", &(((_net__GetPingResponseResponse*)a)->enabled), "xsd:boolean")) + { soap_flag_enabled1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetPingResponseResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetPingResponseResponse, 0, sizeof(_net__GetPingResponseResponse), 0, soap_copy__net__GetPingResponseResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetPingResponseResponse * SOAP_FMAC6 soap_new__net__GetPingResponseResponse(struct soap *soap, int n) +{ return soap_instantiate__net__GetPingResponseResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetPingResponseResponse(struct soap *soap, _net__GetPingResponseResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetPingResponseResponse * SOAP_FMAC4 soap_instantiate__net__GetPingResponseResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetPingResponseResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetPingResponseResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetPingResponseResponse; + if (size) + *size = sizeof(_net__GetPingResponseResponse); + ((_net__GetPingResponseResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetPingResponseResponse[n]; + if (size) + *size = n * sizeof(_net__GetPingResponseResponse); + for (int i = 0; i < n; i++) + ((_net__GetPingResponseResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetPingResponseResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetPingResponseResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetPingResponseResponse %p -> %p\n", q, p)); + *(_net__GetPingResponseResponse*)p = *(_net__GetPingResponseResponse*)q; +} + +void _net__GetPingResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__GetPingResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _net__GetPingResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetPingResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetPingResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetPingResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetPingResponse(struct soap *soap, const char *tag, int id, const _net__GetPingResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetPingResponse), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetPingResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetPingResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetPingResponse * SOAP_FMAC4 soap_get__net__GetPingResponse(struct soap *soap, _net__GetPingResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetPingResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetPingResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetPingResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetPingResponse * SOAP_FMAC4 soap_in__net__GetPingResponse(struct soap *soap, const char *tag, _net__GetPingResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetPingResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetPingResponse, sizeof(_net__GetPingResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetPingResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetPingResponse *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetPingResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetPingResponse, 0, sizeof(_net__GetPingResponse), 0, soap_copy__net__GetPingResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetPingResponse * SOAP_FMAC6 soap_new__net__GetPingResponse(struct soap *soap, int n) +{ return soap_instantiate__net__GetPingResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetPingResponse(struct soap *soap, _net__GetPingResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetPingResponse * SOAP_FMAC4 soap_instantiate__net__GetPingResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetPingResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetPingResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetPingResponse; + if (size) + *size = sizeof(_net__GetPingResponse); + ((_net__GetPingResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetPingResponse[n]; + if (size) + *size = n * sizeof(_net__GetPingResponse); + for (int i = 0; i < n; i++) + ((_net__GetPingResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetPingResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetPingResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetPingResponse %p -> %p\n", q, p)); + *(_net__GetPingResponse*)p = *(_net__GetPingResponse*)q; +} + +void _net__SetPingResponseResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__SetPingResponseResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__SetPingResponseResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _net__SetPingResponseResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetPingResponseResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetPingResponseResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetPingResponseResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetPingResponseResponse(struct soap *soap, const char *tag, int id, const _net__SetPingResponseResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetPingResponseResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__SetPingResponseResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetPingResponseResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetPingResponseResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetPingResponseResponse * SOAP_FMAC4 soap_get__net__SetPingResponseResponse(struct soap *soap, _net__SetPingResponseResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetPingResponseResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetPingResponseResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetPingResponseResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetPingResponseResponse * SOAP_FMAC4 soap_in__net__SetPingResponseResponse(struct soap *soap, const char *tag, _net__SetPingResponseResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetPingResponseResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetPingResponseResponse, sizeof(_net__SetPingResponseResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetPingResponseResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetPingResponseResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__SetPingResponseResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetPingResponseResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetPingResponseResponse, 0, sizeof(_net__SetPingResponseResponse), 0, soap_copy__net__SetPingResponseResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetPingResponseResponse * SOAP_FMAC6 soap_new__net__SetPingResponseResponse(struct soap *soap, int n) +{ return soap_instantiate__net__SetPingResponseResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetPingResponseResponse(struct soap *soap, _net__SetPingResponseResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetPingResponseResponse * SOAP_FMAC4 soap_instantiate__net__SetPingResponseResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetPingResponseResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetPingResponseResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetPingResponseResponse; + if (size) + *size = sizeof(_net__SetPingResponseResponse); + ((_net__SetPingResponseResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetPingResponseResponse[n]; + if (size) + *size = n * sizeof(_net__SetPingResponseResponse); + for (int i = 0; i < n; i++) + ((_net__SetPingResponseResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetPingResponseResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetPingResponseResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetPingResponseResponse %p -> %p\n", q, p)); + *(_net__SetPingResponseResponse*)p = *(_net__SetPingResponseResponse*)q; +} + +void _net__SetPingResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__SetPingResponse*)this)->enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _net__SetPingResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((_net__SetPingResponse*)this)->enabled); + /* transient soap skipped */ +} + +int _net__SetPingResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetPingResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetPingResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetPingResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetPingResponse(struct soap *soap, const char *tag, int id, const _net__SetPingResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetPingResponse), type); + soap_out_bool(soap, "net:enabled", -1, &(((_net__SetPingResponse*)a)->enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetPingResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetPingResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetPingResponse * SOAP_FMAC4 soap_get__net__SetPingResponse(struct soap *soap, _net__SetPingResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetPingResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetPingResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetPingResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetPingResponse * SOAP_FMAC4 soap_in__net__SetPingResponse(struct soap *soap, const char *tag, _net__SetPingResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetPingResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetPingResponse, sizeof(_net__SetPingResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetPingResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetPingResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "net:enabled", &(((_net__SetPingResponse*)a)->enabled), "xsd:boolean")) + { soap_flag_enabled1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetPingResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetPingResponse, 0, sizeof(_net__SetPingResponse), 0, soap_copy__net__SetPingResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetPingResponse * SOAP_FMAC6 soap_new__net__SetPingResponse(struct soap *soap, int n) +{ return soap_instantiate__net__SetPingResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetPingResponse(struct soap *soap, _net__SetPingResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetPingResponse * SOAP_FMAC4 soap_instantiate__net__SetPingResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetPingResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetPingResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetPingResponse; + if (size) + *size = sizeof(_net__SetPingResponse); + ((_net__SetPingResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetPingResponse[n]; + if (size) + *size = n * sizeof(_net__SetPingResponse); + for (int i = 0; i < n; i++) + ((_net__SetPingResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetPingResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetPingResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetPingResponse %p -> %p\n", q, p)); + *(_net__SetPingResponse*)p = *(_net__SetPingResponse*)q; +} + +void _net__GetVlanParametersResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__GetVlanParametersResponse*)this)->VlanMode, SOAP_TYPE_bool); + soap_embedded(soap, &((_net__GetVlanParametersResponse*)this)->VlanTag, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void _net__GetVlanParametersResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__GetVlanParametersResponse*)this)->StatusCode); + soap_default_bool(soap, &((_net__GetVlanParametersResponse*)this)->VlanMode); + soap_default_unsignedShort(soap, &((_net__GetVlanParametersResponse*)this)->VlanTag); + /* transient soap skipped */ +} + +int _net__GetVlanParametersResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetVlanParametersResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetVlanParametersResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetVlanParametersResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetVlanParametersResponse(struct soap *soap, const char *tag, int id, const _net__GetVlanParametersResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetVlanParametersResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__GetVlanParametersResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "net:VlanMode", -1, &(((_net__GetVlanParametersResponse*)a)->VlanMode), ""); + soap_out_unsignedShort(soap, "net:VlanTag", -1, &(((_net__GetVlanParametersResponse*)a)->VlanTag), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetVlanParametersResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetVlanParametersResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetVlanParametersResponse * SOAP_FMAC4 soap_get__net__GetVlanParametersResponse(struct soap *soap, _net__GetVlanParametersResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetVlanParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetVlanParametersResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetVlanParametersResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetVlanParametersResponse * SOAP_FMAC4 soap_in__net__GetVlanParametersResponse(struct soap *soap, const char *tag, _net__GetVlanParametersResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetVlanParametersResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetVlanParametersResponse, sizeof(_net__GetVlanParametersResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetVlanParametersResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetVlanParametersResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_VlanMode1 = 1, soap_flag_VlanTag1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__GetVlanParametersResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_VlanMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "net:VlanMode", &(((_net__GetVlanParametersResponse*)a)->VlanMode), "xsd:boolean")) + { soap_flag_VlanMode1--; + continue; + } + if (soap_flag_VlanTag1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "net:VlanTag", &(((_net__GetVlanParametersResponse*)a)->VlanTag), "xsd:unsignedShort")) + { soap_flag_VlanTag1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_VlanMode1 > 0 || soap_flag_VlanTag1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetVlanParametersResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetVlanParametersResponse, 0, sizeof(_net__GetVlanParametersResponse), 0, soap_copy__net__GetVlanParametersResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetVlanParametersResponse * SOAP_FMAC6 soap_new__net__GetVlanParametersResponse(struct soap *soap, int n) +{ return soap_instantiate__net__GetVlanParametersResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetVlanParametersResponse(struct soap *soap, _net__GetVlanParametersResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetVlanParametersResponse * SOAP_FMAC4 soap_instantiate__net__GetVlanParametersResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetVlanParametersResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetVlanParametersResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetVlanParametersResponse; + if (size) + *size = sizeof(_net__GetVlanParametersResponse); + ((_net__GetVlanParametersResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetVlanParametersResponse[n]; + if (size) + *size = n * sizeof(_net__GetVlanParametersResponse); + for (int i = 0; i < n; i++) + ((_net__GetVlanParametersResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetVlanParametersResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetVlanParametersResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetVlanParametersResponse %p -> %p\n", q, p)); + *(_net__GetVlanParametersResponse*)p = *(_net__GetVlanParametersResponse*)q; +} + +void _net__GetVlanParameters::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocmn__InterfaceHandleType(soap, &((_net__GetVlanParameters*)this)->InterfaceHandle); + /* transient soap skipped */ +} + +void _net__GetVlanParameters::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_net__GetVlanParameters*)this)->InterfaceHandle = NULL; + /* transient soap skipped */ +} + +int _net__GetVlanParameters::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetVlanParameters); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetVlanParameters::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetVlanParameters(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetVlanParameters(struct soap *soap, const char *tag, int id, const _net__GetVlanParameters *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetVlanParameters), type); + soap_out_PointerTocmn__InterfaceHandleType(soap, "net:InterfaceHandle", -1, &(((_net__GetVlanParameters*)a)->InterfaceHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetVlanParameters::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetVlanParameters(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetVlanParameters * SOAP_FMAC4 soap_get__net__GetVlanParameters(struct soap *soap, _net__GetVlanParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetVlanParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetVlanParameters::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetVlanParameters(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetVlanParameters * SOAP_FMAC4 soap_in__net__GetVlanParameters(struct soap *soap, const char *tag, _net__GetVlanParameters *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetVlanParameters *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetVlanParameters, sizeof(_net__GetVlanParameters), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetVlanParameters) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetVlanParameters *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocmn__InterfaceHandleType(soap, "net:InterfaceHandle", &(((_net__GetVlanParameters*)a)->InterfaceHandle), "cmn:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetVlanParameters *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetVlanParameters, 0, sizeof(_net__GetVlanParameters), 0, soap_copy__net__GetVlanParameters); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetVlanParameters * SOAP_FMAC6 soap_new__net__GetVlanParameters(struct soap *soap, int n) +{ return soap_instantiate__net__GetVlanParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetVlanParameters(struct soap *soap, _net__GetVlanParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetVlanParameters * SOAP_FMAC4 soap_instantiate__net__GetVlanParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetVlanParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetVlanParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetVlanParameters; + if (size) + *size = sizeof(_net__GetVlanParameters); + ((_net__GetVlanParameters*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetVlanParameters[n]; + if (size) + *size = n * sizeof(_net__GetVlanParameters); + for (int i = 0; i < n; i++) + ((_net__GetVlanParameters*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetVlanParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetVlanParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetVlanParameters %p -> %p\n", q, p)); + *(_net__GetVlanParameters*)p = *(_net__GetVlanParameters*)q; +} + +void _net__SetVlanParametersResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__SetVlanParametersResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__SetVlanParametersResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _net__SetVlanParametersResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetVlanParametersResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetVlanParametersResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetVlanParametersResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetVlanParametersResponse(struct soap *soap, const char *tag, int id, const _net__SetVlanParametersResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetVlanParametersResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__SetVlanParametersResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetVlanParametersResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetVlanParametersResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetVlanParametersResponse * SOAP_FMAC4 soap_get__net__SetVlanParametersResponse(struct soap *soap, _net__SetVlanParametersResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetVlanParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetVlanParametersResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetVlanParametersResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetVlanParametersResponse * SOAP_FMAC4 soap_in__net__SetVlanParametersResponse(struct soap *soap, const char *tag, _net__SetVlanParametersResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetVlanParametersResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetVlanParametersResponse, sizeof(_net__SetVlanParametersResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetVlanParametersResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetVlanParametersResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__SetVlanParametersResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetVlanParametersResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetVlanParametersResponse, 0, sizeof(_net__SetVlanParametersResponse), 0, soap_copy__net__SetVlanParametersResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetVlanParametersResponse * SOAP_FMAC6 soap_new__net__SetVlanParametersResponse(struct soap *soap, int n) +{ return soap_instantiate__net__SetVlanParametersResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetVlanParametersResponse(struct soap *soap, _net__SetVlanParametersResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetVlanParametersResponse * SOAP_FMAC4 soap_instantiate__net__SetVlanParametersResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetVlanParametersResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetVlanParametersResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetVlanParametersResponse; + if (size) + *size = sizeof(_net__SetVlanParametersResponse); + ((_net__SetVlanParametersResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetVlanParametersResponse[n]; + if (size) + *size = n * sizeof(_net__SetVlanParametersResponse); + for (int i = 0; i < n; i++) + ((_net__SetVlanParametersResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetVlanParametersResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetVlanParametersResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetVlanParametersResponse %p -> %p\n", q, p)); + *(_net__SetVlanParametersResponse*)p = *(_net__SetVlanParametersResponse*)q; +} + +void _net__SetVlanParameters::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocmn__InterfaceHandleType(soap, &((_net__SetVlanParameters*)this)->InterfaceHandle); + soap_embedded(soap, &((_net__SetVlanParameters*)this)->VlanMode, SOAP_TYPE_bool); + soap_embedded(soap, &((_net__SetVlanParameters*)this)->VlanTag, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void _net__SetVlanParameters::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_net__SetVlanParameters*)this)->InterfaceHandle = NULL; + soap_default_bool(soap, &((_net__SetVlanParameters*)this)->VlanMode); + soap_default_unsignedShort(soap, &((_net__SetVlanParameters*)this)->VlanTag); + /* transient soap skipped */ +} + +int _net__SetVlanParameters::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetVlanParameters); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetVlanParameters::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetVlanParameters(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetVlanParameters(struct soap *soap, const char *tag, int id, const _net__SetVlanParameters *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetVlanParameters), type); + soap_out_PointerTocmn__InterfaceHandleType(soap, "net:InterfaceHandle", -1, &(((_net__SetVlanParameters*)a)->InterfaceHandle), ""); + soap_out_bool(soap, "net:VlanMode", -1, &(((_net__SetVlanParameters*)a)->VlanMode), ""); + soap_out_unsignedShort(soap, "net:VlanTag", -1, &(((_net__SetVlanParameters*)a)->VlanTag), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetVlanParameters::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetVlanParameters(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetVlanParameters * SOAP_FMAC4 soap_get__net__SetVlanParameters(struct soap *soap, _net__SetVlanParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetVlanParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetVlanParameters::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetVlanParameters(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetVlanParameters * SOAP_FMAC4 soap_in__net__SetVlanParameters(struct soap *soap, const char *tag, _net__SetVlanParameters *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetVlanParameters *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetVlanParameters, sizeof(_net__SetVlanParameters), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetVlanParameters) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetVlanParameters *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceHandle1 = 1, soap_flag_VlanMode1 = 1, soap_flag_VlanTag1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocmn__InterfaceHandleType(soap, "net:InterfaceHandle", &(((_net__SetVlanParameters*)a)->InterfaceHandle), "cmn:InterfaceHandleType")) + { soap_flag_InterfaceHandle1--; + continue; + } + if (soap_flag_VlanMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "net:VlanMode", &(((_net__SetVlanParameters*)a)->VlanMode), "xsd:boolean")) + { soap_flag_VlanMode1--; + continue; + } + if (soap_flag_VlanTag1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "net:VlanTag", &(((_net__SetVlanParameters*)a)->VlanTag), "xsd:unsignedShort")) + { soap_flag_VlanTag1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_VlanMode1 > 0 || soap_flag_VlanTag1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetVlanParameters *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetVlanParameters, 0, sizeof(_net__SetVlanParameters), 0, soap_copy__net__SetVlanParameters); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetVlanParameters * SOAP_FMAC6 soap_new__net__SetVlanParameters(struct soap *soap, int n) +{ return soap_instantiate__net__SetVlanParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetVlanParameters(struct soap *soap, _net__SetVlanParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetVlanParameters * SOAP_FMAC4 soap_instantiate__net__SetVlanParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetVlanParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetVlanParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetVlanParameters; + if (size) + *size = sizeof(_net__SetVlanParameters); + ((_net__SetVlanParameters*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetVlanParameters[n]; + if (size) + *size = n * sizeof(_net__SetVlanParameters); + for (int i = 0; i < n; i++) + ((_net__SetVlanParameters*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetVlanParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetVlanParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetVlanParameters %p -> %p\n", q, p)); + *(_net__SetVlanParameters*)p = *(_net__SetVlanParameters*)q; +} + +void _net__GetTcpIpParametersResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTonet__StaticIPv4ParametersType(soap, &((_net__GetTcpIpParametersResponse*)this)->StaticIPv4Parameters); + /* transient soap skipped */ +} + +void _net__GetTcpIpParametersResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__GetTcpIpParametersResponse*)this)->StatusCode); + soap_default_net__DhcpModeType(soap, &((_net__GetTcpIpParametersResponse*)this)->DhcpMode); + ((_net__GetTcpIpParametersResponse*)this)->StaticIPv4Parameters = NULL; + /* transient soap skipped */ +} + +int _net__GetTcpIpParametersResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetTcpIpParametersResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetTcpIpParametersResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetTcpIpParametersResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetTcpIpParametersResponse(struct soap *soap, const char *tag, int id, const _net__GetTcpIpParametersResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetTcpIpParametersResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__GetTcpIpParametersResponse*)a)->StatusCode), ""); + soap_out_net__DhcpModeType(soap, "net:DhcpMode", -1, &(((_net__GetTcpIpParametersResponse*)a)->DhcpMode), ""); + soap_out_PointerTonet__StaticIPv4ParametersType(soap, "net:StaticIPv4Parameters", -1, &(((_net__GetTcpIpParametersResponse*)a)->StaticIPv4Parameters), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetTcpIpParametersResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetTcpIpParametersResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetTcpIpParametersResponse * SOAP_FMAC4 soap_get__net__GetTcpIpParametersResponse(struct soap *soap, _net__GetTcpIpParametersResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetTcpIpParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetTcpIpParametersResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetTcpIpParametersResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetTcpIpParametersResponse * SOAP_FMAC4 soap_in__net__GetTcpIpParametersResponse(struct soap *soap, const char *tag, _net__GetTcpIpParametersResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetTcpIpParametersResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetTcpIpParametersResponse, sizeof(_net__GetTcpIpParametersResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetTcpIpParametersResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetTcpIpParametersResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_DhcpMode1 = 1, soap_flag_StaticIPv4Parameters1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__GetTcpIpParametersResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_DhcpMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__DhcpModeType(soap, "net:DhcpMode", &(((_net__GetTcpIpParametersResponse*)a)->DhcpMode), "net:DhcpModeType")) + { soap_flag_DhcpMode1--; + continue; + } + if (soap_flag_StaticIPv4Parameters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTonet__StaticIPv4ParametersType(soap, "net:StaticIPv4Parameters", &(((_net__GetTcpIpParametersResponse*)a)->StaticIPv4Parameters), "net:StaticIPv4ParametersType")) + { soap_flag_StaticIPv4Parameters1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_DhcpMode1 > 0 || soap_flag_StaticIPv4Parameters1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetTcpIpParametersResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetTcpIpParametersResponse, 0, sizeof(_net__GetTcpIpParametersResponse), 0, soap_copy__net__GetTcpIpParametersResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetTcpIpParametersResponse * SOAP_FMAC6 soap_new__net__GetTcpIpParametersResponse(struct soap *soap, int n) +{ return soap_instantiate__net__GetTcpIpParametersResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetTcpIpParametersResponse(struct soap *soap, _net__GetTcpIpParametersResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetTcpIpParametersResponse * SOAP_FMAC4 soap_instantiate__net__GetTcpIpParametersResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetTcpIpParametersResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetTcpIpParametersResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetTcpIpParametersResponse; + if (size) + *size = sizeof(_net__GetTcpIpParametersResponse); + ((_net__GetTcpIpParametersResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetTcpIpParametersResponse[n]; + if (size) + *size = n * sizeof(_net__GetTcpIpParametersResponse); + for (int i = 0; i < n; i++) + ((_net__GetTcpIpParametersResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetTcpIpParametersResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetTcpIpParametersResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetTcpIpParametersResponse %p -> %p\n", q, p)); + *(_net__GetTcpIpParametersResponse*)p = *(_net__GetTcpIpParametersResponse*)q; +} + +void _net__GetTcpIpParameters::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__GetTcpIpParameters::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _net__GetTcpIpParameters::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetTcpIpParameters); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetTcpIpParameters::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetTcpIpParameters(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetTcpIpParameters(struct soap *soap, const char *tag, int id, const _net__GetTcpIpParameters *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetTcpIpParameters), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetTcpIpParameters::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetTcpIpParameters(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetTcpIpParameters * SOAP_FMAC4 soap_get__net__GetTcpIpParameters(struct soap *soap, _net__GetTcpIpParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetTcpIpParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetTcpIpParameters::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetTcpIpParameters(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetTcpIpParameters * SOAP_FMAC4 soap_in__net__GetTcpIpParameters(struct soap *soap, const char *tag, _net__GetTcpIpParameters *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetTcpIpParameters *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetTcpIpParameters, sizeof(_net__GetTcpIpParameters), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetTcpIpParameters) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetTcpIpParameters *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetTcpIpParameters *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetTcpIpParameters, 0, sizeof(_net__GetTcpIpParameters), 0, soap_copy__net__GetTcpIpParameters); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetTcpIpParameters * SOAP_FMAC6 soap_new__net__GetTcpIpParameters(struct soap *soap, int n) +{ return soap_instantiate__net__GetTcpIpParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetTcpIpParameters(struct soap *soap, _net__GetTcpIpParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetTcpIpParameters * SOAP_FMAC4 soap_instantiate__net__GetTcpIpParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetTcpIpParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetTcpIpParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetTcpIpParameters; + if (size) + *size = sizeof(_net__GetTcpIpParameters); + ((_net__GetTcpIpParameters*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetTcpIpParameters[n]; + if (size) + *size = n * sizeof(_net__GetTcpIpParameters); + for (int i = 0; i < n; i++) + ((_net__GetTcpIpParameters*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetTcpIpParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetTcpIpParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetTcpIpParameters %p -> %p\n", q, p)); + *(_net__GetTcpIpParameters*)p = *(_net__GetTcpIpParameters*)q; +} + +void _net__SetTcpIpParametersResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__SetTcpIpParametersResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__SetTcpIpParametersResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _net__SetTcpIpParametersResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetTcpIpParametersResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetTcpIpParametersResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetTcpIpParametersResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetTcpIpParametersResponse(struct soap *soap, const char *tag, int id, const _net__SetTcpIpParametersResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetTcpIpParametersResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__SetTcpIpParametersResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetTcpIpParametersResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetTcpIpParametersResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetTcpIpParametersResponse * SOAP_FMAC4 soap_get__net__SetTcpIpParametersResponse(struct soap *soap, _net__SetTcpIpParametersResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetTcpIpParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetTcpIpParametersResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetTcpIpParametersResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetTcpIpParametersResponse * SOAP_FMAC4 soap_in__net__SetTcpIpParametersResponse(struct soap *soap, const char *tag, _net__SetTcpIpParametersResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetTcpIpParametersResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetTcpIpParametersResponse, sizeof(_net__SetTcpIpParametersResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetTcpIpParametersResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetTcpIpParametersResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__SetTcpIpParametersResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetTcpIpParametersResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetTcpIpParametersResponse, 0, sizeof(_net__SetTcpIpParametersResponse), 0, soap_copy__net__SetTcpIpParametersResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetTcpIpParametersResponse * SOAP_FMAC6 soap_new__net__SetTcpIpParametersResponse(struct soap *soap, int n) +{ return soap_instantiate__net__SetTcpIpParametersResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetTcpIpParametersResponse(struct soap *soap, _net__SetTcpIpParametersResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetTcpIpParametersResponse * SOAP_FMAC4 soap_instantiate__net__SetTcpIpParametersResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetTcpIpParametersResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetTcpIpParametersResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetTcpIpParametersResponse; + if (size) + *size = sizeof(_net__SetTcpIpParametersResponse); + ((_net__SetTcpIpParametersResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetTcpIpParametersResponse[n]; + if (size) + *size = n * sizeof(_net__SetTcpIpParametersResponse); + for (int i = 0; i < n; i++) + ((_net__SetTcpIpParametersResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetTcpIpParametersResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetTcpIpParametersResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetTcpIpParametersResponse %p -> %p\n", q, p)); + *(_net__SetTcpIpParametersResponse*)p = *(_net__SetTcpIpParametersResponse*)q; +} + +void _net__SetTcpIpParameters::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTonet__StaticIPv4ParametersType(soap, &((_net__SetTcpIpParameters*)this)->StaticIPv4Parameters); + /* transient soap skipped */ +} + +void _net__SetTcpIpParameters::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__DhcpModeType(soap, &((_net__SetTcpIpParameters*)this)->DhcpMode); + ((_net__SetTcpIpParameters*)this)->StaticIPv4Parameters = NULL; + /* transient soap skipped */ +} + +int _net__SetTcpIpParameters::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetTcpIpParameters); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetTcpIpParameters::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetTcpIpParameters(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetTcpIpParameters(struct soap *soap, const char *tag, int id, const _net__SetTcpIpParameters *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetTcpIpParameters), type); + soap_out_net__DhcpModeType(soap, "net:DhcpMode", -1, &(((_net__SetTcpIpParameters*)a)->DhcpMode), ""); + soap_out_PointerTonet__StaticIPv4ParametersType(soap, "net:StaticIPv4Parameters", -1, &(((_net__SetTcpIpParameters*)a)->StaticIPv4Parameters), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetTcpIpParameters::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetTcpIpParameters(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetTcpIpParameters * SOAP_FMAC4 soap_get__net__SetTcpIpParameters(struct soap *soap, _net__SetTcpIpParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetTcpIpParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetTcpIpParameters::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetTcpIpParameters(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetTcpIpParameters * SOAP_FMAC4 soap_in__net__SetTcpIpParameters(struct soap *soap, const char *tag, _net__SetTcpIpParameters *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetTcpIpParameters *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetTcpIpParameters, sizeof(_net__SetTcpIpParameters), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetTcpIpParameters) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetTcpIpParameters *)a->soap_in(soap, tag, type); + } + } + short soap_flag_DhcpMode1 = 1, soap_flag_StaticIPv4Parameters1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_DhcpMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__DhcpModeType(soap, "net:DhcpMode", &(((_net__SetTcpIpParameters*)a)->DhcpMode), "net:DhcpModeType")) + { soap_flag_DhcpMode1--; + continue; + } + if (soap_flag_StaticIPv4Parameters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTonet__StaticIPv4ParametersType(soap, "net:StaticIPv4Parameters", &(((_net__SetTcpIpParameters*)a)->StaticIPv4Parameters), "net:StaticIPv4ParametersType")) + { soap_flag_StaticIPv4Parameters1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_DhcpMode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetTcpIpParameters *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetTcpIpParameters, 0, sizeof(_net__SetTcpIpParameters), 0, soap_copy__net__SetTcpIpParameters); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetTcpIpParameters * SOAP_FMAC6 soap_new__net__SetTcpIpParameters(struct soap *soap, int n) +{ return soap_instantiate__net__SetTcpIpParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetTcpIpParameters(struct soap *soap, _net__SetTcpIpParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetTcpIpParameters * SOAP_FMAC4 soap_instantiate__net__SetTcpIpParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetTcpIpParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetTcpIpParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetTcpIpParameters; + if (size) + *size = sizeof(_net__SetTcpIpParameters); + ((_net__SetTcpIpParameters*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetTcpIpParameters[n]; + if (size) + *size = n * sizeof(_net__SetTcpIpParameters); + for (int i = 0; i < n; i++) + ((_net__SetTcpIpParameters*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetTcpIpParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetTcpIpParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetTcpIpParameters %p -> %p\n", q, p)); + *(_net__SetTcpIpParameters*)p = *(_net__SetTcpIpParameters*)q; +} + +void _net__GetDomainNameResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__GetDomainNameResponse*)this)->DomainName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_net__GetDomainNameResponse*)this)->DomainName); + /* transient soap skipped */ +} + +void _net__GetDomainNameResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__GetDomainNameResponse*)this)->StatusCode); + soap_default_std__string(soap, &((_net__GetDomainNameResponse*)this)->DomainName); + /* transient soap skipped */ +} + +int _net__GetDomainNameResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetDomainNameResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetDomainNameResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetDomainNameResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetDomainNameResponse(struct soap *soap, const char *tag, int id, const _net__GetDomainNameResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetDomainNameResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__GetDomainNameResponse*)a)->StatusCode), ""); + soap_out_std__string(soap, "net:DomainName", -1, &(((_net__GetDomainNameResponse*)a)->DomainName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetDomainNameResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetDomainNameResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetDomainNameResponse * SOAP_FMAC4 soap_get__net__GetDomainNameResponse(struct soap *soap, _net__GetDomainNameResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetDomainNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetDomainNameResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetDomainNameResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetDomainNameResponse * SOAP_FMAC4 soap_in__net__GetDomainNameResponse(struct soap *soap, const char *tag, _net__GetDomainNameResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetDomainNameResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetDomainNameResponse, sizeof(_net__GetDomainNameResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetDomainNameResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetDomainNameResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_DomainName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__GetDomainNameResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_DomainName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "net:DomainName", &(((_net__GetDomainNameResponse*)a)->DomainName), "xsd:string")) + { soap_flag_DomainName1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_DomainName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetDomainNameResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetDomainNameResponse, 0, sizeof(_net__GetDomainNameResponse), 0, soap_copy__net__GetDomainNameResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetDomainNameResponse * SOAP_FMAC6 soap_new__net__GetDomainNameResponse(struct soap *soap, int n) +{ return soap_instantiate__net__GetDomainNameResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetDomainNameResponse(struct soap *soap, _net__GetDomainNameResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetDomainNameResponse * SOAP_FMAC4 soap_instantiate__net__GetDomainNameResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetDomainNameResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetDomainNameResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetDomainNameResponse; + if (size) + *size = sizeof(_net__GetDomainNameResponse); + ((_net__GetDomainNameResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetDomainNameResponse[n]; + if (size) + *size = n * sizeof(_net__GetDomainNameResponse); + for (int i = 0; i < n; i++) + ((_net__GetDomainNameResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetDomainNameResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetDomainNameResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetDomainNameResponse %p -> %p\n", q, p)); + *(_net__GetDomainNameResponse*)p = *(_net__GetDomainNameResponse*)q; +} + +void _net__GetDomainName::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__GetDomainName::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _net__GetDomainName::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetDomainName); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetDomainName::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetDomainName(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetDomainName(struct soap *soap, const char *tag, int id, const _net__GetDomainName *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetDomainName), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetDomainName::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetDomainName(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetDomainName * SOAP_FMAC4 soap_get__net__GetDomainName(struct soap *soap, _net__GetDomainName *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetDomainName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetDomainName::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetDomainName(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetDomainName * SOAP_FMAC4 soap_in__net__GetDomainName(struct soap *soap, const char *tag, _net__GetDomainName *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetDomainName *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetDomainName, sizeof(_net__GetDomainName), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetDomainName) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetDomainName *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetDomainName *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetDomainName, 0, sizeof(_net__GetDomainName), 0, soap_copy__net__GetDomainName); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetDomainName * SOAP_FMAC6 soap_new__net__GetDomainName(struct soap *soap, int n) +{ return soap_instantiate__net__GetDomainName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetDomainName(struct soap *soap, _net__GetDomainName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetDomainName * SOAP_FMAC4 soap_instantiate__net__GetDomainName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetDomainName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetDomainName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetDomainName; + if (size) + *size = sizeof(_net__GetDomainName); + ((_net__GetDomainName*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetDomainName[n]; + if (size) + *size = n * sizeof(_net__GetDomainName); + for (int i = 0; i < n; i++) + ((_net__GetDomainName*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetDomainName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetDomainName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetDomainName %p -> %p\n", q, p)); + *(_net__GetDomainName*)p = *(_net__GetDomainName*)q; +} + +void _net__SetDomainNameResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__SetDomainNameResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__SetDomainNameResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _net__SetDomainNameResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetDomainNameResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetDomainNameResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetDomainNameResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetDomainNameResponse(struct soap *soap, const char *tag, int id, const _net__SetDomainNameResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetDomainNameResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__SetDomainNameResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetDomainNameResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetDomainNameResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetDomainNameResponse * SOAP_FMAC4 soap_get__net__SetDomainNameResponse(struct soap *soap, _net__SetDomainNameResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetDomainNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetDomainNameResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetDomainNameResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetDomainNameResponse * SOAP_FMAC4 soap_in__net__SetDomainNameResponse(struct soap *soap, const char *tag, _net__SetDomainNameResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetDomainNameResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetDomainNameResponse, sizeof(_net__SetDomainNameResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetDomainNameResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetDomainNameResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__SetDomainNameResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetDomainNameResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetDomainNameResponse, 0, sizeof(_net__SetDomainNameResponse), 0, soap_copy__net__SetDomainNameResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetDomainNameResponse * SOAP_FMAC6 soap_new__net__SetDomainNameResponse(struct soap *soap, int n) +{ return soap_instantiate__net__SetDomainNameResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetDomainNameResponse(struct soap *soap, _net__SetDomainNameResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetDomainNameResponse * SOAP_FMAC4 soap_instantiate__net__SetDomainNameResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetDomainNameResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetDomainNameResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetDomainNameResponse; + if (size) + *size = sizeof(_net__SetDomainNameResponse); + ((_net__SetDomainNameResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetDomainNameResponse[n]; + if (size) + *size = n * sizeof(_net__SetDomainNameResponse); + for (int i = 0; i < n; i++) + ((_net__SetDomainNameResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetDomainNameResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetDomainNameResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetDomainNameResponse %p -> %p\n", q, p)); + *(_net__SetDomainNameResponse*)p = *(_net__SetDomainNameResponse*)q; +} + +void _net__SetDomainName::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__SetDomainName*)this)->DomainName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_net__SetDomainName*)this)->DomainName); + /* transient soap skipped */ +} + +void _net__SetDomainName::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((_net__SetDomainName*)this)->DomainName); + /* transient soap skipped */ +} + +int _net__SetDomainName::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetDomainName); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetDomainName::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetDomainName(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetDomainName(struct soap *soap, const char *tag, int id, const _net__SetDomainName *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetDomainName), type); + soap_out_std__string(soap, "net:DomainName", -1, &(((_net__SetDomainName*)a)->DomainName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetDomainName::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetDomainName(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetDomainName * SOAP_FMAC4 soap_get__net__SetDomainName(struct soap *soap, _net__SetDomainName *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetDomainName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetDomainName::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetDomainName(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetDomainName * SOAP_FMAC4 soap_in__net__SetDomainName(struct soap *soap, const char *tag, _net__SetDomainName *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetDomainName *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetDomainName, sizeof(_net__SetDomainName), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetDomainName) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetDomainName *)a->soap_in(soap, tag, type); + } + } + short soap_flag_DomainName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_DomainName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "net:DomainName", &(((_net__SetDomainName*)a)->DomainName), "xsd:string")) + { soap_flag_DomainName1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_DomainName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetDomainName *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetDomainName, 0, sizeof(_net__SetDomainName), 0, soap_copy__net__SetDomainName); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetDomainName * SOAP_FMAC6 soap_new__net__SetDomainName(struct soap *soap, int n) +{ return soap_instantiate__net__SetDomainName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetDomainName(struct soap *soap, _net__SetDomainName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetDomainName * SOAP_FMAC4 soap_instantiate__net__SetDomainName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetDomainName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetDomainName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetDomainName; + if (size) + *size = sizeof(_net__SetDomainName); + ((_net__SetDomainName*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetDomainName[n]; + if (size) + *size = n * sizeof(_net__SetDomainName); + for (int i = 0; i < n; i++) + ((_net__SetDomainName*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetDomainName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetDomainName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetDomainName %p -> %p\n", q, p)); + *(_net__SetDomainName*)p = *(_net__SetDomainName*)q; +} + +void _net__GetHostNameResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__GetHostNameResponse*)this)->HostName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_net__GetHostNameResponse*)this)->HostName); + /* transient soap skipped */ +} + +void _net__GetHostNameResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__GetHostNameResponse*)this)->StatusCode); + soap_default_std__string(soap, &((_net__GetHostNameResponse*)this)->HostName); + /* transient soap skipped */ +} + +int _net__GetHostNameResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetHostNameResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetHostNameResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetHostNameResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetHostNameResponse(struct soap *soap, const char *tag, int id, const _net__GetHostNameResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetHostNameResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__GetHostNameResponse*)a)->StatusCode), ""); + soap_out_std__string(soap, "net:HostName", -1, &(((_net__GetHostNameResponse*)a)->HostName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetHostNameResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetHostNameResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetHostNameResponse * SOAP_FMAC4 soap_get__net__GetHostNameResponse(struct soap *soap, _net__GetHostNameResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetHostNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetHostNameResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetHostNameResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetHostNameResponse * SOAP_FMAC4 soap_in__net__GetHostNameResponse(struct soap *soap, const char *tag, _net__GetHostNameResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetHostNameResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetHostNameResponse, sizeof(_net__GetHostNameResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetHostNameResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetHostNameResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_HostName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__GetHostNameResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_HostName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "net:HostName", &(((_net__GetHostNameResponse*)a)->HostName), "xsd:string")) + { soap_flag_HostName1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_HostName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetHostNameResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetHostNameResponse, 0, sizeof(_net__GetHostNameResponse), 0, soap_copy__net__GetHostNameResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetHostNameResponse * SOAP_FMAC6 soap_new__net__GetHostNameResponse(struct soap *soap, int n) +{ return soap_instantiate__net__GetHostNameResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetHostNameResponse(struct soap *soap, _net__GetHostNameResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetHostNameResponse * SOAP_FMAC4 soap_instantiate__net__GetHostNameResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetHostNameResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetHostNameResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetHostNameResponse; + if (size) + *size = sizeof(_net__GetHostNameResponse); + ((_net__GetHostNameResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetHostNameResponse[n]; + if (size) + *size = n * sizeof(_net__GetHostNameResponse); + for (int i = 0; i < n; i++) + ((_net__GetHostNameResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetHostNameResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetHostNameResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetHostNameResponse %p -> %p\n", q, p)); + *(_net__GetHostNameResponse*)p = *(_net__GetHostNameResponse*)q; +} + +void _net__GetHostName::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__GetHostName::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _net__GetHostName::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__GetHostName); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__GetHostName::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__GetHostName(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__GetHostName(struct soap *soap, const char *tag, int id, const _net__GetHostName *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__GetHostName), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__GetHostName::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__GetHostName(soap, this, tag, type); +} + +SOAP_FMAC3 _net__GetHostName * SOAP_FMAC4 soap_get__net__GetHostName(struct soap *soap, _net__GetHostName *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__GetHostName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__GetHostName::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__GetHostName(soap, tag, this, type); +} + +SOAP_FMAC3 _net__GetHostName * SOAP_FMAC4 soap_in__net__GetHostName(struct soap *soap, const char *tag, _net__GetHostName *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__GetHostName *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__GetHostName, sizeof(_net__GetHostName), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__GetHostName) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__GetHostName *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__GetHostName *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__GetHostName, 0, sizeof(_net__GetHostName), 0, soap_copy__net__GetHostName); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__GetHostName * SOAP_FMAC6 soap_new__net__GetHostName(struct soap *soap, int n) +{ return soap_instantiate__net__GetHostName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__GetHostName(struct soap *soap, _net__GetHostName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__GetHostName * SOAP_FMAC4 soap_instantiate__net__GetHostName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__GetHostName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__GetHostName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__GetHostName; + if (size) + *size = sizeof(_net__GetHostName); + ((_net__GetHostName*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__GetHostName[n]; + if (size) + *size = n * sizeof(_net__GetHostName); + for (int i = 0; i < n; i++) + ((_net__GetHostName*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__GetHostName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__GetHostName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__GetHostName %p -> %p\n", q, p)); + *(_net__GetHostName*)p = *(_net__GetHostName*)q; +} + +void _net__SetHostNameResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _net__SetHostNameResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__PT_USCORESTATUS(soap, &((_net__SetHostNameResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _net__SetHostNameResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetHostNameResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetHostNameResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetHostNameResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetHostNameResponse(struct soap *soap, const char *tag, int id, const _net__SetHostNameResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetHostNameResponse), type); + soap_element_result(soap, "net:StatusCode"); + soap_out_net__PT_USCORESTATUS(soap, "net:StatusCode", -1, &(((_net__SetHostNameResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetHostNameResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetHostNameResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetHostNameResponse * SOAP_FMAC4 soap_get__net__SetHostNameResponse(struct soap *soap, _net__SetHostNameResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetHostNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetHostNameResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetHostNameResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetHostNameResponse * SOAP_FMAC4 soap_in__net__SetHostNameResponse(struct soap *soap, const char *tag, _net__SetHostNameResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetHostNameResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetHostNameResponse, sizeof(_net__SetHostNameResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetHostNameResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetHostNameResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__PT_USCORESTATUS(soap, "net:StatusCode", &(((_net__SetHostNameResponse*)a)->StatusCode), "net:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "net:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetHostNameResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetHostNameResponse, 0, sizeof(_net__SetHostNameResponse), 0, soap_copy__net__SetHostNameResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetHostNameResponse * SOAP_FMAC6 soap_new__net__SetHostNameResponse(struct soap *soap, int n) +{ return soap_instantiate__net__SetHostNameResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetHostNameResponse(struct soap *soap, _net__SetHostNameResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetHostNameResponse * SOAP_FMAC4 soap_instantiate__net__SetHostNameResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetHostNameResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetHostNameResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetHostNameResponse; + if (size) + *size = sizeof(_net__SetHostNameResponse); + ((_net__SetHostNameResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetHostNameResponse[n]; + if (size) + *size = n * sizeof(_net__SetHostNameResponse); + for (int i = 0; i < n; i++) + ((_net__SetHostNameResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetHostNameResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetHostNameResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetHostNameResponse %p -> %p\n", q, p)); + *(_net__SetHostNameResponse*)p = *(_net__SetHostNameResponse*)q; +} + +void _net__SetHostName::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_net__SetHostName*)this)->HostName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_net__SetHostName*)this)->HostName); + /* transient soap skipped */ +} + +void _net__SetHostName::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((_net__SetHostName*)this)->HostName); + /* transient soap skipped */ +} + +int _net__SetHostName::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__net__SetHostName); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _net__SetHostName::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__net__SetHostName(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__net__SetHostName(struct soap *soap, const char *tag, int id, const _net__SetHostName *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__net__SetHostName), type); + soap_out_std__string(soap, "net:HostName", -1, &(((_net__SetHostName*)a)->HostName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_net__SetHostName::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__net__SetHostName(soap, this, tag, type); +} + +SOAP_FMAC3 _net__SetHostName * SOAP_FMAC4 soap_get__net__SetHostName(struct soap *soap, _net__SetHostName *p, const char *tag, const char *type) +{ + if ((p = soap_in__net__SetHostName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_net__SetHostName::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__net__SetHostName(soap, tag, this, type); +} + +SOAP_FMAC3 _net__SetHostName * SOAP_FMAC4 soap_in__net__SetHostName(struct soap *soap, const char *tag, _net__SetHostName *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_net__SetHostName *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__net__SetHostName, sizeof(_net__SetHostName), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__net__SetHostName) + { soap_revert(soap); + *soap->id = '\0'; + return (_net__SetHostName *)a->soap_in(soap, tag, type); + } + } + short soap_flag_HostName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_HostName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "net:HostName", &(((_net__SetHostName*)a)->HostName), "xsd:string")) + { soap_flag_HostName1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_HostName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_net__SetHostName *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__net__SetHostName, 0, sizeof(_net__SetHostName), 0, soap_copy__net__SetHostName); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _net__SetHostName * SOAP_FMAC6 soap_new__net__SetHostName(struct soap *soap, int n) +{ return soap_instantiate__net__SetHostName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__net__SetHostName(struct soap *soap, _net__SetHostName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _net__SetHostName * SOAP_FMAC4 soap_instantiate__net__SetHostName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__net__SetHostName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__net__SetHostName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _net__SetHostName; + if (size) + *size = sizeof(_net__SetHostName); + ((_net__SetHostName*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _net__SetHostName[n]; + if (size) + *size = n * sizeof(_net__SetHostName); + for (int i = 0; i < n; i++) + ((_net__SetHostName*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_net__SetHostName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__net__SetHostName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _net__SetHostName %p -> %p\n", q, p)); + *(_net__SetHostName*)p = *(_net__SetHostName*)q; +} + +void net__InterfaceDescriptorGetType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((net__InterfaceDescriptorGetType*)this)->HardwareAddressDescription, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((net__InterfaceDescriptorGetType*)this)->HardwareAddressDescription); + soap_serialize_net__MACAddressType(soap, &((net__InterfaceDescriptorGetType*)this)->MACAddress); + soap_embedded(soap, &((net__InterfaceDescriptorGetType*)this)->DhcpEnabled, SOAP_TYPE_bool); + soap_serialize_PointerTonet__IPv4ParametersType(soap, &((net__InterfaceDescriptorGetType*)this)->IPv4Parameters); + /* transient soap skipped */ +} + +void net__InterfaceDescriptorGetType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((net__InterfaceDescriptorGetType*)this)->HardwareAddressDescription); + soap_default_net__MACAddressType(soap, &((net__InterfaceDescriptorGetType*)this)->MACAddress); + soap_default_net__InterfaceModeType(soap, &((net__InterfaceDescriptorGetType*)this)->InterfaceMode); + soap_default_net__LinkPolicyType(soap, &((net__InterfaceDescriptorGetType*)this)->LinkPolicy); + soap_default_bool(soap, &((net__InterfaceDescriptorGetType*)this)->DhcpEnabled); + ((net__InterfaceDescriptorGetType*)this)->IPv4Parameters = NULL; + /* transient soap skipped */ +} + +int net__InterfaceDescriptorGetType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_net__InterfaceDescriptorGetType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int net__InterfaceDescriptorGetType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_net__InterfaceDescriptorGetType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__InterfaceDescriptorGetType(struct soap *soap, const char *tag, int id, const net__InterfaceDescriptorGetType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_net__InterfaceDescriptorGetType), type); + soap_out_std__string(soap, "net:HardwareAddressDescription", -1, &(((net__InterfaceDescriptorGetType*)a)->HardwareAddressDescription), ""); + soap_out_net__MACAddressType(soap, "net:MACAddress", -1, &(((net__InterfaceDescriptorGetType*)a)->MACAddress), ""); + soap_out_net__InterfaceModeType(soap, "net:InterfaceMode", -1, &(((net__InterfaceDescriptorGetType*)a)->InterfaceMode), ""); + soap_out_net__LinkPolicyType(soap, "net:LinkPolicy", -1, &(((net__InterfaceDescriptorGetType*)a)->LinkPolicy), ""); + soap_out_bool(soap, "net:DhcpEnabled", -1, &(((net__InterfaceDescriptorGetType*)a)->DhcpEnabled), ""); + soap_out_PointerTonet__IPv4ParametersType(soap, "net:IPv4Parameters", -1, &(((net__InterfaceDescriptorGetType*)a)->IPv4Parameters), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *net__InterfaceDescriptorGetType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_net__InterfaceDescriptorGetType(soap, this, tag, type); +} + +SOAP_FMAC3 net__InterfaceDescriptorGetType * SOAP_FMAC4 soap_get_net__InterfaceDescriptorGetType(struct soap *soap, net__InterfaceDescriptorGetType *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__InterfaceDescriptorGetType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *net__InterfaceDescriptorGetType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_net__InterfaceDescriptorGetType(soap, tag, this, type); +} + +SOAP_FMAC3 net__InterfaceDescriptorGetType * SOAP_FMAC4 soap_in_net__InterfaceDescriptorGetType(struct soap *soap, const char *tag, net__InterfaceDescriptorGetType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (net__InterfaceDescriptorGetType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_net__InterfaceDescriptorGetType, sizeof(net__InterfaceDescriptorGetType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_net__InterfaceDescriptorGetType) + { soap_revert(soap); + *soap->id = '\0'; + return (net__InterfaceDescriptorGetType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_HardwareAddressDescription1 = 1, soap_flag_MACAddress1 = 1, soap_flag_InterfaceMode1 = 1, soap_flag_LinkPolicy1 = 1, soap_flag_DhcpEnabled1 = 1, soap_flag_IPv4Parameters1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_HardwareAddressDescription1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "net:HardwareAddressDescription", &(((net__InterfaceDescriptorGetType*)a)->HardwareAddressDescription), "xsd:string")) + { soap_flag_HardwareAddressDescription1--; + continue; + } + if (soap_flag_MACAddress1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_net__MACAddressType(soap, "net:MACAddress", &(((net__InterfaceDescriptorGetType*)a)->MACAddress), "net:MACAddressType")) + { soap_flag_MACAddress1--; + continue; + } + if (soap_flag_InterfaceMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__InterfaceModeType(soap, "net:InterfaceMode", &(((net__InterfaceDescriptorGetType*)a)->InterfaceMode), "net:InterfaceModeType")) + { soap_flag_InterfaceMode1--; + continue; + } + if (soap_flag_LinkPolicy1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__LinkPolicyType(soap, "net:LinkPolicy", &(((net__InterfaceDescriptorGetType*)a)->LinkPolicy), "net:LinkPolicyType")) + { soap_flag_LinkPolicy1--; + continue; + } + if (soap_flag_DhcpEnabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "net:DhcpEnabled", &(((net__InterfaceDescriptorGetType*)a)->DhcpEnabled), "xsd:boolean")) + { soap_flag_DhcpEnabled1--; + continue; + } + if (soap_flag_IPv4Parameters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTonet__IPv4ParametersType(soap, "net:IPv4Parameters", &(((net__InterfaceDescriptorGetType*)a)->IPv4Parameters), "net:IPv4ParametersType")) + { soap_flag_IPv4Parameters1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_HardwareAddressDescription1 > 0 || soap_flag_MACAddress1 > 0 || soap_flag_InterfaceMode1 > 0 || soap_flag_LinkPolicy1 > 0 || soap_flag_DhcpEnabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (net__InterfaceDescriptorGetType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_net__InterfaceDescriptorGetType, 0, sizeof(net__InterfaceDescriptorGetType), 0, soap_copy_net__InterfaceDescriptorGetType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 net__InterfaceDescriptorGetType * SOAP_FMAC6 soap_new_net__InterfaceDescriptorGetType(struct soap *soap, int n) +{ return soap_instantiate_net__InterfaceDescriptorGetType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__InterfaceDescriptorGetType(struct soap *soap, net__InterfaceDescriptorGetType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 net__InterfaceDescriptorGetType * SOAP_FMAC4 soap_instantiate_net__InterfaceDescriptorGetType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_net__InterfaceDescriptorGetType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_net__InterfaceDescriptorGetType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new net__InterfaceDescriptorGetType; + if (size) + *size = sizeof(net__InterfaceDescriptorGetType); + ((net__InterfaceDescriptorGetType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new net__InterfaceDescriptorGetType[n]; + if (size) + *size = n * sizeof(net__InterfaceDescriptorGetType); + for (int i = 0; i < n; i++) + ((net__InterfaceDescriptorGetType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (net__InterfaceDescriptorGetType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__InterfaceDescriptorGetType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying net__InterfaceDescriptorGetType %p -> %p\n", q, p)); + *(net__InterfaceDescriptorGetType*)p = *(net__InterfaceDescriptorGetType*)q; +} + +void net__InterfaceDescriptorSetType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTonet__IPv4ParametersType(soap, &((net__InterfaceDescriptorSetType*)this)->IPv4Parameters); + /* transient soap skipped */ +} + +void net__InterfaceDescriptorSetType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__InterfaceModeType(soap, &((net__InterfaceDescriptorSetType*)this)->InterfaceMode); + soap_default_net__LinkPolicyType(soap, &((net__InterfaceDescriptorSetType*)this)->LinkPolicy); + ((net__InterfaceDescriptorSetType*)this)->IPv4Parameters = NULL; + /* transient soap skipped */ +} + +int net__InterfaceDescriptorSetType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_net__InterfaceDescriptorSetType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int net__InterfaceDescriptorSetType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_net__InterfaceDescriptorSetType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__InterfaceDescriptorSetType(struct soap *soap, const char *tag, int id, const net__InterfaceDescriptorSetType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_net__InterfaceDescriptorSetType), type); + soap_out_net__InterfaceModeType(soap, "net:InterfaceMode", -1, &(((net__InterfaceDescriptorSetType*)a)->InterfaceMode), ""); + soap_out_net__LinkPolicyType(soap, "net:LinkPolicy", -1, &(((net__InterfaceDescriptorSetType*)a)->LinkPolicy), ""); + soap_out_PointerTonet__IPv4ParametersType(soap, "net:IPv4Parameters", -1, &(((net__InterfaceDescriptorSetType*)a)->IPv4Parameters), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *net__InterfaceDescriptorSetType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_net__InterfaceDescriptorSetType(soap, this, tag, type); +} + +SOAP_FMAC3 net__InterfaceDescriptorSetType * SOAP_FMAC4 soap_get_net__InterfaceDescriptorSetType(struct soap *soap, net__InterfaceDescriptorSetType *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__InterfaceDescriptorSetType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *net__InterfaceDescriptorSetType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_net__InterfaceDescriptorSetType(soap, tag, this, type); +} + +SOAP_FMAC3 net__InterfaceDescriptorSetType * SOAP_FMAC4 soap_in_net__InterfaceDescriptorSetType(struct soap *soap, const char *tag, net__InterfaceDescriptorSetType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (net__InterfaceDescriptorSetType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_net__InterfaceDescriptorSetType, sizeof(net__InterfaceDescriptorSetType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_net__InterfaceDescriptorSetType) + { soap_revert(soap); + *soap->id = '\0'; + return (net__InterfaceDescriptorSetType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_InterfaceMode1 = 1, soap_flag_LinkPolicy1 = 1, soap_flag_IPv4Parameters1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_InterfaceMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__InterfaceModeType(soap, "net:InterfaceMode", &(((net__InterfaceDescriptorSetType*)a)->InterfaceMode), "net:InterfaceModeType")) + { soap_flag_InterfaceMode1--; + continue; + } + if (soap_flag_LinkPolicy1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__LinkPolicyType(soap, "net:LinkPolicy", &(((net__InterfaceDescriptorSetType*)a)->LinkPolicy), "net:LinkPolicyType")) + { soap_flag_LinkPolicy1--; + continue; + } + if (soap_flag_IPv4Parameters1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTonet__IPv4ParametersType(soap, "net:IPv4Parameters", &(((net__InterfaceDescriptorSetType*)a)->IPv4Parameters), "net:IPv4ParametersType")) + { soap_flag_IPv4Parameters1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_InterfaceMode1 > 0 || soap_flag_LinkPolicy1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (net__InterfaceDescriptorSetType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_net__InterfaceDescriptorSetType, 0, sizeof(net__InterfaceDescriptorSetType), 0, soap_copy_net__InterfaceDescriptorSetType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 net__InterfaceDescriptorSetType * SOAP_FMAC6 soap_new_net__InterfaceDescriptorSetType(struct soap *soap, int n) +{ return soap_instantiate_net__InterfaceDescriptorSetType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__InterfaceDescriptorSetType(struct soap *soap, net__InterfaceDescriptorSetType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 net__InterfaceDescriptorSetType * SOAP_FMAC4 soap_instantiate_net__InterfaceDescriptorSetType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_net__InterfaceDescriptorSetType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_net__InterfaceDescriptorSetType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new net__InterfaceDescriptorSetType; + if (size) + *size = sizeof(net__InterfaceDescriptorSetType); + ((net__InterfaceDescriptorSetType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new net__InterfaceDescriptorSetType[n]; + if (size) + *size = n * sizeof(net__InterfaceDescriptorSetType); + for (int i = 0; i < n; i++) + ((net__InterfaceDescriptorSetType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (net__InterfaceDescriptorSetType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__InterfaceDescriptorSetType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying net__InterfaceDescriptorSetType %p -> %p\n", q, p)); + *(net__InterfaceDescriptorSetType*)p = *(net__InterfaceDescriptorSetType*)q; +} + +void net__IPv4ParametersType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void net__IPv4ParametersType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__IPv4AddressType(soap, &((net__IPv4ParametersType*)this)->LocalAddress); + soap_default_net__IPv4AddressType(soap, &((net__IPv4ParametersType*)this)->SubnetMask); + soap_default_net__IPv4AddressType(soap, &((net__IPv4ParametersType*)this)->DefaultGatewayAddress); + soap_default_net__IPv4AddressType(soap, &((net__IPv4ParametersType*)this)->PrimaryDnsAddress); + soap_default_net__IPv4AddressType(soap, &((net__IPv4ParametersType*)this)->SecondaryDnsAddress); + /* transient soap skipped */ +} + +int net__IPv4ParametersType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_net__IPv4ParametersType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int net__IPv4ParametersType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_net__IPv4ParametersType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__IPv4ParametersType(struct soap *soap, const char *tag, int id, const net__IPv4ParametersType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_net__IPv4ParametersType), type); + soap_out_net__IPv4AddressType(soap, "net:LocalAddress", -1, &(((net__IPv4ParametersType*)a)->LocalAddress), ""); + soap_out_net__IPv4AddressType(soap, "net:SubnetMask", -1, &(((net__IPv4ParametersType*)a)->SubnetMask), ""); + soap_out_net__IPv4AddressType(soap, "net:DefaultGatewayAddress", -1, &(((net__IPv4ParametersType*)a)->DefaultGatewayAddress), ""); + soap_out_net__IPv4AddressType(soap, "net:PrimaryDnsAddress", -1, &(((net__IPv4ParametersType*)a)->PrimaryDnsAddress), ""); + soap_out_net__IPv4AddressType(soap, "net:SecondaryDnsAddress", -1, &(((net__IPv4ParametersType*)a)->SecondaryDnsAddress), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *net__IPv4ParametersType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_net__IPv4ParametersType(soap, this, tag, type); +} + +SOAP_FMAC3 net__IPv4ParametersType * SOAP_FMAC4 soap_get_net__IPv4ParametersType(struct soap *soap, net__IPv4ParametersType *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__IPv4ParametersType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *net__IPv4ParametersType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_net__IPv4ParametersType(soap, tag, this, type); +} + +SOAP_FMAC3 net__IPv4ParametersType * SOAP_FMAC4 soap_in_net__IPv4ParametersType(struct soap *soap, const char *tag, net__IPv4ParametersType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (net__IPv4ParametersType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_net__IPv4ParametersType, sizeof(net__IPv4ParametersType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_net__IPv4ParametersType) + { soap_revert(soap); + *soap->id = '\0'; + return (net__IPv4ParametersType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_LocalAddress1 = 1, soap_flag_SubnetMask1 = 1, soap_flag_DefaultGatewayAddress1 = 1, soap_flag_PrimaryDnsAddress1 = 1, soap_flag_SecondaryDnsAddress1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_LocalAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:LocalAddress", &(((net__IPv4ParametersType*)a)->LocalAddress), "net:IPv4AddressType")) + { soap_flag_LocalAddress1--; + continue; + } + if (soap_flag_SubnetMask1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:SubnetMask", &(((net__IPv4ParametersType*)a)->SubnetMask), "net:IPv4AddressType")) + { soap_flag_SubnetMask1--; + continue; + } + if (soap_flag_DefaultGatewayAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:DefaultGatewayAddress", &(((net__IPv4ParametersType*)a)->DefaultGatewayAddress), "net:IPv4AddressType")) + { soap_flag_DefaultGatewayAddress1--; + continue; + } + if (soap_flag_PrimaryDnsAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:PrimaryDnsAddress", &(((net__IPv4ParametersType*)a)->PrimaryDnsAddress), "net:IPv4AddressType")) + { soap_flag_PrimaryDnsAddress1--; + continue; + } + if (soap_flag_SecondaryDnsAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:SecondaryDnsAddress", &(((net__IPv4ParametersType*)a)->SecondaryDnsAddress), "net:IPv4AddressType")) + { soap_flag_SecondaryDnsAddress1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_LocalAddress1 > 0 || soap_flag_SubnetMask1 > 0 || soap_flag_DefaultGatewayAddress1 > 0 || soap_flag_PrimaryDnsAddress1 > 0 || soap_flag_SecondaryDnsAddress1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (net__IPv4ParametersType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_net__IPv4ParametersType, 0, sizeof(net__IPv4ParametersType), 0, soap_copy_net__IPv4ParametersType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 net__IPv4ParametersType * SOAP_FMAC6 soap_new_net__IPv4ParametersType(struct soap *soap, int n) +{ return soap_instantiate_net__IPv4ParametersType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__IPv4ParametersType(struct soap *soap, net__IPv4ParametersType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 net__IPv4ParametersType * SOAP_FMAC4 soap_instantiate_net__IPv4ParametersType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_net__IPv4ParametersType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_net__IPv4ParametersType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new net__IPv4ParametersType; + if (size) + *size = sizeof(net__IPv4ParametersType); + ((net__IPv4ParametersType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new net__IPv4ParametersType[n]; + if (size) + *size = n * sizeof(net__IPv4ParametersType); + for (int i = 0; i < n; i++) + ((net__IPv4ParametersType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (net__IPv4ParametersType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__IPv4ParametersType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying net__IPv4ParametersType %p -> %p\n", q, p)); + *(net__IPv4ParametersType*)p = *(net__IPv4ParametersType*)q; +} + +void net__StaticIPv4ParametersType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostd__string(soap, &((net__StaticIPv4ParametersType*)this)->DomainName); + /* transient soap skipped */ +} + +void net__StaticIPv4ParametersType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_net__IPv4AddressType(soap, &((net__StaticIPv4ParametersType*)this)->LocalAddress); + soap_default_net__IPv4AddressType(soap, &((net__StaticIPv4ParametersType*)this)->SubnetMask); + soap_default_net__IPv4AddressType(soap, &((net__StaticIPv4ParametersType*)this)->DefaultGatewayAddress); + soap_default_net__IPv4AddressType(soap, &((net__StaticIPv4ParametersType*)this)->PrimaryDnsAddress); + soap_default_net__IPv4AddressType(soap, &((net__StaticIPv4ParametersType*)this)->SecondaryDnsAddress); + ((net__StaticIPv4ParametersType*)this)->DomainName = NULL; + /* transient soap skipped */ +} + +int net__StaticIPv4ParametersType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_net__StaticIPv4ParametersType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int net__StaticIPv4ParametersType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_net__StaticIPv4ParametersType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_net__StaticIPv4ParametersType(struct soap *soap, const char *tag, int id, const net__StaticIPv4ParametersType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_net__StaticIPv4ParametersType), type); + soap_out_net__IPv4AddressType(soap, "net:LocalAddress", -1, &(((net__StaticIPv4ParametersType*)a)->LocalAddress), ""); + soap_out_net__IPv4AddressType(soap, "net:SubnetMask", -1, &(((net__StaticIPv4ParametersType*)a)->SubnetMask), ""); + soap_out_net__IPv4AddressType(soap, "net:DefaultGatewayAddress", -1, &(((net__StaticIPv4ParametersType*)a)->DefaultGatewayAddress), ""); + soap_out_net__IPv4AddressType(soap, "net:PrimaryDnsAddress", -1, &(((net__StaticIPv4ParametersType*)a)->PrimaryDnsAddress), ""); + soap_out_net__IPv4AddressType(soap, "net:SecondaryDnsAddress", -1, &(((net__StaticIPv4ParametersType*)a)->SecondaryDnsAddress), ""); + soap_out_PointerTostd__string(soap, "net:DomainName", -1, &(((net__StaticIPv4ParametersType*)a)->DomainName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *net__StaticIPv4ParametersType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_net__StaticIPv4ParametersType(soap, this, tag, type); +} + +SOAP_FMAC3 net__StaticIPv4ParametersType * SOAP_FMAC4 soap_get_net__StaticIPv4ParametersType(struct soap *soap, net__StaticIPv4ParametersType *p, const char *tag, const char *type) +{ + if ((p = soap_in_net__StaticIPv4ParametersType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *net__StaticIPv4ParametersType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_net__StaticIPv4ParametersType(soap, tag, this, type); +} + +SOAP_FMAC3 net__StaticIPv4ParametersType * SOAP_FMAC4 soap_in_net__StaticIPv4ParametersType(struct soap *soap, const char *tag, net__StaticIPv4ParametersType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (net__StaticIPv4ParametersType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_net__StaticIPv4ParametersType, sizeof(net__StaticIPv4ParametersType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_net__StaticIPv4ParametersType) + { soap_revert(soap); + *soap->id = '\0'; + return (net__StaticIPv4ParametersType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_LocalAddress1 = 1, soap_flag_SubnetMask1 = 1, soap_flag_DefaultGatewayAddress1 = 1, soap_flag_PrimaryDnsAddress1 = 1, soap_flag_SecondaryDnsAddress1 = 1, soap_flag_DomainName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_LocalAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:LocalAddress", &(((net__StaticIPv4ParametersType*)a)->LocalAddress), "net:IPv4AddressType")) + { soap_flag_LocalAddress1--; + continue; + } + if (soap_flag_SubnetMask1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:SubnetMask", &(((net__StaticIPv4ParametersType*)a)->SubnetMask), "net:IPv4AddressType")) + { soap_flag_SubnetMask1--; + continue; + } + if (soap_flag_DefaultGatewayAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:DefaultGatewayAddress", &(((net__StaticIPv4ParametersType*)a)->DefaultGatewayAddress), "net:IPv4AddressType")) + { soap_flag_DefaultGatewayAddress1--; + continue; + } + if (soap_flag_PrimaryDnsAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:PrimaryDnsAddress", &(((net__StaticIPv4ParametersType*)a)->PrimaryDnsAddress), "net:IPv4AddressType")) + { soap_flag_PrimaryDnsAddress1--; + continue; + } + if (soap_flag_SecondaryDnsAddress1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_net__IPv4AddressType(soap, "net:SecondaryDnsAddress", &(((net__StaticIPv4ParametersType*)a)->SecondaryDnsAddress), "net:IPv4AddressType")) + { soap_flag_SecondaryDnsAddress1--; + continue; + } + if (soap_flag_DomainName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "net:DomainName", &(((net__StaticIPv4ParametersType*)a)->DomainName), "xsd:string")) + { soap_flag_DomainName1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_LocalAddress1 > 0 || soap_flag_SubnetMask1 > 0 || soap_flag_DefaultGatewayAddress1 > 0 || soap_flag_PrimaryDnsAddress1 > 0 || soap_flag_SecondaryDnsAddress1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (net__StaticIPv4ParametersType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_net__StaticIPv4ParametersType, 0, sizeof(net__StaticIPv4ParametersType), 0, soap_copy_net__StaticIPv4ParametersType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 net__StaticIPv4ParametersType * SOAP_FMAC6 soap_new_net__StaticIPv4ParametersType(struct soap *soap, int n) +{ return soap_instantiate_net__StaticIPv4ParametersType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_net__StaticIPv4ParametersType(struct soap *soap, net__StaticIPv4ParametersType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 net__StaticIPv4ParametersType * SOAP_FMAC4 soap_instantiate_net__StaticIPv4ParametersType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_net__StaticIPv4ParametersType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_net__StaticIPv4ParametersType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new net__StaticIPv4ParametersType; + if (size) + *size = sizeof(net__StaticIPv4ParametersType); + ((net__StaticIPv4ParametersType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new net__StaticIPv4ParametersType[n]; + if (size) + *size = n * sizeof(net__StaticIPv4ParametersType); + for (int i = 0; i < n; i++) + ((net__StaticIPv4ParametersType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (net__StaticIPv4ParametersType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_net__StaticIPv4ParametersType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying net__StaticIPv4ParametersType %p -> %p\n", q, p)); + *(net__StaticIPv4ParametersType*)p = *(net__StaticIPv4ParametersType*)q; +} + +void xcfg__XProfileType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__xcfg__union_XProfileType(soap, ((xcfg__XProfileType*)this)->__union_XProfileType, &((xcfg__XProfileType*)this)->union_XProfileType); + /* transient soap skipped */ +} + +void xcfg__XProfileType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((xcfg__XProfileType*)this)->__union_XProfileType = 0; + /* transient soap skipped */ +} + +int xcfg__XProfileType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__XProfileType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__XProfileType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__XProfileType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileType(struct soap *soap, const char *tag, int id, const xcfg__XProfileType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__XProfileType), type); + soap_out__xcfg__union_XProfileType(soap, ((xcfg__XProfileType*)a)->__union_XProfileType, &((xcfg__XProfileType*)a)->union_XProfileType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__XProfileType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__XProfileType(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__XProfileType * SOAP_FMAC4 soap_get_xcfg__XProfileType(struct soap *soap, xcfg__XProfileType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__XProfileType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__XProfileType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__XProfileType(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__XProfileType * SOAP_FMAC4 soap_in_xcfg__XProfileType(struct soap *soap, const char *tag, xcfg__XProfileType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__XProfileType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__XProfileType, sizeof(xcfg__XProfileType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__XProfileType) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__XProfileType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_XProfileType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_XProfileType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__xcfg__union_XProfileType(soap, &((xcfg__XProfileType*)a)->__union_XProfileType, &((xcfg__XProfileType*)a)->union_XProfileType)) + { soap_flag_union_XProfileType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_XProfileType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__XProfileType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__XProfileType, 0, sizeof(xcfg__XProfileType), 0, soap_copy_xcfg__XProfileType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__XProfileType * SOAP_FMAC6 soap_new_xcfg__XProfileType(struct soap *soap, int n) +{ return soap_instantiate_xcfg__XProfileType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileType(struct soap *soap, xcfg__XProfileType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__XProfileType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__XProfileType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__XProfileType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__XProfileType; + if (size) + *size = sizeof(xcfg__XProfileType); + ((xcfg__XProfileType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__XProfileType[n]; + if (size) + *size = n * sizeof(xcfg__XProfileType); + for (int i = 0; i < n; i++) + ((xcfg__XProfileType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__XProfileType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__XProfileType %p -> %p\n", q, p)); + *(xcfg__XProfileType*)p = *(xcfg__XProfileType*)q; +} + +void xcfg__XProfileEAPFAST_USCORETLSType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostd__string(soap, &((xcfg__XProfileEAPFAST_USCORETLSType*)this)->RoamingIdentity); + soap_serialize_PointerToxcfg__ServerIdentityType(soap, &((xcfg__XProfileEAPFAST_USCORETLSType*)this)->ServerIdentity); + soap_serialize_PointerToxcfg__UserCredentialsType(soap, &((xcfg__XProfileEAPFAST_USCORETLSType*)this)->UserCredentials); + soap_serialize_PointerToxcfg__ManualPACType(soap, &((xcfg__XProfileEAPFAST_USCORETLSType*)this)->ProtectedAccessCredentials); + soap_embedded(soap, &((xcfg__XProfileEAPFAST_USCORETLSType*)this)->ClientCertificate, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void xcfg__XProfileEAPFAST_USCORETLSType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((xcfg__XProfileEAPFAST_USCORETLSType*)this)->RoamingIdentity = NULL; + ((xcfg__XProfileEAPFAST_USCORETLSType*)this)->ServerIdentity = NULL; + ((xcfg__XProfileEAPFAST_USCORETLSType*)this)->UserCredentials = NULL; + ((xcfg__XProfileEAPFAST_USCORETLSType*)this)->ProtectedAccessCredentials = NULL; + soap_default_sai__CertificateHandleType(soap, &((xcfg__XProfileEAPFAST_USCORETLSType*)this)->ClientCertificate); + /* transient soap skipped */ +} + +int xcfg__XProfileEAPFAST_USCORETLSType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__XProfileEAPFAST_USCORETLSType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__XProfileEAPFAST_USCORETLSType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, const char *tag, int id, const xcfg__XProfileEAPFAST_USCORETLSType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType), type); + soap_out_PointerTostd__string(soap, "xcfg:RoamingIdentity", -1, &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->RoamingIdentity), ""); + soap_out_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", -1, &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->ServerIdentity), ""); + soap_out_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", -1, &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->UserCredentials), ""); + soap_out_PointerToxcfg__ManualPACType(soap, "xcfg:ProtectedAccessCredentials", -1, &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->ProtectedAccessCredentials), ""); + soap_out_sai__CertificateHandleType(soap, "xcfg:ClientCertificate", -1, &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->ClientCertificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__XProfileEAPFAST_USCORETLSType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__XProfileEAPFAST_USCORETLSType(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType * SOAP_FMAC4 soap_get_xcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, xcfg__XProfileEAPFAST_USCORETLSType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__XProfileEAPFAST_USCORETLSType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__XProfileEAPFAST_USCORETLSType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__XProfileEAPFAST_USCORETLSType(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType * SOAP_FMAC4 soap_in_xcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, const char *tag, xcfg__XProfileEAPFAST_USCORETLSType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__XProfileEAPFAST_USCORETLSType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType, sizeof(xcfg__XProfileEAPFAST_USCORETLSType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__XProfileEAPFAST_USCORETLSType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_RoamingIdentity1 = 1, soap_flag_ServerIdentity1 = 1, soap_flag_UserCredentials1 = 1, soap_flag_ProtectedAccessCredentials1 = 1, soap_flag_ClientCertificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_RoamingIdentity1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "xcfg:RoamingIdentity", &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->RoamingIdentity), "xsd:string")) + { soap_flag_RoamingIdentity1--; + continue; + } + if (soap_flag_ServerIdentity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->ServerIdentity), "xcfg:ServerIdentityType")) + { soap_flag_ServerIdentity1--; + continue; + } + if (soap_flag_UserCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->UserCredentials), "xcfg:UserCredentialsType")) + { soap_flag_UserCredentials1--; + continue; + } + if (soap_flag_ProtectedAccessCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__ManualPACType(soap, "xcfg:ProtectedAccessCredentials", &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->ProtectedAccessCredentials), "xcfg:ManualPACType")) + { soap_flag_ProtectedAccessCredentials1--; + continue; + } + if (soap_flag_ClientCertificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "xcfg:ClientCertificate", &(((xcfg__XProfileEAPFAST_USCORETLSType*)a)->ClientCertificate), "sai:CertificateHandleType")) + { soap_flag_ClientCertificate1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ServerIdentity1 > 0 || soap_flag_UserCredentials1 > 0 || soap_flag_ClientCertificate1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__XProfileEAPFAST_USCORETLSType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType, 0, sizeof(xcfg__XProfileEAPFAST_USCORETLSType), 0, soap_copy_xcfg__XProfileEAPFAST_USCORETLSType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__XProfileEAPFAST_USCORETLSType * SOAP_FMAC6 soap_new_xcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, int n) +{ return soap_instantiate_xcfg__XProfileEAPFAST_USCORETLSType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, xcfg__XProfileEAPFAST_USCORETLSType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__XProfileEAPFAST_USCORETLSType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__XProfileEAPFAST_USCORETLSType; + if (size) + *size = sizeof(xcfg__XProfileEAPFAST_USCORETLSType); + ((xcfg__XProfileEAPFAST_USCORETLSType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__XProfileEAPFAST_USCORETLSType[n]; + if (size) + *size = n * sizeof(xcfg__XProfileEAPFAST_USCORETLSType); + for (int i = 0; i < n; i++) + ((xcfg__XProfileEAPFAST_USCORETLSType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__XProfileEAPFAST_USCORETLSType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__XProfileEAPFAST_USCORETLSType %p -> %p\n", q, p)); + *(xcfg__XProfileEAPFAST_USCORETLSType*)p = *(xcfg__XProfileEAPFAST_USCORETLSType*)q; +} + +void xcfg__XProfileEAPFAST_USCOREGTCType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostd__string(soap, &((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->RoamingIdentity); + soap_serialize_PointerToxcfg__ServerIdentityType(soap, &((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->ServerIdentity); + soap_serialize_PointerToxcfg__UserCredentialsType(soap, &((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->UserCredentials); + soap_serialize_PointerToxcfg__ManualPACType(soap, &((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->ProtectedAccessCredentials); + soap_serialize_PointerTosai__CertificateHandleType(soap, &((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->ClientCertificate); + /* transient soap skipped */ +} + +void xcfg__XProfileEAPFAST_USCOREGTCType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->RoamingIdentity = NULL; + ((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->ServerIdentity = NULL; + ((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->UserCredentials = NULL; + ((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->ProtectedAccessCredentials = NULL; + ((xcfg__XProfileEAPFAST_USCOREGTCType*)this)->ClientCertificate = NULL; + /* transient soap skipped */ +} + +int xcfg__XProfileEAPFAST_USCOREGTCType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__XProfileEAPFAST_USCOREGTCType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__XProfileEAPFAST_USCOREGTCType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, const char *tag, int id, const xcfg__XProfileEAPFAST_USCOREGTCType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType), type); + soap_out_PointerTostd__string(soap, "xcfg:RoamingIdentity", -1, &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->RoamingIdentity), ""); + soap_out_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", -1, &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->ServerIdentity), ""); + soap_out_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", -1, &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->UserCredentials), ""); + soap_out_PointerToxcfg__ManualPACType(soap, "xcfg:ProtectedAccessCredentials", -1, &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->ProtectedAccessCredentials), ""); + soap_out_PointerTosai__CertificateHandleType(soap, "xcfg:ClientCertificate", -1, &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->ClientCertificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__XProfileEAPFAST_USCOREGTCType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__XProfileEAPFAST_USCOREGTCType(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType * SOAP_FMAC4 soap_get_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, xcfg__XProfileEAPFAST_USCOREGTCType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__XProfileEAPFAST_USCOREGTCType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__XProfileEAPFAST_USCOREGTCType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__XProfileEAPFAST_USCOREGTCType(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType * SOAP_FMAC4 soap_in_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, const char *tag, xcfg__XProfileEAPFAST_USCOREGTCType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__XProfileEAPFAST_USCOREGTCType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType, sizeof(xcfg__XProfileEAPFAST_USCOREGTCType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__XProfileEAPFAST_USCOREGTCType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_RoamingIdentity1 = 1, soap_flag_ServerIdentity1 = 1, soap_flag_UserCredentials1 = 1, soap_flag_ProtectedAccessCredentials1 = 1, soap_flag_ClientCertificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_RoamingIdentity1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "xcfg:RoamingIdentity", &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->RoamingIdentity), "xsd:string")) + { soap_flag_RoamingIdentity1--; + continue; + } + if (soap_flag_ServerIdentity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->ServerIdentity), "xcfg:ServerIdentityType")) + { soap_flag_ServerIdentity1--; + continue; + } + if (soap_flag_UserCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->UserCredentials), "xcfg:UserCredentialsType")) + { soap_flag_UserCredentials1--; + continue; + } + if (soap_flag_ProtectedAccessCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__ManualPACType(soap, "xcfg:ProtectedAccessCredentials", &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->ProtectedAccessCredentials), "xcfg:ManualPACType")) + { soap_flag_ProtectedAccessCredentials1--; + continue; + } + if (soap_flag_ClientCertificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateHandleType(soap, "xcfg:ClientCertificate", &(((xcfg__XProfileEAPFAST_USCOREGTCType*)a)->ClientCertificate), "sai:CertificateHandleType")) + { soap_flag_ClientCertificate1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ServerIdentity1 > 0 || soap_flag_UserCredentials1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__XProfileEAPFAST_USCOREGTCType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType, 0, sizeof(xcfg__XProfileEAPFAST_USCOREGTCType), 0, soap_copy_xcfg__XProfileEAPFAST_USCOREGTCType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__XProfileEAPFAST_USCOREGTCType * SOAP_FMAC6 soap_new_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, int n) +{ return soap_instantiate_xcfg__XProfileEAPFAST_USCOREGTCType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, xcfg__XProfileEAPFAST_USCOREGTCType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__XProfileEAPFAST_USCOREGTCType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__XProfileEAPFAST_USCOREGTCType; + if (size) + *size = sizeof(xcfg__XProfileEAPFAST_USCOREGTCType); + ((xcfg__XProfileEAPFAST_USCOREGTCType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__XProfileEAPFAST_USCOREGTCType[n]; + if (size) + *size = n * sizeof(xcfg__XProfileEAPFAST_USCOREGTCType); + for (int i = 0; i < n; i++) + ((xcfg__XProfileEAPFAST_USCOREGTCType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__XProfileEAPFAST_USCOREGTCType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__XProfileEAPFAST_USCOREGTCType %p -> %p\n", q, p)); + *(xcfg__XProfileEAPFAST_USCOREGTCType*)p = *(xcfg__XProfileEAPFAST_USCOREGTCType*)q; +} + +void xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostd__string(soap, &((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->RoamingIdentity); + soap_serialize_PointerToxcfg__ServerIdentityType(soap, &((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->ServerIdentity); + soap_serialize_PointerToxcfg__UserCredentialsType(soap, &((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->UserCredentials); + soap_serialize_PointerToxcfg__ManualPACType(soap, &((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->ProtectedAccessCredentials); + soap_serialize_PointerTosai__CertificateHandleType(soap, &((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->ClientCertificate); + /* transient soap skipped */ +} + +void xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type::soap_default(struct soap *soap) +{ + this->soap = soap; + ((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->RoamingIdentity = NULL; + ((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->ServerIdentity = NULL; + ((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->UserCredentials = NULL; + ((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->ProtectedAccessCredentials = NULL; + ((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)this)->ClientCertificate = NULL; + /* transient soap skipped */ +} + +int xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, int id, const xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type), type); + soap_out_PointerTostd__string(soap, "xcfg:RoamingIdentity", -1, &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->RoamingIdentity), ""); + soap_out_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", -1, &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->ServerIdentity), ""); + soap_out_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", -1, &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->UserCredentials), ""); + soap_out_PointerToxcfg__ManualPACType(soap, "xcfg:ProtectedAccessCredentials", -1, &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->ProtectedAccessCredentials), ""); + soap_out_PointerTosai__CertificateHandleType(soap, "xcfg:ClientCertificate", -1, &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->ClientCertificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_get_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_in_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type, sizeof(xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *)a->soap_in(soap, tag, type); + } + } + short soap_flag_RoamingIdentity1 = 1, soap_flag_ServerIdentity1 = 1, soap_flag_UserCredentials1 = 1, soap_flag_ProtectedAccessCredentials1 = 1, soap_flag_ClientCertificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_RoamingIdentity1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "xcfg:RoamingIdentity", &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->RoamingIdentity), "xsd:string")) + { soap_flag_RoamingIdentity1--; + continue; + } + if (soap_flag_ServerIdentity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->ServerIdentity), "xcfg:ServerIdentityType")) + { soap_flag_ServerIdentity1--; + continue; + } + if (soap_flag_UserCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->UserCredentials), "xcfg:UserCredentialsType")) + { soap_flag_UserCredentials1--; + continue; + } + if (soap_flag_ProtectedAccessCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__ManualPACType(soap, "xcfg:ProtectedAccessCredentials", &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->ProtectedAccessCredentials), "xcfg:ManualPACType")) + { soap_flag_ProtectedAccessCredentials1--; + continue; + } + if (soap_flag_ClientCertificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateHandleType(soap, "xcfg:ClientCertificate", &(((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)a)->ClientCertificate), "sai:CertificateHandleType")) + { soap_flag_ClientCertificate1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ServerIdentity1 > 0 || soap_flag_UserCredentials1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type, 0, sizeof(xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type), 0, soap_copy_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type * SOAP_FMAC6 soap_new_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, int n) +{ return soap_instantiate_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_instantiate_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type; + if (size) + *size = sizeof(xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type); + ((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type[n]; + if (size) + *size = n * sizeof(xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type); + for (int i = 0; i < n; i++) + ((xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type %p -> %p\n", q, p)); + *(xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)p = *(xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type*)q; +} + +void xcfg__XProfileEAP_USCOREGTCType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerToxcfg__UserCredentialsType(soap, &((xcfg__XProfileEAP_USCOREGTCType*)this)->UserCredentials); + /* transient soap skipped */ +} + +void xcfg__XProfileEAP_USCOREGTCType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((xcfg__XProfileEAP_USCOREGTCType*)this)->UserCredentials = NULL; + /* transient soap skipped */ +} + +int xcfg__XProfileEAP_USCOREGTCType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__XProfileEAP_USCOREGTCType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__XProfileEAP_USCOREGTCType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileEAP_USCOREGTCType(struct soap *soap, const char *tag, int id, const xcfg__XProfileEAP_USCOREGTCType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType), type); + soap_out_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", -1, &(((xcfg__XProfileEAP_USCOREGTCType*)a)->UserCredentials), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__XProfileEAP_USCOREGTCType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__XProfileEAP_USCOREGTCType(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType * SOAP_FMAC4 soap_get_xcfg__XProfileEAP_USCOREGTCType(struct soap *soap, xcfg__XProfileEAP_USCOREGTCType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__XProfileEAP_USCOREGTCType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__XProfileEAP_USCOREGTCType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__XProfileEAP_USCOREGTCType(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType * SOAP_FMAC4 soap_in_xcfg__XProfileEAP_USCOREGTCType(struct soap *soap, const char *tag, xcfg__XProfileEAP_USCOREGTCType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__XProfileEAP_USCOREGTCType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType, sizeof(xcfg__XProfileEAP_USCOREGTCType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__XProfileEAP_USCOREGTCType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_UserCredentials1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_UserCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", &(((xcfg__XProfileEAP_USCOREGTCType*)a)->UserCredentials), "xcfg:UserCredentialsType")) + { soap_flag_UserCredentials1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_UserCredentials1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__XProfileEAP_USCOREGTCType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType, 0, sizeof(xcfg__XProfileEAP_USCOREGTCType), 0, soap_copy_xcfg__XProfileEAP_USCOREGTCType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__XProfileEAP_USCOREGTCType * SOAP_FMAC6 soap_new_xcfg__XProfileEAP_USCOREGTCType(struct soap *soap, int n) +{ return soap_instantiate_xcfg__XProfileEAP_USCOREGTCType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileEAP_USCOREGTCType(struct soap *soap, xcfg__XProfileEAP_USCOREGTCType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileEAP_USCOREGTCType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__XProfileEAP_USCOREGTCType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__XProfileEAP_USCOREGTCType; + if (size) + *size = sizeof(xcfg__XProfileEAP_USCOREGTCType); + ((xcfg__XProfileEAP_USCOREGTCType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__XProfileEAP_USCOREGTCType[n]; + if (size) + *size = n * sizeof(xcfg__XProfileEAP_USCOREGTCType); + for (int i = 0; i < n; i++) + ((xcfg__XProfileEAP_USCOREGTCType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__XProfileEAP_USCOREGTCType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileEAP_USCOREGTCType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__XProfileEAP_USCOREGTCType %p -> %p\n", q, p)); + *(xcfg__XProfileEAP_USCOREGTCType*)p = *(xcfg__XProfileEAP_USCOREGTCType*)q; +} + +void xcfg__XProfilePEAP_USCOREMSCHAPv2Type::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostd__string(soap, &((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)this)->RoamingIdentity); + soap_serialize_PointerToxcfg__ServerIdentityType(soap, &((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)this)->ServerIdentity); + soap_serialize_PointerToxcfg__UserCredentialsType(soap, &((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)this)->UserCredentials); + soap_serialize_PointerTosai__CertificateHandleType(soap, &((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)this)->ClientCertificate); + /* transient soap skipped */ +} + +void xcfg__XProfilePEAP_USCOREMSCHAPv2Type::soap_default(struct soap *soap) +{ + this->soap = soap; + ((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)this)->RoamingIdentity = NULL; + ((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)this)->ServerIdentity = NULL; + ((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)this)->UserCredentials = NULL; + ((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)this)->ClientCertificate = NULL; + /* transient soap skipped */ +} + +int xcfg__XProfilePEAP_USCOREMSCHAPv2Type::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__XProfilePEAP_USCOREMSCHAPv2Type::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, int id, const xcfg__XProfilePEAP_USCOREMSCHAPv2Type *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type), type); + soap_out_PointerTostd__string(soap, "xcfg:RoamingIdentity", -1, &(((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)a)->RoamingIdentity), ""); + soap_out_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", -1, &(((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)a)->ServerIdentity), ""); + soap_out_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", -1, &(((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)a)->UserCredentials), ""); + soap_out_PointerTosai__CertificateHandleType(soap, "xcfg:ClientCertificate", -1, &(((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)a)->ClientCertificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__XProfilePEAP_USCOREMSCHAPv2Type::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_get_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__XProfilePEAP_USCOREMSCHAPv2Type::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_in_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__XProfilePEAP_USCOREMSCHAPv2Type *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type, sizeof(xcfg__XProfilePEAP_USCOREMSCHAPv2Type), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__XProfilePEAP_USCOREMSCHAPv2Type *)a->soap_in(soap, tag, type); + } + } + short soap_flag_RoamingIdentity1 = 1, soap_flag_ServerIdentity1 = 1, soap_flag_UserCredentials1 = 1, soap_flag_ClientCertificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_RoamingIdentity1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "xcfg:RoamingIdentity", &(((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)a)->RoamingIdentity), "xsd:string")) + { soap_flag_RoamingIdentity1--; + continue; + } + if (soap_flag_ServerIdentity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", &(((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)a)->ServerIdentity), "xcfg:ServerIdentityType")) + { soap_flag_ServerIdentity1--; + continue; + } + if (soap_flag_UserCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", &(((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)a)->UserCredentials), "xcfg:UserCredentialsType")) + { soap_flag_UserCredentials1--; + continue; + } + if (soap_flag_ClientCertificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateHandleType(soap, "xcfg:ClientCertificate", &(((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)a)->ClientCertificate), "sai:CertificateHandleType")) + { soap_flag_ClientCertificate1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ServerIdentity1 > 0 || soap_flag_UserCredentials1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__XProfilePEAP_USCOREMSCHAPv2Type *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type, 0, sizeof(xcfg__XProfilePEAP_USCOREMSCHAPv2Type), 0, soap_copy_xcfg__XProfilePEAP_USCOREMSCHAPv2Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__XProfilePEAP_USCOREMSCHAPv2Type * SOAP_FMAC6 soap_new_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, int n) +{ return soap_instantiate_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_instantiate_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__XProfilePEAP_USCOREMSCHAPv2Type; + if (size) + *size = sizeof(xcfg__XProfilePEAP_USCOREMSCHAPv2Type); + ((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__XProfilePEAP_USCOREMSCHAPv2Type[n]; + if (size) + *size = n * sizeof(xcfg__XProfilePEAP_USCOREMSCHAPv2Type); + for (int i = 0; i < n; i++) + ((xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__XProfilePEAP_USCOREMSCHAPv2Type %p -> %p\n", q, p)); + *(xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)p = *(xcfg__XProfilePEAP_USCOREMSCHAPv2Type*)q; +} + +void xcfg__XProfileTTLS_USCOREMSCHAPv2Type::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostd__string(soap, &((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)this)->RoamingIdentity); + soap_serialize_PointerToxcfg__ServerIdentityType(soap, &((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)this)->ServerIdentity); + soap_serialize_PointerToxcfg__UserCredentialsType(soap, &((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)this)->UserCredentials); + soap_serialize_PointerTosai__CertificateHandleType(soap, &((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)this)->ClientCertificate); + /* transient soap skipped */ +} + +void xcfg__XProfileTTLS_USCOREMSCHAPv2Type::soap_default(struct soap *soap) +{ + this->soap = soap; + ((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)this)->RoamingIdentity = NULL; + ((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)this)->ServerIdentity = NULL; + ((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)this)->UserCredentials = NULL; + ((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)this)->ClientCertificate = NULL; + /* transient soap skipped */ +} + +int xcfg__XProfileTTLS_USCOREMSCHAPv2Type::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__XProfileTTLS_USCOREMSCHAPv2Type::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, int id, const xcfg__XProfileTTLS_USCOREMSCHAPv2Type *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type), type); + soap_out_PointerTostd__string(soap, "xcfg:RoamingIdentity", -1, &(((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)a)->RoamingIdentity), ""); + soap_out_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", -1, &(((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)a)->ServerIdentity), ""); + soap_out_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", -1, &(((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)a)->UserCredentials), ""); + soap_out_PointerTosai__CertificateHandleType(soap, "xcfg:ClientCertificate", -1, &(((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)a)->ClientCertificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__XProfileTTLS_USCOREMSCHAPv2Type::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_get_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__XProfileTTLS_USCOREMSCHAPv2Type::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_in_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__XProfileTTLS_USCOREMSCHAPv2Type *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type, sizeof(xcfg__XProfileTTLS_USCOREMSCHAPv2Type), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__XProfileTTLS_USCOREMSCHAPv2Type *)a->soap_in(soap, tag, type); + } + } + short soap_flag_RoamingIdentity1 = 1, soap_flag_ServerIdentity1 = 1, soap_flag_UserCredentials1 = 1, soap_flag_ClientCertificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_RoamingIdentity1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "xcfg:RoamingIdentity", &(((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)a)->RoamingIdentity), "xsd:string")) + { soap_flag_RoamingIdentity1--; + continue; + } + if (soap_flag_ServerIdentity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", &(((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)a)->ServerIdentity), "xcfg:ServerIdentityType")) + { soap_flag_ServerIdentity1--; + continue; + } + if (soap_flag_UserCredentials1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__UserCredentialsType(soap, "xcfg:UserCredentials", &(((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)a)->UserCredentials), "xcfg:UserCredentialsType")) + { soap_flag_UserCredentials1--; + continue; + } + if (soap_flag_ClientCertificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateHandleType(soap, "xcfg:ClientCertificate", &(((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)a)->ClientCertificate), "sai:CertificateHandleType")) + { soap_flag_ClientCertificate1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ServerIdentity1 > 0 || soap_flag_UserCredentials1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__XProfileTTLS_USCOREMSCHAPv2Type *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type, 0, sizeof(xcfg__XProfileTTLS_USCOREMSCHAPv2Type), 0, soap_copy_xcfg__XProfileTTLS_USCOREMSCHAPv2Type); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__XProfileTTLS_USCOREMSCHAPv2Type * SOAP_FMAC6 soap_new_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, int n) +{ return soap_instantiate_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type * SOAP_FMAC4 soap_instantiate_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__XProfileTTLS_USCOREMSCHAPv2Type; + if (size) + *size = sizeof(xcfg__XProfileTTLS_USCOREMSCHAPv2Type); + ((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__XProfileTTLS_USCOREMSCHAPv2Type[n]; + if (size) + *size = n * sizeof(xcfg__XProfileTTLS_USCOREMSCHAPv2Type); + for (int i = 0; i < n; i++) + ((xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__XProfileTTLS_USCOREMSCHAPv2Type %p -> %p\n", q, p)); + *(xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)p = *(xcfg__XProfileTTLS_USCOREMSCHAPv2Type*)q; +} + +void xcfg__XProfileTLSType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((xcfg__XProfileTLSType*)this)->Username, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((xcfg__XProfileTLSType*)this)->Username); + soap_serialize_PointerToxcfg__ServerIdentityType(soap, &((xcfg__XProfileTLSType*)this)->ServerIdentity); + soap_embedded(soap, &((xcfg__XProfileTLSType*)this)->ClientCertificate, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void xcfg__XProfileTLSType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((xcfg__XProfileTLSType*)this)->Username); + ((xcfg__XProfileTLSType*)this)->ServerIdentity = NULL; + soap_default_sai__CertificateHandleType(soap, &((xcfg__XProfileTLSType*)this)->ClientCertificate); + /* transient soap skipped */ +} + +int xcfg__XProfileTLSType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__XProfileTLSType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__XProfileTLSType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__XProfileTLSType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__XProfileTLSType(struct soap *soap, const char *tag, int id, const xcfg__XProfileTLSType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__XProfileTLSType), type); + soap_out_std__string(soap, "xcfg:Username", -1, &(((xcfg__XProfileTLSType*)a)->Username), ""); + soap_out_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", -1, &(((xcfg__XProfileTLSType*)a)->ServerIdentity), ""); + soap_out_sai__CertificateHandleType(soap, "xcfg:ClientCertificate", -1, &(((xcfg__XProfileTLSType*)a)->ClientCertificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__XProfileTLSType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__XProfileTLSType(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__XProfileTLSType * SOAP_FMAC4 soap_get_xcfg__XProfileTLSType(struct soap *soap, xcfg__XProfileTLSType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__XProfileTLSType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__XProfileTLSType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__XProfileTLSType(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__XProfileTLSType * SOAP_FMAC4 soap_in_xcfg__XProfileTLSType(struct soap *soap, const char *tag, xcfg__XProfileTLSType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__XProfileTLSType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__XProfileTLSType, sizeof(xcfg__XProfileTLSType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__XProfileTLSType) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__XProfileTLSType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Username1 = 1, soap_flag_ServerIdentity1 = 1, soap_flag_ClientCertificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Username1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "xcfg:Username", &(((xcfg__XProfileTLSType*)a)->Username), "xsd:string")) + { soap_flag_Username1--; + continue; + } + if (soap_flag_ServerIdentity1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__ServerIdentityType(soap, "xcfg:ServerIdentity", &(((xcfg__XProfileTLSType*)a)->ServerIdentity), "xcfg:ServerIdentityType")) + { soap_flag_ServerIdentity1--; + continue; + } + if (soap_flag_ClientCertificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "xcfg:ClientCertificate", &(((xcfg__XProfileTLSType*)a)->ClientCertificate), "sai:CertificateHandleType")) + { soap_flag_ClientCertificate1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Username1 > 0 || soap_flag_ServerIdentity1 > 0 || soap_flag_ClientCertificate1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__XProfileTLSType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__XProfileTLSType, 0, sizeof(xcfg__XProfileTLSType), 0, soap_copy_xcfg__XProfileTLSType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__XProfileTLSType * SOAP_FMAC6 soap_new_xcfg__XProfileTLSType(struct soap *soap, int n) +{ return soap_instantiate_xcfg__XProfileTLSType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__XProfileTLSType(struct soap *soap, xcfg__XProfileTLSType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__XProfileTLSType * SOAP_FMAC4 soap_instantiate_xcfg__XProfileTLSType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__XProfileTLSType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__XProfileTLSType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__XProfileTLSType; + if (size) + *size = sizeof(xcfg__XProfileTLSType); + ((xcfg__XProfileTLSType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__XProfileTLSType[n]; + if (size) + *size = n * sizeof(xcfg__XProfileTLSType); + for (int i = 0; i < n; i++) + ((xcfg__XProfileTLSType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__XProfileTLSType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__XProfileTLSType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__XProfileTLSType %p -> %p\n", q, p)); + *(xcfg__XProfileTLSType*)p = *(xcfg__XProfileTLSType*)q; +} + +void xcfg__ServerIdentityType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateHandleType(soap, &((xcfg__ServerIdentityType*)this)->CertificateIssuer); + soap_serialize_PointerToxcfg__CertificateNameType(soap, &((xcfg__ServerIdentityType*)this)->ServerNameOptions); + /* transient soap skipped */ +} + +void xcfg__ServerIdentityType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((xcfg__ServerIdentityType*)this)->CertificateIssuer = NULL; + ((xcfg__ServerIdentityType*)this)->ServerNameOptions = NULL; + /* transient soap skipped */ +} + +int xcfg__ServerIdentityType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__ServerIdentityType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__ServerIdentityType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__ServerIdentityType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__ServerIdentityType(struct soap *soap, const char *tag, int id, const xcfg__ServerIdentityType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__ServerIdentityType), type); + soap_out_PointerTosai__CertificateHandleType(soap, "xcfg:CertificateIssuer", -1, &(((xcfg__ServerIdentityType*)a)->CertificateIssuer), ""); + soap_out_PointerToxcfg__CertificateNameType(soap, "xcfg:ServerNameOptions", -1, &(((xcfg__ServerIdentityType*)a)->ServerNameOptions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__ServerIdentityType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__ServerIdentityType(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__ServerIdentityType * SOAP_FMAC4 soap_get_xcfg__ServerIdentityType(struct soap *soap, xcfg__ServerIdentityType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__ServerIdentityType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__ServerIdentityType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__ServerIdentityType(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__ServerIdentityType * SOAP_FMAC4 soap_in_xcfg__ServerIdentityType(struct soap *soap, const char *tag, xcfg__ServerIdentityType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__ServerIdentityType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__ServerIdentityType, sizeof(xcfg__ServerIdentityType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__ServerIdentityType) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__ServerIdentityType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CertificateIssuer1 = 1, soap_flag_ServerNameOptions1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CertificateIssuer1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateHandleType(soap, "xcfg:CertificateIssuer", &(((xcfg__ServerIdentityType*)a)->CertificateIssuer), "sai:CertificateHandleType")) + { soap_flag_CertificateIssuer1--; + continue; + } + if (soap_flag_ServerNameOptions1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToxcfg__CertificateNameType(soap, "xcfg:ServerNameOptions", &(((xcfg__ServerIdentityType*)a)->ServerNameOptions), "xcfg:CertificateNameType")) + { soap_flag_ServerNameOptions1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__ServerIdentityType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__ServerIdentityType, 0, sizeof(xcfg__ServerIdentityType), 0, soap_copy_xcfg__ServerIdentityType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__ServerIdentityType * SOAP_FMAC6 soap_new_xcfg__ServerIdentityType(struct soap *soap, int n) +{ return soap_instantiate_xcfg__ServerIdentityType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__ServerIdentityType(struct soap *soap, xcfg__ServerIdentityType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__ServerIdentityType * SOAP_FMAC4 soap_instantiate_xcfg__ServerIdentityType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__ServerIdentityType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__ServerIdentityType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__ServerIdentityType; + if (size) + *size = sizeof(xcfg__ServerIdentityType); + ((xcfg__ServerIdentityType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__ServerIdentityType[n]; + if (size) + *size = n * sizeof(xcfg__ServerIdentityType); + for (int i = 0; i < n; i++) + ((xcfg__ServerIdentityType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__ServerIdentityType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__ServerIdentityType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__ServerIdentityType %p -> %p\n", q, p)); + *(xcfg__ServerIdentityType*)p = *(xcfg__ServerIdentityType*)q; +} + +void xcfg__ManualPACType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((xcfg__ManualPACType*)this)->PACData, SOAP_TYPE_xsd__base64Binary); + ((xcfg__ManualPACType*)this)->PACData.soap_serialize(soap); + soap_serialize_PointerTostd__string(soap, &((xcfg__ManualPACType*)this)->Password); + /* transient soap skipped */ +} + +void xcfg__ManualPACType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((xcfg__ManualPACType*)this)->PACData.xsd__base64Binary::soap_default(soap); + ((xcfg__ManualPACType*)this)->Password = NULL; + /* transient soap skipped */ +} + +int xcfg__ManualPACType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__ManualPACType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__ManualPACType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__ManualPACType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__ManualPACType(struct soap *soap, const char *tag, int id, const xcfg__ManualPACType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__ManualPACType), type); + (((xcfg__ManualPACType*)a)->PACData).soap_out(soap, "xcfg:PACData", -1, ""); + soap_out_PointerTostd__string(soap, "xcfg:Password", -1, &(((xcfg__ManualPACType*)a)->Password), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__ManualPACType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__ManualPACType(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__ManualPACType * SOAP_FMAC4 soap_get_xcfg__ManualPACType(struct soap *soap, xcfg__ManualPACType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__ManualPACType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__ManualPACType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__ManualPACType(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__ManualPACType * SOAP_FMAC4 soap_in_xcfg__ManualPACType(struct soap *soap, const char *tag, xcfg__ManualPACType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__ManualPACType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__ManualPACType, sizeof(xcfg__ManualPACType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__ManualPACType) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__ManualPACType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PACData1 = 1, soap_flag_Password1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PACData1 && soap->error == SOAP_TAG_MISMATCH) + if ((((xcfg__ManualPACType*)a)->PACData).soap_in(soap, "xcfg:PACData", "xsd:base64Binary")) + { soap_flag_PACData1--; + continue; + } + if (soap_flag_Password1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "xcfg:Password", &(((xcfg__ManualPACType*)a)->Password), "xsd:string")) + { soap_flag_Password1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PACData1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__ManualPACType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__ManualPACType, 0, sizeof(xcfg__ManualPACType), 0, soap_copy_xcfg__ManualPACType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__ManualPACType * SOAP_FMAC6 soap_new_xcfg__ManualPACType(struct soap *soap, int n) +{ return soap_instantiate_xcfg__ManualPACType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__ManualPACType(struct soap *soap, xcfg__ManualPACType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__ManualPACType * SOAP_FMAC4 soap_instantiate_xcfg__ManualPACType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__ManualPACType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__ManualPACType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__ManualPACType; + if (size) + *size = sizeof(xcfg__ManualPACType); + ((xcfg__ManualPACType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__ManualPACType[n]; + if (size) + *size = n * sizeof(xcfg__ManualPACType); + for (int i = 0; i < n; i++) + ((xcfg__ManualPACType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__ManualPACType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__ManualPACType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__ManualPACType %p -> %p\n", q, p)); + *(xcfg__ManualPACType*)p = *(xcfg__ManualPACType*)q; +} + +void xcfg__CertificateNameType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((xcfg__CertificateNameType*)this)->ServerOrCertName, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((xcfg__CertificateNameType*)this)->ServerOrCertName); + /* transient soap skipped */ +} + +void xcfg__CertificateNameType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((xcfg__CertificateNameType*)this)->ServerOrCertName); + soap_default_xcfg__CertNameOptionsType(soap, &((xcfg__CertificateNameType*)this)->Options); + /* transient soap skipped */ +} + +int xcfg__CertificateNameType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__CertificateNameType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__CertificateNameType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__CertificateNameType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__CertificateNameType(struct soap *soap, const char *tag, int id, const xcfg__CertificateNameType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__CertificateNameType), type); + soap_out_std__string(soap, "xcfg:ServerOrCertName", -1, &(((xcfg__CertificateNameType*)a)->ServerOrCertName), ""); + soap_out_xcfg__CertNameOptionsType(soap, "xcfg:Options", -1, &(((xcfg__CertificateNameType*)a)->Options), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__CertificateNameType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__CertificateNameType(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__CertificateNameType * SOAP_FMAC4 soap_get_xcfg__CertificateNameType(struct soap *soap, xcfg__CertificateNameType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__CertificateNameType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__CertificateNameType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__CertificateNameType(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__CertificateNameType * SOAP_FMAC4 soap_in_xcfg__CertificateNameType(struct soap *soap, const char *tag, xcfg__CertificateNameType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__CertificateNameType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__CertificateNameType, sizeof(xcfg__CertificateNameType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__CertificateNameType) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__CertificateNameType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ServerOrCertName1 = 1, soap_flag_Options1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ServerOrCertName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "xcfg:ServerOrCertName", &(((xcfg__CertificateNameType*)a)->ServerOrCertName), "xsd:string")) + { soap_flag_ServerOrCertName1--; + continue; + } + if (soap_flag_Options1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_xcfg__CertNameOptionsType(soap, "xcfg:Options", &(((xcfg__CertificateNameType*)a)->Options), "xcfg:CertNameOptionsType")) + { soap_flag_Options1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ServerOrCertName1 > 0 || soap_flag_Options1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__CertificateNameType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__CertificateNameType, 0, sizeof(xcfg__CertificateNameType), 0, soap_copy_xcfg__CertificateNameType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__CertificateNameType * SOAP_FMAC6 soap_new_xcfg__CertificateNameType(struct soap *soap, int n) +{ return soap_instantiate_xcfg__CertificateNameType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__CertificateNameType(struct soap *soap, xcfg__CertificateNameType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__CertificateNameType * SOAP_FMAC4 soap_instantiate_xcfg__CertificateNameType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__CertificateNameType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__CertificateNameType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__CertificateNameType; + if (size) + *size = sizeof(xcfg__CertificateNameType); + ((xcfg__CertificateNameType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__CertificateNameType[n]; + if (size) + *size = n * sizeof(xcfg__CertificateNameType); + for (int i = 0; i < n; i++) + ((xcfg__CertificateNameType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__CertificateNameType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__CertificateNameType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__CertificateNameType %p -> %p\n", q, p)); + *(xcfg__CertificateNameType*)p = *(xcfg__CertificateNameType*)q; +} + +void xcfg__UserCredentialsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((xcfg__UserCredentialsType*)this)->Username, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((xcfg__UserCredentialsType*)this)->Username); + soap_embedded(soap, &((xcfg__UserCredentialsType*)this)->Password, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((xcfg__UserCredentialsType*)this)->Password); + soap_serialize_PointerTostd__string(soap, &((xcfg__UserCredentialsType*)this)->Domain); + /* transient soap skipped */ +} + +void xcfg__UserCredentialsType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((xcfg__UserCredentialsType*)this)->Username); + soap_default_std__string(soap, &((xcfg__UserCredentialsType*)this)->Password); + ((xcfg__UserCredentialsType*)this)->Domain = NULL; + /* transient soap skipped */ +} + +int xcfg__UserCredentialsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_xcfg__UserCredentialsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xcfg__UserCredentialsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_xcfg__UserCredentialsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xcfg__UserCredentialsType(struct soap *soap, const char *tag, int id, const xcfg__UserCredentialsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_xcfg__UserCredentialsType), type); + soap_out_std__string(soap, "xcfg:Username", -1, &(((xcfg__UserCredentialsType*)a)->Username), ""); + soap_out_std__string(soap, "xcfg:Password", -1, &(((xcfg__UserCredentialsType*)a)->Password), ""); + soap_out_PointerTostd__string(soap, "xcfg:Domain", -1, &(((xcfg__UserCredentialsType*)a)->Domain), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xcfg__UserCredentialsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xcfg__UserCredentialsType(soap, this, tag, type); +} + +SOAP_FMAC3 xcfg__UserCredentialsType * SOAP_FMAC4 soap_get_xcfg__UserCredentialsType(struct soap *soap, xcfg__UserCredentialsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_xcfg__UserCredentialsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xcfg__UserCredentialsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xcfg__UserCredentialsType(soap, tag, this, type); +} + +SOAP_FMAC3 xcfg__UserCredentialsType * SOAP_FMAC4 soap_in_xcfg__UserCredentialsType(struct soap *soap, const char *tag, xcfg__UserCredentialsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (xcfg__UserCredentialsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xcfg__UserCredentialsType, sizeof(xcfg__UserCredentialsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_xcfg__UserCredentialsType) + { soap_revert(soap); + *soap->id = '\0'; + return (xcfg__UserCredentialsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Username1 = 1, soap_flag_Password1 = 1, soap_flag_Domain1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Username1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "xcfg:Username", &(((xcfg__UserCredentialsType*)a)->Username), "xsd:string")) + { soap_flag_Username1--; + continue; + } + if (soap_flag_Password1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "xcfg:Password", &(((xcfg__UserCredentialsType*)a)->Password), "xsd:string")) + { soap_flag_Password1--; + continue; + } + if (soap_flag_Domain1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "xcfg:Domain", &(((xcfg__UserCredentialsType*)a)->Domain), "xsd:string")) + { soap_flag_Domain1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Username1 > 0 || soap_flag_Password1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (xcfg__UserCredentialsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xcfg__UserCredentialsType, 0, sizeof(xcfg__UserCredentialsType), 0, soap_copy_xcfg__UserCredentialsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xcfg__UserCredentialsType * SOAP_FMAC6 soap_new_xcfg__UserCredentialsType(struct soap *soap, int n) +{ return soap_instantiate_xcfg__UserCredentialsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xcfg__UserCredentialsType(struct soap *soap, xcfg__UserCredentialsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xcfg__UserCredentialsType * SOAP_FMAC4 soap_instantiate_xcfg__UserCredentialsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xcfg__UserCredentialsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xcfg__UserCredentialsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xcfg__UserCredentialsType; + if (size) + *size = sizeof(xcfg__UserCredentialsType); + ((xcfg__UserCredentialsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xcfg__UserCredentialsType[n]; + if (size) + *size = n * sizeof(xcfg__UserCredentialsType); + for (int i = 0; i < n; i++) + ((xcfg__UserCredentialsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xcfg__UserCredentialsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xcfg__UserCredentialsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xcfg__UserCredentialsType %p -> %p\n", q, p)); + *(xcfg__UserCredentialsType*)p = *(xcfg__UserCredentialsType*)q; +} + +void _sai__GetAclEnabledStateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetAclEnabledStateResponse*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _sai__GetAclEnabledStateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetAclEnabledStateResponse*)this)->StatusCode); + soap_default_bool(soap, &((_sai__GetAclEnabledStateResponse*)this)->Enabled); + /* transient soap skipped */ +} + +int _sai__GetAclEnabledStateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetAclEnabledStateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetAclEnabledStateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetAclEnabledStateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetAclEnabledStateResponse(struct soap *soap, const char *tag, int id, const _sai__GetAclEnabledStateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetAclEnabledStateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetAclEnabledStateResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "sai:Enabled", -1, &(((_sai__GetAclEnabledStateResponse*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetAclEnabledStateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetAclEnabledStateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetAclEnabledStateResponse * SOAP_FMAC4 soap_get__sai__GetAclEnabledStateResponse(struct soap *soap, _sai__GetAclEnabledStateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetAclEnabledStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetAclEnabledStateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetAclEnabledStateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetAclEnabledStateResponse * SOAP_FMAC4 soap_in__sai__GetAclEnabledStateResponse(struct soap *soap, const char *tag, _sai__GetAclEnabledStateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetAclEnabledStateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetAclEnabledStateResponse, sizeof(_sai__GetAclEnabledStateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetAclEnabledStateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetAclEnabledStateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetAclEnabledStateResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:Enabled", &(((_sai__GetAclEnabledStateResponse*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetAclEnabledStateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetAclEnabledStateResponse, 0, sizeof(_sai__GetAclEnabledStateResponse), 0, soap_copy__sai__GetAclEnabledStateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetAclEnabledStateResponse * SOAP_FMAC6 soap_new__sai__GetAclEnabledStateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetAclEnabledStateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetAclEnabledStateResponse(struct soap *soap, _sai__GetAclEnabledStateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetAclEnabledStateResponse * SOAP_FMAC4 soap_instantiate__sai__GetAclEnabledStateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetAclEnabledStateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetAclEnabledStateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetAclEnabledStateResponse; + if (size) + *size = sizeof(_sai__GetAclEnabledStateResponse); + ((_sai__GetAclEnabledStateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetAclEnabledStateResponse[n]; + if (size) + *size = n * sizeof(_sai__GetAclEnabledStateResponse); + for (int i = 0; i < n; i++) + ((_sai__GetAclEnabledStateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetAclEnabledStateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetAclEnabledStateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetAclEnabledStateResponse %p -> %p\n", q, p)); + *(_sai__GetAclEnabledStateResponse*)p = *(_sai__GetAclEnabledStateResponse*)q; +} + +void _sai__GetAclEnabledState::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetAclEnabledState::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__UserAclEntryHandleType(soap, &((_sai__GetAclEnabledState*)this)->Handle); + /* transient soap skipped */ +} + +int _sai__GetAclEnabledState::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetAclEnabledState); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetAclEnabledState::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetAclEnabledState(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetAclEnabledState(struct soap *soap, const char *tag, int id, const _sai__GetAclEnabledState *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetAclEnabledState), type); + soap_out_sai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((_sai__GetAclEnabledState*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetAclEnabledState::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetAclEnabledState(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetAclEnabledState * SOAP_FMAC4 soap_get__sai__GetAclEnabledState(struct soap *soap, _sai__GetAclEnabledState *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetAclEnabledState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetAclEnabledState::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetAclEnabledState(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetAclEnabledState * SOAP_FMAC4 soap_in__sai__GetAclEnabledState(struct soap *soap, const char *tag, _sai__GetAclEnabledState *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetAclEnabledState *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetAclEnabledState, sizeof(_sai__GetAclEnabledState), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetAclEnabledState) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetAclEnabledState *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclEntryHandleType(soap, "sai:Handle", &(((_sai__GetAclEnabledState*)a)->Handle), "sai:UserAclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetAclEnabledState *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetAclEnabledState, 0, sizeof(_sai__GetAclEnabledState), 0, soap_copy__sai__GetAclEnabledState); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetAclEnabledState * SOAP_FMAC6 soap_new__sai__GetAclEnabledState(struct soap *soap, int n) +{ return soap_instantiate__sai__GetAclEnabledState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetAclEnabledState(struct soap *soap, _sai__GetAclEnabledState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetAclEnabledState * SOAP_FMAC4 soap_instantiate__sai__GetAclEnabledState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetAclEnabledState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetAclEnabledState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetAclEnabledState; + if (size) + *size = sizeof(_sai__GetAclEnabledState); + ((_sai__GetAclEnabledState*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetAclEnabledState[n]; + if (size) + *size = n * sizeof(_sai__GetAclEnabledState); + for (int i = 0; i < n; i++) + ((_sai__GetAclEnabledState*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetAclEnabledState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetAclEnabledState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetAclEnabledState %p -> %p\n", q, p)); + *(_sai__GetAclEnabledState*)p = *(_sai__GetAclEnabledState*)q; +} + +void _sai__SetAclEnabledStateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetAclEnabledStateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__SetAclEnabledStateResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetAclEnabledStateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetAclEnabledStateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetAclEnabledStateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetAclEnabledStateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAclEnabledStateResponse(struct soap *soap, const char *tag, int id, const _sai__SetAclEnabledStateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetAclEnabledStateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetAclEnabledStateResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetAclEnabledStateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetAclEnabledStateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetAclEnabledStateResponse * SOAP_FMAC4 soap_get__sai__SetAclEnabledStateResponse(struct soap *soap, _sai__SetAclEnabledStateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetAclEnabledStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetAclEnabledStateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetAclEnabledStateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetAclEnabledStateResponse * SOAP_FMAC4 soap_in__sai__SetAclEnabledStateResponse(struct soap *soap, const char *tag, _sai__SetAclEnabledStateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetAclEnabledStateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetAclEnabledStateResponse, sizeof(_sai__SetAclEnabledStateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetAclEnabledStateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetAclEnabledStateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetAclEnabledStateResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetAclEnabledStateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetAclEnabledStateResponse, 0, sizeof(_sai__SetAclEnabledStateResponse), 0, soap_copy__sai__SetAclEnabledStateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetAclEnabledStateResponse * SOAP_FMAC6 soap_new__sai__SetAclEnabledStateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetAclEnabledStateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAclEnabledStateResponse(struct soap *soap, _sai__SetAclEnabledStateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetAclEnabledStateResponse * SOAP_FMAC4 soap_instantiate__sai__SetAclEnabledStateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetAclEnabledStateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetAclEnabledStateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetAclEnabledStateResponse; + if (size) + *size = sizeof(_sai__SetAclEnabledStateResponse); + ((_sai__SetAclEnabledStateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetAclEnabledStateResponse[n]; + if (size) + *size = n * sizeof(_sai__SetAclEnabledStateResponse); + for (int i = 0; i < n; i++) + ((_sai__SetAclEnabledStateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetAclEnabledStateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAclEnabledStateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetAclEnabledStateResponse %p -> %p\n", q, p)); + *(_sai__SetAclEnabledStateResponse*)p = *(_sai__SetAclEnabledStateResponse*)q; +} + +void _sai__SetAclEnabledState::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__SetAclEnabledState*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _sai__SetAclEnabledState::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__UserAclEntryHandleType(soap, &((_sai__SetAclEnabledState*)this)->Handle); + soap_default_bool(soap, &((_sai__SetAclEnabledState*)this)->Enabled); + /* transient soap skipped */ +} + +int _sai__SetAclEnabledState::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetAclEnabledState); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetAclEnabledState::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetAclEnabledState(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAclEnabledState(struct soap *soap, const char *tag, int id, const _sai__SetAclEnabledState *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetAclEnabledState), type); + soap_out_sai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((_sai__SetAclEnabledState*)a)->Handle), ""); + soap_out_bool(soap, "sai:Enabled", -1, &(((_sai__SetAclEnabledState*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetAclEnabledState::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetAclEnabledState(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetAclEnabledState * SOAP_FMAC4 soap_get__sai__SetAclEnabledState(struct soap *soap, _sai__SetAclEnabledState *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetAclEnabledState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetAclEnabledState::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetAclEnabledState(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetAclEnabledState * SOAP_FMAC4 soap_in__sai__SetAclEnabledState(struct soap *soap, const char *tag, _sai__SetAclEnabledState *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetAclEnabledState *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetAclEnabledState, sizeof(_sai__SetAclEnabledState), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetAclEnabledState) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetAclEnabledState *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1, soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclEntryHandleType(soap, "sai:Handle", &(((_sai__SetAclEnabledState*)a)->Handle), "sai:UserAclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:Enabled", &(((_sai__SetAclEnabledState*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0 || soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetAclEnabledState *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetAclEnabledState, 0, sizeof(_sai__SetAclEnabledState), 0, soap_copy__sai__SetAclEnabledState); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetAclEnabledState * SOAP_FMAC6 soap_new__sai__SetAclEnabledState(struct soap *soap, int n) +{ return soap_instantiate__sai__SetAclEnabledState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAclEnabledState(struct soap *soap, _sai__SetAclEnabledState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetAclEnabledState * SOAP_FMAC4 soap_instantiate__sai__SetAclEnabledState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetAclEnabledState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetAclEnabledState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetAclEnabledState; + if (size) + *size = sizeof(_sai__SetAclEnabledState); + ((_sai__SetAclEnabledState*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetAclEnabledState[n]; + if (size) + *size = n * sizeof(_sai__SetAclEnabledState); + for (int i = 0; i < n; i++) + ((_sai__SetAclEnabledState*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetAclEnabledState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAclEnabledState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetAclEnabledState %p -> %p\n", q, p)); + *(_sai__SetAclEnabledState*)p = *(_sai__SetAclEnabledState*)q; +} + +void _sai__GetConfigurationServerFQDNResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetConfigurationServerFQDNResponse*)this)->fqdn, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_sai__GetConfigurationServerFQDNResponse*)this)->fqdn); + /* transient soap skipped */ +} + +void _sai__GetConfigurationServerFQDNResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetConfigurationServerFQDNResponse*)this)->StatusCode); + soap_default_std__string(soap, &((_sai__GetConfigurationServerFQDNResponse*)this)->fqdn); + /* transient soap skipped */ +} + +int _sai__GetConfigurationServerFQDNResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetConfigurationServerFQDNResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetConfigurationServerFQDNResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetConfigurationServerFQDNResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetConfigurationServerFQDNResponse(struct soap *soap, const char *tag, int id, const _sai__GetConfigurationServerFQDNResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetConfigurationServerFQDNResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetConfigurationServerFQDNResponse*)a)->StatusCode), ""); + soap_out_std__string(soap, "sai:fqdn", -1, &(((_sai__GetConfigurationServerFQDNResponse*)a)->fqdn), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetConfigurationServerFQDNResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetConfigurationServerFQDNResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_get__sai__GetConfigurationServerFQDNResponse(struct soap *soap, _sai__GetConfigurationServerFQDNResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetConfigurationServerFQDNResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetConfigurationServerFQDNResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetConfigurationServerFQDNResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_in__sai__GetConfigurationServerFQDNResponse(struct soap *soap, const char *tag, _sai__GetConfigurationServerFQDNResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetConfigurationServerFQDNResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetConfigurationServerFQDNResponse, sizeof(_sai__GetConfigurationServerFQDNResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetConfigurationServerFQDNResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetConfigurationServerFQDNResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_fqdn1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetConfigurationServerFQDNResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_fqdn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "sai:fqdn", &(((_sai__GetConfigurationServerFQDNResponse*)a)->fqdn), "xsd:string")) + { soap_flag_fqdn1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_fqdn1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetConfigurationServerFQDNResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetConfigurationServerFQDNResponse, 0, sizeof(_sai__GetConfigurationServerFQDNResponse), 0, soap_copy__sai__GetConfigurationServerFQDNResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetConfigurationServerFQDNResponse * SOAP_FMAC6 soap_new__sai__GetConfigurationServerFQDNResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetConfigurationServerFQDNResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetConfigurationServerFQDNResponse(struct soap *soap, _sai__GetConfigurationServerFQDNResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_instantiate__sai__GetConfigurationServerFQDNResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetConfigurationServerFQDNResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetConfigurationServerFQDNResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetConfigurationServerFQDNResponse; + if (size) + *size = sizeof(_sai__GetConfigurationServerFQDNResponse); + ((_sai__GetConfigurationServerFQDNResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetConfigurationServerFQDNResponse[n]; + if (size) + *size = n * sizeof(_sai__GetConfigurationServerFQDNResponse); + for (int i = 0; i < n; i++) + ((_sai__GetConfigurationServerFQDNResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetConfigurationServerFQDNResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetConfigurationServerFQDNResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetConfigurationServerFQDNResponse %p -> %p\n", q, p)); + *(_sai__GetConfigurationServerFQDNResponse*)p = *(_sai__GetConfigurationServerFQDNResponse*)q; +} + +void _sai__GetConfigurationServerFQDN::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetConfigurationServerFQDN::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetConfigurationServerFQDN::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetConfigurationServerFQDN); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetConfigurationServerFQDN::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetConfigurationServerFQDN(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetConfigurationServerFQDN(struct soap *soap, const char *tag, int id, const _sai__GetConfigurationServerFQDN *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetConfigurationServerFQDN), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetConfigurationServerFQDN::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetConfigurationServerFQDN(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_get__sai__GetConfigurationServerFQDN(struct soap *soap, _sai__GetConfigurationServerFQDN *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetConfigurationServerFQDN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetConfigurationServerFQDN::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetConfigurationServerFQDN(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_in__sai__GetConfigurationServerFQDN(struct soap *soap, const char *tag, _sai__GetConfigurationServerFQDN *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetConfigurationServerFQDN *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetConfigurationServerFQDN, sizeof(_sai__GetConfigurationServerFQDN), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetConfigurationServerFQDN) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetConfigurationServerFQDN *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetConfigurationServerFQDN *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetConfigurationServerFQDN, 0, sizeof(_sai__GetConfigurationServerFQDN), 0, soap_copy__sai__GetConfigurationServerFQDN); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetConfigurationServerFQDN * SOAP_FMAC6 soap_new__sai__GetConfigurationServerFQDN(struct soap *soap, int n) +{ return soap_instantiate__sai__GetConfigurationServerFQDN(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetConfigurationServerFQDN(struct soap *soap, _sai__GetConfigurationServerFQDN *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_instantiate__sai__GetConfigurationServerFQDN(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetConfigurationServerFQDN(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetConfigurationServerFQDN, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetConfigurationServerFQDN; + if (size) + *size = sizeof(_sai__GetConfigurationServerFQDN); + ((_sai__GetConfigurationServerFQDN*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetConfigurationServerFQDN[n]; + if (size) + *size = n * sizeof(_sai__GetConfigurationServerFQDN); + for (int i = 0; i < n; i++) + ((_sai__GetConfigurationServerFQDN*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetConfigurationServerFQDN*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetConfigurationServerFQDN(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetConfigurationServerFQDN %p -> %p\n", q, p)); + *(_sai__GetConfigurationServerFQDN*)p = *(_sai__GetConfigurationServerFQDN*)q; +} + +void _sai__SetConfigurationServerFQDNResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetConfigurationServerFQDNResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__SetConfigurationServerFQDNResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetConfigurationServerFQDNResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetConfigurationServerFQDNResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetConfigurationServerFQDNResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetConfigurationServerFQDNResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetConfigurationServerFQDNResponse(struct soap *soap, const char *tag, int id, const _sai__SetConfigurationServerFQDNResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetConfigurationServerFQDNResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetConfigurationServerFQDNResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetConfigurationServerFQDNResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetConfigurationServerFQDNResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_get__sai__SetConfigurationServerFQDNResponse(struct soap *soap, _sai__SetConfigurationServerFQDNResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetConfigurationServerFQDNResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetConfigurationServerFQDNResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetConfigurationServerFQDNResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_in__sai__SetConfigurationServerFQDNResponse(struct soap *soap, const char *tag, _sai__SetConfigurationServerFQDNResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetConfigurationServerFQDNResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetConfigurationServerFQDNResponse, sizeof(_sai__SetConfigurationServerFQDNResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetConfigurationServerFQDNResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetConfigurationServerFQDNResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetConfigurationServerFQDNResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetConfigurationServerFQDNResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetConfigurationServerFQDNResponse, 0, sizeof(_sai__SetConfigurationServerFQDNResponse), 0, soap_copy__sai__SetConfigurationServerFQDNResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetConfigurationServerFQDNResponse * SOAP_FMAC6 soap_new__sai__SetConfigurationServerFQDNResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetConfigurationServerFQDNResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetConfigurationServerFQDNResponse(struct soap *soap, _sai__SetConfigurationServerFQDNResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse * SOAP_FMAC4 soap_instantiate__sai__SetConfigurationServerFQDNResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetConfigurationServerFQDNResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetConfigurationServerFQDNResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetConfigurationServerFQDNResponse; + if (size) + *size = sizeof(_sai__SetConfigurationServerFQDNResponse); + ((_sai__SetConfigurationServerFQDNResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetConfigurationServerFQDNResponse[n]; + if (size) + *size = n * sizeof(_sai__SetConfigurationServerFQDNResponse); + for (int i = 0; i < n; i++) + ((_sai__SetConfigurationServerFQDNResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetConfigurationServerFQDNResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetConfigurationServerFQDNResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetConfigurationServerFQDNResponse %p -> %p\n", q, p)); + *(_sai__SetConfigurationServerFQDNResponse*)p = *(_sai__SetConfigurationServerFQDNResponse*)q; +} + +void _sai__SetConfigurationServerFQDN::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__SetConfigurationServerFQDN*)this)->fqdn, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_sai__SetConfigurationServerFQDN*)this)->fqdn); + /* transient soap skipped */ +} + +void _sai__SetConfigurationServerFQDN::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((_sai__SetConfigurationServerFQDN*)this)->fqdn); + /* transient soap skipped */ +} + +int _sai__SetConfigurationServerFQDN::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetConfigurationServerFQDN); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetConfigurationServerFQDN::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetConfigurationServerFQDN(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetConfigurationServerFQDN(struct soap *soap, const char *tag, int id, const _sai__SetConfigurationServerFQDN *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetConfigurationServerFQDN), type); + soap_out_std__string(soap, "sai:fqdn", -1, &(((_sai__SetConfigurationServerFQDN*)a)->fqdn), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetConfigurationServerFQDN::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetConfigurationServerFQDN(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_get__sai__SetConfigurationServerFQDN(struct soap *soap, _sai__SetConfigurationServerFQDN *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetConfigurationServerFQDN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetConfigurationServerFQDN::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetConfigurationServerFQDN(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_in__sai__SetConfigurationServerFQDN(struct soap *soap, const char *tag, _sai__SetConfigurationServerFQDN *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetConfigurationServerFQDN *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetConfigurationServerFQDN, sizeof(_sai__SetConfigurationServerFQDN), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetConfigurationServerFQDN) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetConfigurationServerFQDN *)a->soap_in(soap, tag, type); + } + } + short soap_flag_fqdn1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_fqdn1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "sai:fqdn", &(((_sai__SetConfigurationServerFQDN*)a)->fqdn), "xsd:string")) + { soap_flag_fqdn1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_fqdn1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetConfigurationServerFQDN *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetConfigurationServerFQDN, 0, sizeof(_sai__SetConfigurationServerFQDN), 0, soap_copy__sai__SetConfigurationServerFQDN); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetConfigurationServerFQDN * SOAP_FMAC6 soap_new__sai__SetConfigurationServerFQDN(struct soap *soap, int n) +{ return soap_instantiate__sai__SetConfigurationServerFQDN(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetConfigurationServerFQDN(struct soap *soap, _sai__SetConfigurationServerFQDN *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_instantiate__sai__SetConfigurationServerFQDN(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetConfigurationServerFQDN(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetConfigurationServerFQDN, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetConfigurationServerFQDN; + if (size) + *size = sizeof(_sai__SetConfigurationServerFQDN); + ((_sai__SetConfigurationServerFQDN*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetConfigurationServerFQDN[n]; + if (size) + *size = n * sizeof(_sai__SetConfigurationServerFQDN); + for (int i = 0; i < n; i++) + ((_sai__SetConfigurationServerFQDN*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetConfigurationServerFQDN*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetConfigurationServerFQDN(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetConfigurationServerFQDN %p -> %p\n", q, p)); + *(_sai__SetConfigurationServerFQDN*)p = *(_sai__SetConfigurationServerFQDN*)q; +} + +void _sai__EnableVpnRoutingResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__EnableVpnRoutingResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__EnableVpnRoutingResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__EnableVpnRoutingResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnableVpnRoutingResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnableVpnRoutingResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnableVpnRoutingResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnableVpnRoutingResponse(struct soap *soap, const char *tag, int id, const _sai__EnableVpnRoutingResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnableVpnRoutingResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__EnableVpnRoutingResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnableVpnRoutingResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnableVpnRoutingResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnableVpnRoutingResponse * SOAP_FMAC4 soap_get__sai__EnableVpnRoutingResponse(struct soap *soap, _sai__EnableVpnRoutingResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnableVpnRoutingResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnableVpnRoutingResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnableVpnRoutingResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnableVpnRoutingResponse * SOAP_FMAC4 soap_in__sai__EnableVpnRoutingResponse(struct soap *soap, const char *tag, _sai__EnableVpnRoutingResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnableVpnRoutingResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnableVpnRoutingResponse, sizeof(_sai__EnableVpnRoutingResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnableVpnRoutingResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnableVpnRoutingResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__EnableVpnRoutingResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnableVpnRoutingResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnableVpnRoutingResponse, 0, sizeof(_sai__EnableVpnRoutingResponse), 0, soap_copy__sai__EnableVpnRoutingResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnableVpnRoutingResponse * SOAP_FMAC6 soap_new__sai__EnableVpnRoutingResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__EnableVpnRoutingResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnableVpnRoutingResponse(struct soap *soap, _sai__EnableVpnRoutingResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnableVpnRoutingResponse * SOAP_FMAC4 soap_instantiate__sai__EnableVpnRoutingResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnableVpnRoutingResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnableVpnRoutingResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnableVpnRoutingResponse; + if (size) + *size = sizeof(_sai__EnableVpnRoutingResponse); + ((_sai__EnableVpnRoutingResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnableVpnRoutingResponse[n]; + if (size) + *size = n * sizeof(_sai__EnableVpnRoutingResponse); + for (int i = 0; i < n; i++) + ((_sai__EnableVpnRoutingResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnableVpnRoutingResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnableVpnRoutingResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnableVpnRoutingResponse %p -> %p\n", q, p)); + *(_sai__EnableVpnRoutingResponse*)p = *(_sai__EnableVpnRoutingResponse*)q; +} + +void _sai__EnableVpnRouting::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__EnableVpnRouting*)this)->Enable, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _sai__EnableVpnRouting::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((_sai__EnableVpnRouting*)this)->Enable); + /* transient soap skipped */ +} + +int _sai__EnableVpnRouting::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnableVpnRouting); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnableVpnRouting::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnableVpnRouting(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnableVpnRouting(struct soap *soap, const char *tag, int id, const _sai__EnableVpnRouting *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnableVpnRouting), type); + soap_out_bool(soap, "sai:Enable", -1, &(((_sai__EnableVpnRouting*)a)->Enable), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnableVpnRouting::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnableVpnRouting(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnableVpnRouting * SOAP_FMAC4 soap_get__sai__EnableVpnRouting(struct soap *soap, _sai__EnableVpnRouting *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnableVpnRouting(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnableVpnRouting::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnableVpnRouting(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnableVpnRouting * SOAP_FMAC4 soap_in__sai__EnableVpnRouting(struct soap *soap, const char *tag, _sai__EnableVpnRouting *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnableVpnRouting *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnableVpnRouting, sizeof(_sai__EnableVpnRouting), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnableVpnRouting) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnableVpnRouting *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Enable1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Enable1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:Enable", &(((_sai__EnableVpnRouting*)a)->Enable), "xsd:boolean")) + { soap_flag_Enable1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Enable1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnableVpnRouting *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnableVpnRouting, 0, sizeof(_sai__EnableVpnRouting), 0, soap_copy__sai__EnableVpnRouting); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnableVpnRouting * SOAP_FMAC6 soap_new__sai__EnableVpnRouting(struct soap *soap, int n) +{ return soap_instantiate__sai__EnableVpnRouting(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnableVpnRouting(struct soap *soap, _sai__EnableVpnRouting *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnableVpnRouting * SOAP_FMAC4 soap_instantiate__sai__EnableVpnRouting(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnableVpnRouting(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnableVpnRouting, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnableVpnRouting; + if (size) + *size = sizeof(_sai__EnableVpnRouting); + ((_sai__EnableVpnRouting*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnableVpnRouting[n]; + if (size) + *size = n * sizeof(_sai__EnableVpnRouting); + for (int i = 0; i < n; i++) + ((_sai__EnableVpnRouting*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnableVpnRouting*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnableVpnRouting(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnableVpnRouting %p -> %p\n", q, p)); + *(_sai__EnableVpnRouting*)p = *(_sai__EnableVpnRouting*)q; +} + +void _sai__GetTLSCredentialsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateHandleType(soap, &((_sai__GetTLSCredentialsResponse*)this)->CertHandle); + /* transient soap skipped */ +} + +void _sai__GetTLSCredentialsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetTLSCredentialsResponse*)this)->StatusCode); + ((_sai__GetTLSCredentialsResponse*)this)->CertHandle = NULL; + /* transient soap skipped */ +} + +int _sai__GetTLSCredentialsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTLSCredentialsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTLSCredentialsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTLSCredentialsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTLSCredentialsResponse(struct soap *soap, const char *tag, int id, const _sai__GetTLSCredentialsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTLSCredentialsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetTLSCredentialsResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__GetTLSCredentialsResponse*)a)->CertHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTLSCredentialsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTLSCredentialsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTLSCredentialsResponse * SOAP_FMAC4 soap_get__sai__GetTLSCredentialsResponse(struct soap *soap, _sai__GetTLSCredentialsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTLSCredentialsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTLSCredentialsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTLSCredentialsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTLSCredentialsResponse * SOAP_FMAC4 soap_in__sai__GetTLSCredentialsResponse(struct soap *soap, const char *tag, _sai__GetTLSCredentialsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTLSCredentialsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTLSCredentialsResponse, sizeof(_sai__GetTLSCredentialsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTLSCredentialsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTLSCredentialsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_CertHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetTLSCredentialsResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_CertHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__GetTLSCredentialsResponse*)a)->CertHandle), "sai:CertificateHandleType")) + { soap_flag_CertHandle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTLSCredentialsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTLSCredentialsResponse, 0, sizeof(_sai__GetTLSCredentialsResponse), 0, soap_copy__sai__GetTLSCredentialsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTLSCredentialsResponse * SOAP_FMAC6 soap_new__sai__GetTLSCredentialsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTLSCredentialsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTLSCredentialsResponse(struct soap *soap, _sai__GetTLSCredentialsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTLSCredentialsResponse * SOAP_FMAC4 soap_instantiate__sai__GetTLSCredentialsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTLSCredentialsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTLSCredentialsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTLSCredentialsResponse; + if (size) + *size = sizeof(_sai__GetTLSCredentialsResponse); + ((_sai__GetTLSCredentialsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTLSCredentialsResponse[n]; + if (size) + *size = n * sizeof(_sai__GetTLSCredentialsResponse); + for (int i = 0; i < n; i++) + ((_sai__GetTLSCredentialsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTLSCredentialsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTLSCredentialsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTLSCredentialsResponse %p -> %p\n", q, p)); + *(_sai__GetTLSCredentialsResponse*)p = *(_sai__GetTLSCredentialsResponse*)q; +} + +void _sai__GetTLSCredentials::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetTLSCredentials::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetTLSCredentials::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTLSCredentials); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTLSCredentials::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTLSCredentials(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTLSCredentials(struct soap *soap, const char *tag, int id, const _sai__GetTLSCredentials *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTLSCredentials), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTLSCredentials::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTLSCredentials(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTLSCredentials * SOAP_FMAC4 soap_get__sai__GetTLSCredentials(struct soap *soap, _sai__GetTLSCredentials *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTLSCredentials(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTLSCredentials::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTLSCredentials(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTLSCredentials * SOAP_FMAC4 soap_in__sai__GetTLSCredentials(struct soap *soap, const char *tag, _sai__GetTLSCredentials *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTLSCredentials *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTLSCredentials, sizeof(_sai__GetTLSCredentials), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTLSCredentials) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTLSCredentials *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTLSCredentials *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTLSCredentials, 0, sizeof(_sai__GetTLSCredentials), 0, soap_copy__sai__GetTLSCredentials); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTLSCredentials * SOAP_FMAC6 soap_new__sai__GetTLSCredentials(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTLSCredentials(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTLSCredentials(struct soap *soap, _sai__GetTLSCredentials *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTLSCredentials * SOAP_FMAC4 soap_instantiate__sai__GetTLSCredentials(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTLSCredentials(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTLSCredentials, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTLSCredentials; + if (size) + *size = sizeof(_sai__GetTLSCredentials); + ((_sai__GetTLSCredentials*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTLSCredentials[n]; + if (size) + *size = n * sizeof(_sai__GetTLSCredentials); + for (int i = 0; i < n; i++) + ((_sai__GetTLSCredentials*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTLSCredentials*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTLSCredentials(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTLSCredentials %p -> %p\n", q, p)); + *(_sai__GetTLSCredentials*)p = *(_sai__GetTLSCredentials*)q; +} + +void _sai__SetTLSCredentialsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetTLSCredentialsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__SetTLSCredentialsResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetTLSCredentialsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTLSCredentialsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTLSCredentialsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTLSCredentialsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSCredentialsResponse(struct soap *soap, const char *tag, int id, const _sai__SetTLSCredentialsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTLSCredentialsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetTLSCredentialsResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTLSCredentialsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTLSCredentialsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTLSCredentialsResponse * SOAP_FMAC4 soap_get__sai__SetTLSCredentialsResponse(struct soap *soap, _sai__SetTLSCredentialsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTLSCredentialsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTLSCredentialsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTLSCredentialsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTLSCredentialsResponse * SOAP_FMAC4 soap_in__sai__SetTLSCredentialsResponse(struct soap *soap, const char *tag, _sai__SetTLSCredentialsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTLSCredentialsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTLSCredentialsResponse, sizeof(_sai__SetTLSCredentialsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTLSCredentialsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTLSCredentialsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetTLSCredentialsResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTLSCredentialsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTLSCredentialsResponse, 0, sizeof(_sai__SetTLSCredentialsResponse), 0, soap_copy__sai__SetTLSCredentialsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTLSCredentialsResponse * SOAP_FMAC6 soap_new__sai__SetTLSCredentialsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTLSCredentialsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSCredentialsResponse(struct soap *soap, _sai__SetTLSCredentialsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTLSCredentialsResponse * SOAP_FMAC4 soap_instantiate__sai__SetTLSCredentialsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTLSCredentialsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTLSCredentialsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTLSCredentialsResponse; + if (size) + *size = sizeof(_sai__SetTLSCredentialsResponse); + ((_sai__SetTLSCredentialsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTLSCredentialsResponse[n]; + if (size) + *size = n * sizeof(_sai__SetTLSCredentialsResponse); + for (int i = 0; i < n; i++) + ((_sai__SetTLSCredentialsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTLSCredentialsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSCredentialsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTLSCredentialsResponse %p -> %p\n", q, p)); + *(_sai__SetTLSCredentialsResponse*)p = *(_sai__SetTLSCredentialsResponse*)q; +} + +void _sai__SetTLSCredentials::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateHandleType(soap, &((_sai__SetTLSCredentials*)this)->CertHandle); + /* transient soap skipped */ +} + +void _sai__SetTLSCredentials::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetTLSCredentials*)this)->CertHandle = NULL; + /* transient soap skipped */ +} + +int _sai__SetTLSCredentials::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTLSCredentials); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTLSCredentials::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTLSCredentials(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSCredentials(struct soap *soap, const char *tag, int id, const _sai__SetTLSCredentials *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTLSCredentials), type); + soap_out_PointerTosai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__SetTLSCredentials*)a)->CertHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTLSCredentials::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTLSCredentials(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTLSCredentials * SOAP_FMAC4 soap_get__sai__SetTLSCredentials(struct soap *soap, _sai__SetTLSCredentials *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTLSCredentials(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTLSCredentials::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTLSCredentials(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTLSCredentials * SOAP_FMAC4 soap_in__sai__SetTLSCredentials(struct soap *soap, const char *tag, _sai__SetTLSCredentials *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTLSCredentials *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTLSCredentials, sizeof(_sai__SetTLSCredentials), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTLSCredentials) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTLSCredentials *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CertHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CertHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__SetTLSCredentials*)a)->CertHandle), "sai:CertificateHandleType")) + { soap_flag_CertHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTLSCredentials *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTLSCredentials, 0, sizeof(_sai__SetTLSCredentials), 0, soap_copy__sai__SetTLSCredentials); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTLSCredentials * SOAP_FMAC6 soap_new__sai__SetTLSCredentials(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTLSCredentials(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSCredentials(struct soap *soap, _sai__SetTLSCredentials *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTLSCredentials * SOAP_FMAC4 soap_instantiate__sai__SetTLSCredentials(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTLSCredentials(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTLSCredentials, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTLSCredentials; + if (size) + *size = sizeof(_sai__SetTLSCredentials); + ((_sai__SetTLSCredentials*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTLSCredentials[n]; + if (size) + *size = n * sizeof(_sai__SetTLSCredentials); + for (int i = 0; i < n; i++) + ((_sai__SetTLSCredentials*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTLSCredentials*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSCredentials(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTLSCredentials %p -> %p\n", q, p)); + *(_sai__SetTLSCredentials*)p = *(_sai__SetTLSCredentials*)q; +} + +void _sai__CertStoreUpdateCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__CertStoreUpdateCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreUpdateCertificateResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__CertStoreUpdateCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreUpdateCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreUpdateCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreUpdateCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreUpdateCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreUpdateCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreUpdateCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreUpdateCertificateResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreUpdateCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreUpdateCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse * SOAP_FMAC4 soap_get__sai__CertStoreUpdateCertificateResponse(struct soap *soap, _sai__CertStoreUpdateCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreUpdateCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreUpdateCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreUpdateCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse * SOAP_FMAC4 soap_in__sai__CertStoreUpdateCertificateResponse(struct soap *soap, const char *tag, _sai__CertStoreUpdateCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreUpdateCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreUpdateCertificateResponse, sizeof(_sai__CertStoreUpdateCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreUpdateCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreUpdateCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreUpdateCertificateResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreUpdateCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreUpdateCertificateResponse, 0, sizeof(_sai__CertStoreUpdateCertificateResponse), 0, soap_copy__sai__CertStoreUpdateCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreUpdateCertificateResponse * SOAP_FMAC6 soap_new__sai__CertStoreUpdateCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreUpdateCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreUpdateCertificateResponse(struct soap *soap, _sai__CertStoreUpdateCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreUpdateCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreUpdateCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreUpdateCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreUpdateCertificateResponse; + if (size) + *size = sizeof(_sai__CertStoreUpdateCertificateResponse); + ((_sai__CertStoreUpdateCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreUpdateCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreUpdateCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreUpdateCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreUpdateCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreUpdateCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreUpdateCertificateResponse %p -> %p\n", q, p)); + *(_sai__CertStoreUpdateCertificateResponse*)p = *(_sai__CertStoreUpdateCertificateResponse*)q; +} + +void _sai__CertStoreUpdateCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__CertStoreUpdateCertificate*)this)->CertHandle, SOAP_TYPE_sai__CertificateHandleType); + soap_serialize_PointerTosai__CertificateType(soap, &((_sai__CertStoreUpdateCertificate*)this)->Certificate); + /* transient soap skipped */ +} + +void _sai__CertStoreUpdateCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__CertificateHandleType(soap, &((_sai__CertStoreUpdateCertificate*)this)->CertHandle); + ((_sai__CertStoreUpdateCertificate*)this)->Certificate = NULL; + /* transient soap skipped */ +} + +int _sai__CertStoreUpdateCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreUpdateCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreUpdateCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreUpdateCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreUpdateCertificate(struct soap *soap, const char *tag, int id, const _sai__CertStoreUpdateCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreUpdateCertificate), type); + soap_out_sai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__CertStoreUpdateCertificate*)a)->CertHandle), ""); + soap_out_PointerTosai__CertificateType(soap, "sai:Certificate", -1, &(((_sai__CertStoreUpdateCertificate*)a)->Certificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreUpdateCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreUpdateCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_get__sai__CertStoreUpdateCertificate(struct soap *soap, _sai__CertStoreUpdateCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreUpdateCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreUpdateCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreUpdateCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_in__sai__CertStoreUpdateCertificate(struct soap *soap, const char *tag, _sai__CertStoreUpdateCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreUpdateCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreUpdateCertificate, sizeof(_sai__CertStoreUpdateCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreUpdateCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreUpdateCertificate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CertHandle1 = 1, soap_flag_Certificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CertHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__CertStoreUpdateCertificate*)a)->CertHandle), "sai:CertificateHandleType")) + { soap_flag_CertHandle1--; + continue; + } + if (soap_flag_Certificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateType(soap, "sai:Certificate", &(((_sai__CertStoreUpdateCertificate*)a)->Certificate), "sai:CertificateType")) + { soap_flag_Certificate1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CertHandle1 > 0 || soap_flag_Certificate1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreUpdateCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreUpdateCertificate, 0, sizeof(_sai__CertStoreUpdateCertificate), 0, soap_copy__sai__CertStoreUpdateCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreUpdateCertificate * SOAP_FMAC6 soap_new__sai__CertStoreUpdateCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreUpdateCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreUpdateCertificate(struct soap *soap, _sai__CertStoreUpdateCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_instantiate__sai__CertStoreUpdateCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreUpdateCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreUpdateCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreUpdateCertificate; + if (size) + *size = sizeof(_sai__CertStoreUpdateCertificate); + ((_sai__CertStoreUpdateCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreUpdateCertificate[n]; + if (size) + *size = n * sizeof(_sai__CertStoreUpdateCertificate); + for (int i = 0; i < n; i++) + ((_sai__CertStoreUpdateCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreUpdateCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreUpdateCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreUpdateCertificate %p -> %p\n", q, p)); + *(_sai__CertStoreUpdateCertificate*)p = *(_sai__CertStoreUpdateCertificate*)q; +} + +void _sai__CertStoreGetPKCS10RequestResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__CertStoreGetPKCS10RequestResponse*)this)->CertificateRequest, SOAP_TYPE_xsd__base64Binary); + ((_sai__CertStoreGetPKCS10RequestResponse*)this)->CertificateRequest.soap_serialize(soap); + /* transient soap skipped */ +} + +void _sai__CertStoreGetPKCS10RequestResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreGetPKCS10RequestResponse*)this)->StatusCode); + ((_sai__CertStoreGetPKCS10RequestResponse*)this)->CertificateRequest.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int _sai__CertStoreGetPKCS10RequestResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreGetPKCS10RequestResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreGetPKCS10RequestResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreGetPKCS10RequestResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreGetPKCS10RequestResponse*)a)->StatusCode), ""); + (((_sai__CertStoreGetPKCS10RequestResponse*)a)->CertificateRequest).soap_out(soap, "sai:CertificateRequest", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreGetPKCS10RequestResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreGetPKCS10RequestResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse * SOAP_FMAC4 soap_get__sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, _sai__CertStoreGetPKCS10RequestResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreGetPKCS10RequestResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreGetPKCS10RequestResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreGetPKCS10RequestResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse * SOAP_FMAC4 soap_in__sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, const char *tag, _sai__CertStoreGetPKCS10RequestResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreGetPKCS10RequestResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse, sizeof(_sai__CertStoreGetPKCS10RequestResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreGetPKCS10RequestResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_CertificateRequest1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreGetPKCS10RequestResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_CertificateRequest1 && soap->error == SOAP_TAG_MISMATCH) + if ((((_sai__CertStoreGetPKCS10RequestResponse*)a)->CertificateRequest).soap_in(soap, "sai:CertificateRequest", "xsd:base64Binary")) + { soap_flag_CertificateRequest1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_CertificateRequest1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreGetPKCS10RequestResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse, 0, sizeof(_sai__CertStoreGetPKCS10RequestResponse), 0, soap_copy__sai__CertStoreGetPKCS10RequestResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreGetPKCS10RequestResponse * SOAP_FMAC6 soap_new__sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreGetPKCS10RequestResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, _sai__CertStoreGetPKCS10RequestResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreGetPKCS10RequestResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreGetPKCS10RequestResponse; + if (size) + *size = sizeof(_sai__CertStoreGetPKCS10RequestResponse); + ((_sai__CertStoreGetPKCS10RequestResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreGetPKCS10RequestResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreGetPKCS10RequestResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreGetPKCS10RequestResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreGetPKCS10RequestResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreGetPKCS10RequestResponse %p -> %p\n", q, p)); + *(_sai__CertStoreGetPKCS10RequestResponse*)p = *(_sai__CertStoreGetPKCS10RequestResponse*)q; +} + +void _sai__CertStoreGetPKCS10Request::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__CertStoreGetPKCS10Request*)this)->KeyPairHandle, SOAP_TYPE_sai__CertificateHandleType); + soap_serialize_PointerTostd__string(soap, &((_sai__CertStoreGetPKCS10Request*)this)->DNName); + soap_serialize_PointerTostd__string(soap, &((_sai__CertStoreGetPKCS10Request*)this)->Usage); + /* transient soap skipped */ +} + +void _sai__CertStoreGetPKCS10Request::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__CertificateHandleType(soap, &((_sai__CertStoreGetPKCS10Request*)this)->KeyPairHandle); + ((_sai__CertStoreGetPKCS10Request*)this)->DNName = NULL; + ((_sai__CertStoreGetPKCS10Request*)this)->Usage = NULL; + /* transient soap skipped */ +} + +int _sai__CertStoreGetPKCS10Request::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreGetPKCS10Request); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreGetPKCS10Request::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreGetPKCS10Request(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetPKCS10Request(struct soap *soap, const char *tag, int id, const _sai__CertStoreGetPKCS10Request *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreGetPKCS10Request), type); + soap_out_sai__CertificateHandleType(soap, "sai:KeyPairHandle", -1, &(((_sai__CertStoreGetPKCS10Request*)a)->KeyPairHandle), ""); + soap_out_PointerTostd__string(soap, "sai:DNName", -1, &(((_sai__CertStoreGetPKCS10Request*)a)->DNName), ""); + soap_out_PointerTostd__string(soap, "sai:Usage", -1, &(((_sai__CertStoreGetPKCS10Request*)a)->Usage), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreGetPKCS10Request::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreGetPKCS10Request(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_get__sai__CertStoreGetPKCS10Request(struct soap *soap, _sai__CertStoreGetPKCS10Request *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreGetPKCS10Request(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreGetPKCS10Request::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreGetPKCS10Request(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_in__sai__CertStoreGetPKCS10Request(struct soap *soap, const char *tag, _sai__CertStoreGetPKCS10Request *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreGetPKCS10Request *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreGetPKCS10Request, sizeof(_sai__CertStoreGetPKCS10Request), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreGetPKCS10Request) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreGetPKCS10Request *)a->soap_in(soap, tag, type); + } + } + short soap_flag_KeyPairHandle1 = 1, soap_flag_DNName1 = 1, soap_flag_Usage1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_KeyPairHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:KeyPairHandle", &(((_sai__CertStoreGetPKCS10Request*)a)->KeyPairHandle), "sai:CertificateHandleType")) + { soap_flag_KeyPairHandle1--; + continue; + } + if (soap_flag_DNName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "sai:DNName", &(((_sai__CertStoreGetPKCS10Request*)a)->DNName), "xsd:string")) + { soap_flag_DNName1--; + continue; + } + if (soap_flag_Usage1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "sai:Usage", &(((_sai__CertStoreGetPKCS10Request*)a)->Usage), "xsd:string")) + { soap_flag_Usage1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_KeyPairHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreGetPKCS10Request *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreGetPKCS10Request, 0, sizeof(_sai__CertStoreGetPKCS10Request), 0, soap_copy__sai__CertStoreGetPKCS10Request); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreGetPKCS10Request * SOAP_FMAC6 soap_new__sai__CertStoreGetPKCS10Request(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreGetPKCS10Request(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetPKCS10Request(struct soap *soap, _sai__CertStoreGetPKCS10Request *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetPKCS10Request(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreGetPKCS10Request(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreGetPKCS10Request, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreGetPKCS10Request; + if (size) + *size = sizeof(_sai__CertStoreGetPKCS10Request); + ((_sai__CertStoreGetPKCS10Request*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreGetPKCS10Request[n]; + if (size) + *size = n * sizeof(_sai__CertStoreGetPKCS10Request); + for (int i = 0; i < n; i++) + ((_sai__CertStoreGetPKCS10Request*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreGetPKCS10Request*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetPKCS10Request(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreGetPKCS10Request %p -> %p\n", q, p)); + *(_sai__CertStoreGetPKCS10Request*)p = *(_sai__CertStoreGetPKCS10Request*)q; +} + +void _sai__CertStoreRemoveCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__CertStoreRemoveCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreRemoveCertificateResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__CertStoreRemoveCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreRemoveCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreRemoveCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreRemoveCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreRemoveCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreRemoveCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreRemoveCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreRemoveCertificateResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreRemoveCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreRemoveCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse * SOAP_FMAC4 soap_get__sai__CertStoreRemoveCertificateResponse(struct soap *soap, _sai__CertStoreRemoveCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreRemoveCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreRemoveCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreRemoveCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse * SOAP_FMAC4 soap_in__sai__CertStoreRemoveCertificateResponse(struct soap *soap, const char *tag, _sai__CertStoreRemoveCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreRemoveCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreRemoveCertificateResponse, sizeof(_sai__CertStoreRemoveCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreRemoveCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreRemoveCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreRemoveCertificateResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreRemoveCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreRemoveCertificateResponse, 0, sizeof(_sai__CertStoreRemoveCertificateResponse), 0, soap_copy__sai__CertStoreRemoveCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreRemoveCertificateResponse * SOAP_FMAC6 soap_new__sai__CertStoreRemoveCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreRemoveCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreRemoveCertificateResponse(struct soap *soap, _sai__CertStoreRemoveCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreRemoveCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreRemoveCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreRemoveCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreRemoveCertificateResponse; + if (size) + *size = sizeof(_sai__CertStoreRemoveCertificateResponse); + ((_sai__CertStoreRemoveCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreRemoveCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreRemoveCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreRemoveCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreRemoveCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreRemoveCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreRemoveCertificateResponse %p -> %p\n", q, p)); + *(_sai__CertStoreRemoveCertificateResponse*)p = *(_sai__CertStoreRemoveCertificateResponse*)q; +} + +void _sai__CertStoreRemoveCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__CertStoreRemoveCertificate*)this)->CertHandle, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void _sai__CertStoreRemoveCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__CertificateHandleType(soap, &((_sai__CertStoreRemoveCertificate*)this)->CertHandle); + /* transient soap skipped */ +} + +int _sai__CertStoreRemoveCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreRemoveCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreRemoveCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreRemoveCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreRemoveCertificate(struct soap *soap, const char *tag, int id, const _sai__CertStoreRemoveCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreRemoveCertificate), type); + soap_out_sai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__CertStoreRemoveCertificate*)a)->CertHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreRemoveCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreRemoveCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_get__sai__CertStoreRemoveCertificate(struct soap *soap, _sai__CertStoreRemoveCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreRemoveCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreRemoveCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreRemoveCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_in__sai__CertStoreRemoveCertificate(struct soap *soap, const char *tag, _sai__CertStoreRemoveCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreRemoveCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreRemoveCertificate, sizeof(_sai__CertStoreRemoveCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreRemoveCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreRemoveCertificate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CertHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CertHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__CertStoreRemoveCertificate*)a)->CertHandle), "sai:CertificateHandleType")) + { soap_flag_CertHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CertHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreRemoveCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreRemoveCertificate, 0, sizeof(_sai__CertStoreRemoveCertificate), 0, soap_copy__sai__CertStoreRemoveCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreRemoveCertificate * SOAP_FMAC6 soap_new__sai__CertStoreRemoveCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreRemoveCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreRemoveCertificate(struct soap *soap, _sai__CertStoreRemoveCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_instantiate__sai__CertStoreRemoveCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreRemoveCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreRemoveCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreRemoveCertificate; + if (size) + *size = sizeof(_sai__CertStoreRemoveCertificate); + ((_sai__CertStoreRemoveCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreRemoveCertificate[n]; + if (size) + *size = n * sizeof(_sai__CertStoreRemoveCertificate); + for (int i = 0; i < n; i++) + ((_sai__CertStoreRemoveCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreRemoveCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreRemoveCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreRemoveCertificate %p -> %p\n", q, p)); + *(_sai__CertStoreRemoveCertificate*)p = *(_sai__CertStoreRemoveCertificate*)q; +} + +void _sai__CertStoreGetCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateType(soap, &((_sai__CertStoreGetCertificateResponse*)this)->Certificate); + /* transient soap skipped */ +} + +void _sai__CertStoreGetCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreGetCertificateResponse*)this)->StatusCode); + ((_sai__CertStoreGetCertificateResponse*)this)->Certificate = NULL; + /* transient soap skipped */ +} + +int _sai__CertStoreGetCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreGetCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreGetCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreGetCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreGetCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreGetCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreGetCertificateResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__CertificateType(soap, "sai:Certificate", -1, &(((_sai__CertStoreGetCertificateResponse*)a)->Certificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreGetCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreGetCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse * SOAP_FMAC4 soap_get__sai__CertStoreGetCertificateResponse(struct soap *soap, _sai__CertStoreGetCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreGetCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreGetCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreGetCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse * SOAP_FMAC4 soap_in__sai__CertStoreGetCertificateResponse(struct soap *soap, const char *tag, _sai__CertStoreGetCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreGetCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreGetCertificateResponse, sizeof(_sai__CertStoreGetCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreGetCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreGetCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Certificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreGetCertificateResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Certificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateType(soap, "sai:Certificate", &(((_sai__CertStoreGetCertificateResponse*)a)->Certificate), "sai:CertificateType")) + { soap_flag_Certificate1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Certificate1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreGetCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreGetCertificateResponse, 0, sizeof(_sai__CertStoreGetCertificateResponse), 0, soap_copy__sai__CertStoreGetCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreGetCertificateResponse * SOAP_FMAC6 soap_new__sai__CertStoreGetCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreGetCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetCertificateResponse(struct soap *soap, _sai__CertStoreGetCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreGetCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreGetCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreGetCertificateResponse; + if (size) + *size = sizeof(_sai__CertStoreGetCertificateResponse); + ((_sai__CertStoreGetCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreGetCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreGetCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreGetCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreGetCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreGetCertificateResponse %p -> %p\n", q, p)); + *(_sai__CertStoreGetCertificateResponse*)p = *(_sai__CertStoreGetCertificateResponse*)q; +} + +void _sai__CertStoreGetCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__CertStoreGetCertificate*)this)->CertHandle, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void _sai__CertStoreGetCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__CertificateHandleType(soap, &((_sai__CertStoreGetCertificate*)this)->CertHandle); + /* transient soap skipped */ +} + +int _sai__CertStoreGetCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreGetCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreGetCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreGetCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetCertificate(struct soap *soap, const char *tag, int id, const _sai__CertStoreGetCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreGetCertificate), type); + soap_out_sai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__CertStoreGetCertificate*)a)->CertHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreGetCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreGetCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreGetCertificate * SOAP_FMAC4 soap_get__sai__CertStoreGetCertificate(struct soap *soap, _sai__CertStoreGetCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreGetCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreGetCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreGetCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreGetCertificate * SOAP_FMAC4 soap_in__sai__CertStoreGetCertificate(struct soap *soap, const char *tag, _sai__CertStoreGetCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreGetCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreGetCertificate, sizeof(_sai__CertStoreGetCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreGetCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreGetCertificate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CertHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CertHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__CertStoreGetCertificate*)a)->CertHandle), "sai:CertificateHandleType")) + { soap_flag_CertHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CertHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreGetCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreGetCertificate, 0, sizeof(_sai__CertStoreGetCertificate), 0, soap_copy__sai__CertStoreGetCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreGetCertificate * SOAP_FMAC6 soap_new__sai__CertStoreGetCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreGetCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetCertificate(struct soap *soap, _sai__CertStoreGetCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreGetCertificate * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreGetCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreGetCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreGetCertificate; + if (size) + *size = sizeof(_sai__CertStoreGetCertificate); + ((_sai__CertStoreGetCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreGetCertificate[n]; + if (size) + *size = n * sizeof(_sai__CertStoreGetCertificate); + for (int i = 0; i < n; i++) + ((_sai__CertStoreGetCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreGetCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreGetCertificate %p -> %p\n", q, p)); + *(_sai__CertStoreGetCertificate*)p = *(_sai__CertStoreGetCertificate*)q; +} + +void _sai__CertStoreEnumerateCertificatesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfsai__CertificateHandleType(soap, &((_sai__CertStoreEnumerateCertificatesResponse*)this)->CertHandles); + /* transient soap skipped */ +} + +void _sai__CertStoreEnumerateCertificatesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreEnumerateCertificatesResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfsai__CertificateHandleType(soap, &((_sai__CertStoreEnumerateCertificatesResponse*)this)->CertHandles); + /* transient soap skipped */ +} + +int _sai__CertStoreEnumerateCertificatesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreEnumerateCertificatesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreEnumerateCertificatesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreEnumerateCertificatesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreEnumerateCertificatesResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfsai__CertificateHandleType(soap, "sai:CertHandles", -1, &(((_sai__CertStoreEnumerateCertificatesResponse*)a)->CertHandles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreEnumerateCertificatesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreEnumerateCertificatesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse * SOAP_FMAC4 soap_get__sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, _sai__CertStoreEnumerateCertificatesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreEnumerateCertificatesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreEnumerateCertificatesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreEnumerateCertificatesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse * SOAP_FMAC4 soap_in__sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, const char *tag, _sai__CertStoreEnumerateCertificatesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreEnumerateCertificatesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse, sizeof(_sai__CertStoreEnumerateCertificatesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreEnumerateCertificatesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreEnumerateCertificatesResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfsai__CertificateHandleType(soap, "sai:CertHandles", &(((_sai__CertStoreEnumerateCertificatesResponse*)a)->CertHandles), "sai:CertificateHandleType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreEnumerateCertificatesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse, 0, sizeof(_sai__CertStoreEnumerateCertificatesResponse), 0, soap_copy__sai__CertStoreEnumerateCertificatesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreEnumerateCertificatesResponse * SOAP_FMAC6 soap_new__sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreEnumerateCertificatesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, _sai__CertStoreEnumerateCertificatesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreEnumerateCertificatesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreEnumerateCertificatesResponse; + if (size) + *size = sizeof(_sai__CertStoreEnumerateCertificatesResponse); + ((_sai__CertStoreEnumerateCertificatesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreEnumerateCertificatesResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreEnumerateCertificatesResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreEnumerateCertificatesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreEnumerateCertificatesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreEnumerateCertificatesResponse %p -> %p\n", q, p)); + *(_sai__CertStoreEnumerateCertificatesResponse*)p = *(_sai__CertStoreEnumerateCertificatesResponse*)q; +} + +void _sai__CertStoreEnumerateCertificates::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostd__string(soap, &((_sai__CertStoreEnumerateCertificates*)this)->FindByDNName); + soap_serialize_PointerTostd__string(soap, &((_sai__CertStoreEnumerateCertificates*)this)->FindByUsage); + soap_serialize_PointerTostd__string(soap, &((_sai__CertStoreEnumerateCertificates*)this)->FindByIssuer); + /* transient soap skipped */ +} + +void _sai__CertStoreEnumerateCertificates::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__CertStoreEnumerateCertificates*)this)->FindByDNName = NULL; + ((_sai__CertStoreEnumerateCertificates*)this)->FindByUsage = NULL; + ((_sai__CertStoreEnumerateCertificates*)this)->FindByIssuer = NULL; + /* transient soap skipped */ +} + +int _sai__CertStoreEnumerateCertificates::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreEnumerateCertificates); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreEnumerateCertificates::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreEnumerateCertificates(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreEnumerateCertificates(struct soap *soap, const char *tag, int id, const _sai__CertStoreEnumerateCertificates *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreEnumerateCertificates), type); + soap_out_PointerTostd__string(soap, "sai:FindByDNName", -1, &(((_sai__CertStoreEnumerateCertificates*)a)->FindByDNName), ""); + soap_out_PointerTostd__string(soap, "sai:FindByUsage", -1, &(((_sai__CertStoreEnumerateCertificates*)a)->FindByUsage), ""); + soap_out_PointerTostd__string(soap, "sai:FindByIssuer", -1, &(((_sai__CertStoreEnumerateCertificates*)a)->FindByIssuer), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreEnumerateCertificates::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreEnumerateCertificates(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_get__sai__CertStoreEnumerateCertificates(struct soap *soap, _sai__CertStoreEnumerateCertificates *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreEnumerateCertificates(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreEnumerateCertificates::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreEnumerateCertificates(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_in__sai__CertStoreEnumerateCertificates(struct soap *soap, const char *tag, _sai__CertStoreEnumerateCertificates *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreEnumerateCertificates *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreEnumerateCertificates, sizeof(_sai__CertStoreEnumerateCertificates), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreEnumerateCertificates) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreEnumerateCertificates *)a->soap_in(soap, tag, type); + } + } + short soap_flag_FindByDNName1 = 1, soap_flag_FindByUsage1 = 1, soap_flag_FindByIssuer1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_FindByDNName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "sai:FindByDNName", &(((_sai__CertStoreEnumerateCertificates*)a)->FindByDNName), "xsd:string")) + { soap_flag_FindByDNName1--; + continue; + } + if (soap_flag_FindByUsage1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "sai:FindByUsage", &(((_sai__CertStoreEnumerateCertificates*)a)->FindByUsage), "xsd:string")) + { soap_flag_FindByUsage1--; + continue; + } + if (soap_flag_FindByIssuer1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "sai:FindByIssuer", &(((_sai__CertStoreEnumerateCertificates*)a)->FindByIssuer), "xsd:string")) + { soap_flag_FindByIssuer1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreEnumerateCertificates *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreEnumerateCertificates, 0, sizeof(_sai__CertStoreEnumerateCertificates), 0, soap_copy__sai__CertStoreEnumerateCertificates); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreEnumerateCertificates * SOAP_FMAC6 soap_new__sai__CertStoreEnumerateCertificates(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreEnumerateCertificates(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreEnumerateCertificates(struct soap *soap, _sai__CertStoreEnumerateCertificates *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_instantiate__sai__CertStoreEnumerateCertificates(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreEnumerateCertificates(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreEnumerateCertificates, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreEnumerateCertificates; + if (size) + *size = sizeof(_sai__CertStoreEnumerateCertificates); + ((_sai__CertStoreEnumerateCertificates*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreEnumerateCertificates[n]; + if (size) + *size = n * sizeof(_sai__CertStoreEnumerateCertificates); + for (int i = 0; i < n; i++) + ((_sai__CertStoreEnumerateCertificates*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreEnumerateCertificates*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreEnumerateCertificates(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreEnumerateCertificates %p -> %p\n", q, p)); + *(_sai__CertStoreEnumerateCertificates*)p = *(_sai__CertStoreEnumerateCertificates*)q; +} + +void _sai__CertStoreAddCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__CertStoreAddCertificateResponse*)this)->CertHandle, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void _sai__CertStoreAddCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreAddCertificateResponse*)this)->StatusCode); + soap_default_sai__CertificateHandleType(soap, &((_sai__CertStoreAddCertificateResponse*)this)->CertHandle); + /* transient soap skipped */ +} + +int _sai__CertStoreAddCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreAddCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreAddCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreAddCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreAddCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreAddCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreAddCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreAddCertificateResponse*)a)->StatusCode), ""); + soap_out_sai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__CertStoreAddCertificateResponse*)a)->CertHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreAddCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreAddCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse * SOAP_FMAC4 soap_get__sai__CertStoreAddCertificateResponse(struct soap *soap, _sai__CertStoreAddCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreAddCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreAddCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreAddCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse * SOAP_FMAC4 soap_in__sai__CertStoreAddCertificateResponse(struct soap *soap, const char *tag, _sai__CertStoreAddCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreAddCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreAddCertificateResponse, sizeof(_sai__CertStoreAddCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreAddCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreAddCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_CertHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreAddCertificateResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_CertHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__CertStoreAddCertificateResponse*)a)->CertHandle), "sai:CertificateHandleType")) + { soap_flag_CertHandle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_CertHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreAddCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreAddCertificateResponse, 0, sizeof(_sai__CertStoreAddCertificateResponse), 0, soap_copy__sai__CertStoreAddCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreAddCertificateResponse * SOAP_FMAC6 soap_new__sai__CertStoreAddCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreAddCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreAddCertificateResponse(struct soap *soap, _sai__CertStoreAddCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreAddCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreAddCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreAddCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreAddCertificateResponse; + if (size) + *size = sizeof(_sai__CertStoreAddCertificateResponse); + ((_sai__CertStoreAddCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreAddCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreAddCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreAddCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreAddCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreAddCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreAddCertificateResponse %p -> %p\n", q, p)); + *(_sai__CertStoreAddCertificateResponse*)p = *(_sai__CertStoreAddCertificateResponse*)q; +} + +void _sai__CertStoreAddCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateType(soap, &((_sai__CertStoreAddCertificate*)this)->Certificate); + /* transient soap skipped */ +} + +void _sai__CertStoreAddCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__CertStoreAddCertificate*)this)->Certificate = NULL; + /* transient soap skipped */ +} + +int _sai__CertStoreAddCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreAddCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreAddCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreAddCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreAddCertificate(struct soap *soap, const char *tag, int id, const _sai__CertStoreAddCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreAddCertificate), type); + soap_out_PointerTosai__CertificateType(soap, "sai:Certificate", -1, &(((_sai__CertStoreAddCertificate*)a)->Certificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreAddCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreAddCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreAddCertificate * SOAP_FMAC4 soap_get__sai__CertStoreAddCertificate(struct soap *soap, _sai__CertStoreAddCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreAddCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreAddCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreAddCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreAddCertificate * SOAP_FMAC4 soap_in__sai__CertStoreAddCertificate(struct soap *soap, const char *tag, _sai__CertStoreAddCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreAddCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreAddCertificate, sizeof(_sai__CertStoreAddCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreAddCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreAddCertificate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Certificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Certificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateType(soap, "sai:Certificate", &(((_sai__CertStoreAddCertificate*)a)->Certificate), "sai:CertificateType")) + { soap_flag_Certificate1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Certificate1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreAddCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreAddCertificate, 0, sizeof(_sai__CertStoreAddCertificate), 0, soap_copy__sai__CertStoreAddCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreAddCertificate * SOAP_FMAC6 soap_new__sai__CertStoreAddCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreAddCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreAddCertificate(struct soap *soap, _sai__CertStoreAddCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreAddCertificate * SOAP_FMAC4 soap_instantiate__sai__CertStoreAddCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreAddCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreAddCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreAddCertificate; + if (size) + *size = sizeof(_sai__CertStoreAddCertificate); + ((_sai__CertStoreAddCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreAddCertificate[n]; + if (size) + *size = n * sizeof(_sai__CertStoreAddCertificate); + for (int i = 0; i < n; i++) + ((_sai__CertStoreAddCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreAddCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreAddCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreAddCertificate %p -> %p\n", q, p)); + *(_sai__CertStoreAddCertificate*)p = *(_sai__CertStoreAddCertificate*)q; +} + +void _sai__CertStoreRemoveKeyResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__CertStoreRemoveKeyResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreRemoveKeyResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__CertStoreRemoveKeyResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreRemoveKeyResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreRemoveKeyResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreRemoveKeyResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreRemoveKeyResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreRemoveKeyResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreRemoveKeyResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreRemoveKeyResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreRemoveKeyResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreRemoveKeyResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse * SOAP_FMAC4 soap_get__sai__CertStoreRemoveKeyResponse(struct soap *soap, _sai__CertStoreRemoveKeyResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreRemoveKeyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreRemoveKeyResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreRemoveKeyResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse * SOAP_FMAC4 soap_in__sai__CertStoreRemoveKeyResponse(struct soap *soap, const char *tag, _sai__CertStoreRemoveKeyResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreRemoveKeyResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreRemoveKeyResponse, sizeof(_sai__CertStoreRemoveKeyResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreRemoveKeyResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreRemoveKeyResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreRemoveKeyResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreRemoveKeyResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreRemoveKeyResponse, 0, sizeof(_sai__CertStoreRemoveKeyResponse), 0, soap_copy__sai__CertStoreRemoveKeyResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreRemoveKeyResponse * SOAP_FMAC6 soap_new__sai__CertStoreRemoveKeyResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreRemoveKeyResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreRemoveKeyResponse(struct soap *soap, _sai__CertStoreRemoveKeyResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreRemoveKeyResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreRemoveKeyResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreRemoveKeyResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreRemoveKeyResponse; + if (size) + *size = sizeof(_sai__CertStoreRemoveKeyResponse); + ((_sai__CertStoreRemoveKeyResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreRemoveKeyResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreRemoveKeyResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreRemoveKeyResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreRemoveKeyResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreRemoveKeyResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreRemoveKeyResponse %p -> %p\n", q, p)); + *(_sai__CertStoreRemoveKeyResponse*)p = *(_sai__CertStoreRemoveKeyResponse*)q; +} + +void _sai__CertStoreRemoveKey::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__CertStoreRemoveKey*)this)->KeyPairHandle, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void _sai__CertStoreRemoveKey::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__CertificateHandleType(soap, &((_sai__CertStoreRemoveKey*)this)->KeyPairHandle); + /* transient soap skipped */ +} + +int _sai__CertStoreRemoveKey::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreRemoveKey); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreRemoveKey::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreRemoveKey(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreRemoveKey(struct soap *soap, const char *tag, int id, const _sai__CertStoreRemoveKey *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreRemoveKey), type); + soap_out_sai__CertificateHandleType(soap, "sai:KeyPairHandle", -1, &(((_sai__CertStoreRemoveKey*)a)->KeyPairHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreRemoveKey::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreRemoveKey(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveKey * SOAP_FMAC4 soap_get__sai__CertStoreRemoveKey(struct soap *soap, _sai__CertStoreRemoveKey *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreRemoveKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreRemoveKey::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreRemoveKey(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveKey * SOAP_FMAC4 soap_in__sai__CertStoreRemoveKey(struct soap *soap, const char *tag, _sai__CertStoreRemoveKey *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreRemoveKey *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreRemoveKey, sizeof(_sai__CertStoreRemoveKey), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreRemoveKey) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreRemoveKey *)a->soap_in(soap, tag, type); + } + } + short soap_flag_KeyPairHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_KeyPairHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:KeyPairHandle", &(((_sai__CertStoreRemoveKey*)a)->KeyPairHandle), "sai:CertificateHandleType")) + { soap_flag_KeyPairHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_KeyPairHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreRemoveKey *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreRemoveKey, 0, sizeof(_sai__CertStoreRemoveKey), 0, soap_copy__sai__CertStoreRemoveKey); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreRemoveKey * SOAP_FMAC6 soap_new__sai__CertStoreRemoveKey(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreRemoveKey(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreRemoveKey(struct soap *soap, _sai__CertStoreRemoveKey *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreRemoveKey * SOAP_FMAC4 soap_instantiate__sai__CertStoreRemoveKey(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreRemoveKey(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreRemoveKey, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreRemoveKey; + if (size) + *size = sizeof(_sai__CertStoreRemoveKey); + ((_sai__CertStoreRemoveKey*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreRemoveKey[n]; + if (size) + *size = n * sizeof(_sai__CertStoreRemoveKey); + for (int i = 0; i < n; i++) + ((_sai__CertStoreRemoveKey*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreRemoveKey*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreRemoveKey(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreRemoveKey %p -> %p\n", q, p)); + *(_sai__CertStoreRemoveKey*)p = *(_sai__CertStoreRemoveKey*)q; +} + +void _sai__CertStoreGetKeyResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocstr__KeyPairType(soap, &((_sai__CertStoreGetKeyResponse*)this)->PublicKey); + /* transient soap skipped */ +} + +void _sai__CertStoreGetKeyResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreGetKeyResponse*)this)->StatusCode); + ((_sai__CertStoreGetKeyResponse*)this)->PublicKey = NULL; + /* transient soap skipped */ +} + +int _sai__CertStoreGetKeyResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreGetKeyResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreGetKeyResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreGetKeyResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetKeyResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreGetKeyResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreGetKeyResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreGetKeyResponse*)a)->StatusCode), ""); + soap_out_PointerTocstr__KeyPairType(soap, "sai:PublicKey", -1, &(((_sai__CertStoreGetKeyResponse*)a)->PublicKey), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreGetKeyResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreGetKeyResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreGetKeyResponse * SOAP_FMAC4 soap_get__sai__CertStoreGetKeyResponse(struct soap *soap, _sai__CertStoreGetKeyResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreGetKeyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreGetKeyResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreGetKeyResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreGetKeyResponse * SOAP_FMAC4 soap_in__sai__CertStoreGetKeyResponse(struct soap *soap, const char *tag, _sai__CertStoreGetKeyResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreGetKeyResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreGetKeyResponse, sizeof(_sai__CertStoreGetKeyResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreGetKeyResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreGetKeyResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_PublicKey1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreGetKeyResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_PublicKey1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocstr__KeyPairType(soap, "sai:PublicKey", &(((_sai__CertStoreGetKeyResponse*)a)->PublicKey), "cstr:KeyPairType")) + { soap_flag_PublicKey1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_PublicKey1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreGetKeyResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreGetKeyResponse, 0, sizeof(_sai__CertStoreGetKeyResponse), 0, soap_copy__sai__CertStoreGetKeyResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreGetKeyResponse * SOAP_FMAC6 soap_new__sai__CertStoreGetKeyResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreGetKeyResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetKeyResponse(struct soap *soap, _sai__CertStoreGetKeyResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreGetKeyResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetKeyResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreGetKeyResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreGetKeyResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreGetKeyResponse; + if (size) + *size = sizeof(_sai__CertStoreGetKeyResponse); + ((_sai__CertStoreGetKeyResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreGetKeyResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreGetKeyResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreGetKeyResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreGetKeyResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetKeyResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreGetKeyResponse %p -> %p\n", q, p)); + *(_sai__CertStoreGetKeyResponse*)p = *(_sai__CertStoreGetKeyResponse*)q; +} + +void _sai__CertStoreGetKey::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__CertStoreGetKey*)this)->KeyPairHandle, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void _sai__CertStoreGetKey::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__CertificateHandleType(soap, &((_sai__CertStoreGetKey*)this)->KeyPairHandle); + /* transient soap skipped */ +} + +int _sai__CertStoreGetKey::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreGetKey); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreGetKey::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreGetKey(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreGetKey(struct soap *soap, const char *tag, int id, const _sai__CertStoreGetKey *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreGetKey), type); + soap_out_sai__CertificateHandleType(soap, "sai:KeyPairHandle", -1, &(((_sai__CertStoreGetKey*)a)->KeyPairHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreGetKey::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreGetKey(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreGetKey * SOAP_FMAC4 soap_get__sai__CertStoreGetKey(struct soap *soap, _sai__CertStoreGetKey *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreGetKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreGetKey::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreGetKey(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreGetKey * SOAP_FMAC4 soap_in__sai__CertStoreGetKey(struct soap *soap, const char *tag, _sai__CertStoreGetKey *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreGetKey *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreGetKey, sizeof(_sai__CertStoreGetKey), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreGetKey) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreGetKey *)a->soap_in(soap, tag, type); + } + } + short soap_flag_KeyPairHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_KeyPairHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:KeyPairHandle", &(((_sai__CertStoreGetKey*)a)->KeyPairHandle), "sai:CertificateHandleType")) + { soap_flag_KeyPairHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_KeyPairHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreGetKey *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreGetKey, 0, sizeof(_sai__CertStoreGetKey), 0, soap_copy__sai__CertStoreGetKey); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreGetKey * SOAP_FMAC6 soap_new__sai__CertStoreGetKey(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreGetKey(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreGetKey(struct soap *soap, _sai__CertStoreGetKey *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreGetKey * SOAP_FMAC4 soap_instantiate__sai__CertStoreGetKey(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreGetKey(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreGetKey, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreGetKey; + if (size) + *size = sizeof(_sai__CertStoreGetKey); + ((_sai__CertStoreGetKey*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreGetKey[n]; + if (size) + *size = n * sizeof(_sai__CertStoreGetKey); + for (int i = 0; i < n; i++) + ((_sai__CertStoreGetKey*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreGetKey*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreGetKey(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreGetKey %p -> %p\n", q, p)); + *(_sai__CertStoreGetKey*)p = *(_sai__CertStoreGetKey*)q; +} + +void _sai__CertStoreEnumerateKeysResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfsai__CertificateHandleType(soap, &((_sai__CertStoreEnumerateKeysResponse*)this)->KeyPairHandles); + /* transient soap skipped */ +} + +void _sai__CertStoreEnumerateKeysResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreEnumerateKeysResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfsai__CertificateHandleType(soap, &((_sai__CertStoreEnumerateKeysResponse*)this)->KeyPairHandles); + /* transient soap skipped */ +} + +int _sai__CertStoreEnumerateKeysResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreEnumerateKeysResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreEnumerateKeysResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreEnumerateKeysResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreEnumerateKeysResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreEnumerateKeysResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreEnumerateKeysResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreEnumerateKeysResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfsai__CertificateHandleType(soap, "sai:KeyPairHandles", -1, &(((_sai__CertStoreEnumerateKeysResponse*)a)->KeyPairHandles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreEnumerateKeysResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreEnumerateKeysResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse * SOAP_FMAC4 soap_get__sai__CertStoreEnumerateKeysResponse(struct soap *soap, _sai__CertStoreEnumerateKeysResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreEnumerateKeysResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreEnumerateKeysResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreEnumerateKeysResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse * SOAP_FMAC4 soap_in__sai__CertStoreEnumerateKeysResponse(struct soap *soap, const char *tag, _sai__CertStoreEnumerateKeysResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreEnumerateKeysResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreEnumerateKeysResponse, sizeof(_sai__CertStoreEnumerateKeysResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreEnumerateKeysResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreEnumerateKeysResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreEnumerateKeysResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfsai__CertificateHandleType(soap, "sai:KeyPairHandles", &(((_sai__CertStoreEnumerateKeysResponse*)a)->KeyPairHandles), "sai:CertificateHandleType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreEnumerateKeysResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreEnumerateKeysResponse, 0, sizeof(_sai__CertStoreEnumerateKeysResponse), 0, soap_copy__sai__CertStoreEnumerateKeysResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreEnumerateKeysResponse * SOAP_FMAC6 soap_new__sai__CertStoreEnumerateKeysResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreEnumerateKeysResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreEnumerateKeysResponse(struct soap *soap, _sai__CertStoreEnumerateKeysResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreEnumerateKeysResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreEnumerateKeysResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreEnumerateKeysResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreEnumerateKeysResponse; + if (size) + *size = sizeof(_sai__CertStoreEnumerateKeysResponse); + ((_sai__CertStoreEnumerateKeysResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreEnumerateKeysResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreEnumerateKeysResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreEnumerateKeysResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreEnumerateKeysResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreEnumerateKeysResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreEnumerateKeysResponse %p -> %p\n", q, p)); + *(_sai__CertStoreEnumerateKeysResponse*)p = *(_sai__CertStoreEnumerateKeysResponse*)q; +} + +void _sai__CertStoreEnumerateKeys::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateHandleType(soap, &((_sai__CertStoreEnumerateKeys*)this)->FindByCert); + /* transient soap skipped */ +} + +void _sai__CertStoreEnumerateKeys::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__CertStoreEnumerateKeys*)this)->FindByCert = NULL; + /* transient soap skipped */ +} + +int _sai__CertStoreEnumerateKeys::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreEnumerateKeys); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreEnumerateKeys::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreEnumerateKeys(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreEnumerateKeys(struct soap *soap, const char *tag, int id, const _sai__CertStoreEnumerateKeys *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreEnumerateKeys), type); + soap_out_PointerTosai__CertificateHandleType(soap, "sai:FindByCert", -1, &(((_sai__CertStoreEnumerateKeys*)a)->FindByCert), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreEnumerateKeys::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreEnumerateKeys(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_get__sai__CertStoreEnumerateKeys(struct soap *soap, _sai__CertStoreEnumerateKeys *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreEnumerateKeys(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreEnumerateKeys::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreEnumerateKeys(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_in__sai__CertStoreEnumerateKeys(struct soap *soap, const char *tag, _sai__CertStoreEnumerateKeys *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreEnumerateKeys *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreEnumerateKeys, sizeof(_sai__CertStoreEnumerateKeys), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreEnumerateKeys) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreEnumerateKeys *)a->soap_in(soap, tag, type); + } + } + short soap_flag_FindByCert1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_FindByCert1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateHandleType(soap, "sai:FindByCert", &(((_sai__CertStoreEnumerateKeys*)a)->FindByCert), "sai:CertificateHandleType")) + { soap_flag_FindByCert1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreEnumerateKeys *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreEnumerateKeys, 0, sizeof(_sai__CertStoreEnumerateKeys), 0, soap_copy__sai__CertStoreEnumerateKeys); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreEnumerateKeys * SOAP_FMAC6 soap_new__sai__CertStoreEnumerateKeys(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreEnumerateKeys(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreEnumerateKeys(struct soap *soap, _sai__CertStoreEnumerateKeys *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_instantiate__sai__CertStoreEnumerateKeys(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreEnumerateKeys(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreEnumerateKeys, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreEnumerateKeys; + if (size) + *size = sizeof(_sai__CertStoreEnumerateKeys); + ((_sai__CertStoreEnumerateKeys*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreEnumerateKeys[n]; + if (size) + *size = n * sizeof(_sai__CertStoreEnumerateKeys); + for (int i = 0; i < n; i++) + ((_sai__CertStoreEnumerateKeys*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreEnumerateKeys*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreEnumerateKeys(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreEnumerateKeys %p -> %p\n", q, p)); + *(_sai__CertStoreEnumerateKeys*)p = *(_sai__CertStoreEnumerateKeys*)q; +} + +void _sai__CertStoreAddKeyResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__CertStoreAddKeyResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__CertStoreAddKeyResponse*)this)->StatusCode); + soap_default_cstr__KeyPairHandleType(soap, &((_sai__CertStoreAddKeyResponse*)this)->KeyPairHandle); + /* transient soap skipped */ +} + +int _sai__CertStoreAddKeyResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreAddKeyResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreAddKeyResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreAddKeyResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreAddKeyResponse(struct soap *soap, const char *tag, int id, const _sai__CertStoreAddKeyResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreAddKeyResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CertStoreAddKeyResponse*)a)->StatusCode), ""); + soap_out_cstr__KeyPairHandleType(soap, "sai:KeyPairHandle", -1, &(((_sai__CertStoreAddKeyResponse*)a)->KeyPairHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreAddKeyResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreAddKeyResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreAddKeyResponse * SOAP_FMAC4 soap_get__sai__CertStoreAddKeyResponse(struct soap *soap, _sai__CertStoreAddKeyResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreAddKeyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreAddKeyResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreAddKeyResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreAddKeyResponse * SOAP_FMAC4 soap_in__sai__CertStoreAddKeyResponse(struct soap *soap, const char *tag, _sai__CertStoreAddKeyResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreAddKeyResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreAddKeyResponse, sizeof(_sai__CertStoreAddKeyResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreAddKeyResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreAddKeyResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_KeyPairHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CertStoreAddKeyResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_KeyPairHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cstr__KeyPairHandleType(soap, "sai:KeyPairHandle", &(((_sai__CertStoreAddKeyResponse*)a)->KeyPairHandle), "cstr:KeyPairHandleType")) + { soap_flag_KeyPairHandle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_KeyPairHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreAddKeyResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreAddKeyResponse, 0, sizeof(_sai__CertStoreAddKeyResponse), 0, soap_copy__sai__CertStoreAddKeyResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreAddKeyResponse * SOAP_FMAC6 soap_new__sai__CertStoreAddKeyResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreAddKeyResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreAddKeyResponse(struct soap *soap, _sai__CertStoreAddKeyResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreAddKeyResponse * SOAP_FMAC4 soap_instantiate__sai__CertStoreAddKeyResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreAddKeyResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreAddKeyResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreAddKeyResponse; + if (size) + *size = sizeof(_sai__CertStoreAddKeyResponse); + ((_sai__CertStoreAddKeyResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreAddKeyResponse[n]; + if (size) + *size = n * sizeof(_sai__CertStoreAddKeyResponse); + for (int i = 0; i < n; i++) + ((_sai__CertStoreAddKeyResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreAddKeyResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreAddKeyResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreAddKeyResponse %p -> %p\n", q, p)); + *(_sai__CertStoreAddKeyResponse*)p = *(_sai__CertStoreAddKeyResponse*)q; +} + +void _sai__CertStoreAddKey::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTocstr__KeyPairType(soap, &((_sai__CertStoreAddKey*)this)->KeyPair); + /* transient soap skipped */ +} + +void _sai__CertStoreAddKey::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__CertStoreAddKey*)this)->KeyPair = NULL; + /* transient soap skipped */ +} + +int _sai__CertStoreAddKey::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CertStoreAddKey); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CertStoreAddKey::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CertStoreAddKey(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CertStoreAddKey(struct soap *soap, const char *tag, int id, const _sai__CertStoreAddKey *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CertStoreAddKey), type); + soap_out_PointerTocstr__KeyPairType(soap, "sai:KeyPair", -1, &(((_sai__CertStoreAddKey*)a)->KeyPair), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CertStoreAddKey::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CertStoreAddKey(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CertStoreAddKey * SOAP_FMAC4 soap_get__sai__CertStoreAddKey(struct soap *soap, _sai__CertStoreAddKey *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CertStoreAddKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CertStoreAddKey::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CertStoreAddKey(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CertStoreAddKey * SOAP_FMAC4 soap_in__sai__CertStoreAddKey(struct soap *soap, const char *tag, _sai__CertStoreAddKey *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CertStoreAddKey *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CertStoreAddKey, sizeof(_sai__CertStoreAddKey), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CertStoreAddKey) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CertStoreAddKey *)a->soap_in(soap, tag, type); + } + } + short soap_flag_KeyPair1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_KeyPair1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTocstr__KeyPairType(soap, "sai:KeyPair", &(((_sai__CertStoreAddKey*)a)->KeyPair), "cstr:KeyPairType")) + { soap_flag_KeyPair1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_KeyPair1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CertStoreAddKey *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CertStoreAddKey, 0, sizeof(_sai__CertStoreAddKey), 0, soap_copy__sai__CertStoreAddKey); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CertStoreAddKey * SOAP_FMAC6 soap_new__sai__CertStoreAddKey(struct soap *soap, int n) +{ return soap_instantiate__sai__CertStoreAddKey(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CertStoreAddKey(struct soap *soap, _sai__CertStoreAddKey *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CertStoreAddKey * SOAP_FMAC4 soap_instantiate__sai__CertStoreAddKey(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CertStoreAddKey(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CertStoreAddKey, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CertStoreAddKey; + if (size) + *size = sizeof(_sai__CertStoreAddKey); + ((_sai__CertStoreAddKey*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CertStoreAddKey[n]; + if (size) + *size = n * sizeof(_sai__CertStoreAddKey); + for (int i = 0; i < n; i++) + ((_sai__CertStoreAddKey*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CertStoreAddKey*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CertStoreAddKey(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CertStoreAddKey %p -> %p\n", q, p)); + *(_sai__CertStoreAddKey*)p = *(_sai__CertStoreAddKey*)q; +} + +void _sai__GetGlobalPowerPolicyResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__GlobalPowerPolicyType(soap, &((_sai__GetGlobalPowerPolicyResponse*)this)->GlobalPowerPolicy); + /* transient soap skipped */ +} + +void _sai__GetGlobalPowerPolicyResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetGlobalPowerPolicyResponse*)this)->StatusCode); + ((_sai__GetGlobalPowerPolicyResponse*)this)->GlobalPowerPolicy = NULL; + /* transient soap skipped */ +} + +int _sai__GetGlobalPowerPolicyResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetGlobalPowerPolicyResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetGlobalPowerPolicyResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetGlobalPowerPolicyResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetGlobalPowerPolicyResponse(struct soap *soap, const char *tag, int id, const _sai__GetGlobalPowerPolicyResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetGlobalPowerPolicyResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetGlobalPowerPolicyResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__GlobalPowerPolicyType(soap, "sai:GlobalPowerPolicy", -1, &(((_sai__GetGlobalPowerPolicyResponse*)a)->GlobalPowerPolicy), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetGlobalPowerPolicyResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetGlobalPowerPolicyResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_get__sai__GetGlobalPowerPolicyResponse(struct soap *soap, _sai__GetGlobalPowerPolicyResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetGlobalPowerPolicyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetGlobalPowerPolicyResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetGlobalPowerPolicyResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_in__sai__GetGlobalPowerPolicyResponse(struct soap *soap, const char *tag, _sai__GetGlobalPowerPolicyResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetGlobalPowerPolicyResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetGlobalPowerPolicyResponse, sizeof(_sai__GetGlobalPowerPolicyResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetGlobalPowerPolicyResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetGlobalPowerPolicyResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_GlobalPowerPolicy1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetGlobalPowerPolicyResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_GlobalPowerPolicy1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__GlobalPowerPolicyType(soap, "sai:GlobalPowerPolicy", &(((_sai__GetGlobalPowerPolicyResponse*)a)->GlobalPowerPolicy), "sai:GlobalPowerPolicyType")) + { soap_flag_GlobalPowerPolicy1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_GlobalPowerPolicy1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetGlobalPowerPolicyResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetGlobalPowerPolicyResponse, 0, sizeof(_sai__GetGlobalPowerPolicyResponse), 0, soap_copy__sai__GetGlobalPowerPolicyResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetGlobalPowerPolicyResponse * SOAP_FMAC6 soap_new__sai__GetGlobalPowerPolicyResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetGlobalPowerPolicyResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetGlobalPowerPolicyResponse(struct soap *soap, _sai__GetGlobalPowerPolicyResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_instantiate__sai__GetGlobalPowerPolicyResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetGlobalPowerPolicyResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetGlobalPowerPolicyResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetGlobalPowerPolicyResponse; + if (size) + *size = sizeof(_sai__GetGlobalPowerPolicyResponse); + ((_sai__GetGlobalPowerPolicyResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetGlobalPowerPolicyResponse[n]; + if (size) + *size = n * sizeof(_sai__GetGlobalPowerPolicyResponse); + for (int i = 0; i < n; i++) + ((_sai__GetGlobalPowerPolicyResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetGlobalPowerPolicyResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetGlobalPowerPolicyResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetGlobalPowerPolicyResponse %p -> %p\n", q, p)); + *(_sai__GetGlobalPowerPolicyResponse*)p = *(_sai__GetGlobalPowerPolicyResponse*)q; +} + +void _sai__GetGlobalPowerPolicy::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetGlobalPowerPolicy::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetGlobalPowerPolicy::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetGlobalPowerPolicy); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetGlobalPowerPolicy::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetGlobalPowerPolicy(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetGlobalPowerPolicy(struct soap *soap, const char *tag, int id, const _sai__GetGlobalPowerPolicy *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetGlobalPowerPolicy), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetGlobalPowerPolicy::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetGlobalPowerPolicy(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_get__sai__GetGlobalPowerPolicy(struct soap *soap, _sai__GetGlobalPowerPolicy *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetGlobalPowerPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetGlobalPowerPolicy::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetGlobalPowerPolicy(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_in__sai__GetGlobalPowerPolicy(struct soap *soap, const char *tag, _sai__GetGlobalPowerPolicy *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetGlobalPowerPolicy *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetGlobalPowerPolicy, sizeof(_sai__GetGlobalPowerPolicy), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetGlobalPowerPolicy) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetGlobalPowerPolicy *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetGlobalPowerPolicy *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetGlobalPowerPolicy, 0, sizeof(_sai__GetGlobalPowerPolicy), 0, soap_copy__sai__GetGlobalPowerPolicy); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetGlobalPowerPolicy * SOAP_FMAC6 soap_new__sai__GetGlobalPowerPolicy(struct soap *soap, int n) +{ return soap_instantiate__sai__GetGlobalPowerPolicy(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetGlobalPowerPolicy(struct soap *soap, _sai__GetGlobalPowerPolicy *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_instantiate__sai__GetGlobalPowerPolicy(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetGlobalPowerPolicy(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetGlobalPowerPolicy, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetGlobalPowerPolicy; + if (size) + *size = sizeof(_sai__GetGlobalPowerPolicy); + ((_sai__GetGlobalPowerPolicy*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetGlobalPowerPolicy[n]; + if (size) + *size = n * sizeof(_sai__GetGlobalPowerPolicy); + for (int i = 0; i < n; i++) + ((_sai__GetGlobalPowerPolicy*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetGlobalPowerPolicy*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetGlobalPowerPolicy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetGlobalPowerPolicy %p -> %p\n", q, p)); + *(_sai__GetGlobalPowerPolicy*)p = *(_sai__GetGlobalPowerPolicy*)q; +} + +void _sai__SetGlobalPowerPolicyResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetGlobalPowerPolicyResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__SetGlobalPowerPolicyResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetGlobalPowerPolicyResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetGlobalPowerPolicyResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetGlobalPowerPolicyResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetGlobalPowerPolicyResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetGlobalPowerPolicyResponse(struct soap *soap, const char *tag, int id, const _sai__SetGlobalPowerPolicyResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetGlobalPowerPolicyResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetGlobalPowerPolicyResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetGlobalPowerPolicyResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetGlobalPowerPolicyResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_get__sai__SetGlobalPowerPolicyResponse(struct soap *soap, _sai__SetGlobalPowerPolicyResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetGlobalPowerPolicyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetGlobalPowerPolicyResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetGlobalPowerPolicyResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_in__sai__SetGlobalPowerPolicyResponse(struct soap *soap, const char *tag, _sai__SetGlobalPowerPolicyResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetGlobalPowerPolicyResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetGlobalPowerPolicyResponse, sizeof(_sai__SetGlobalPowerPolicyResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetGlobalPowerPolicyResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetGlobalPowerPolicyResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetGlobalPowerPolicyResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetGlobalPowerPolicyResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetGlobalPowerPolicyResponse, 0, sizeof(_sai__SetGlobalPowerPolicyResponse), 0, soap_copy__sai__SetGlobalPowerPolicyResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetGlobalPowerPolicyResponse * SOAP_FMAC6 soap_new__sai__SetGlobalPowerPolicyResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetGlobalPowerPolicyResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetGlobalPowerPolicyResponse(struct soap *soap, _sai__SetGlobalPowerPolicyResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse * SOAP_FMAC4 soap_instantiate__sai__SetGlobalPowerPolicyResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetGlobalPowerPolicyResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetGlobalPowerPolicyResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetGlobalPowerPolicyResponse; + if (size) + *size = sizeof(_sai__SetGlobalPowerPolicyResponse); + ((_sai__SetGlobalPowerPolicyResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetGlobalPowerPolicyResponse[n]; + if (size) + *size = n * sizeof(_sai__SetGlobalPowerPolicyResponse); + for (int i = 0; i < n; i++) + ((_sai__SetGlobalPowerPolicyResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetGlobalPowerPolicyResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetGlobalPowerPolicyResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetGlobalPowerPolicyResponse %p -> %p\n", q, p)); + *(_sai__SetGlobalPowerPolicyResponse*)p = *(_sai__SetGlobalPowerPolicyResponse*)q; +} + +void _sai__SetGlobalPowerPolicy::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__GlobalPowerPolicyType(soap, &((_sai__SetGlobalPowerPolicy*)this)->GlobalPowerPolicy); + /* transient soap skipped */ +} + +void _sai__SetGlobalPowerPolicy::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetGlobalPowerPolicy*)this)->GlobalPowerPolicy = NULL; + /* transient soap skipped */ +} + +int _sai__SetGlobalPowerPolicy::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetGlobalPowerPolicy); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetGlobalPowerPolicy::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetGlobalPowerPolicy(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetGlobalPowerPolicy(struct soap *soap, const char *tag, int id, const _sai__SetGlobalPowerPolicy *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetGlobalPowerPolicy), type); + soap_out_PointerTosai__GlobalPowerPolicyType(soap, "sai:GlobalPowerPolicy", -1, &(((_sai__SetGlobalPowerPolicy*)a)->GlobalPowerPolicy), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetGlobalPowerPolicy::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetGlobalPowerPolicy(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_get__sai__SetGlobalPowerPolicy(struct soap *soap, _sai__SetGlobalPowerPolicy *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetGlobalPowerPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetGlobalPowerPolicy::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetGlobalPowerPolicy(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_in__sai__SetGlobalPowerPolicy(struct soap *soap, const char *tag, _sai__SetGlobalPowerPolicy *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetGlobalPowerPolicy *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetGlobalPowerPolicy, sizeof(_sai__SetGlobalPowerPolicy), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetGlobalPowerPolicy) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetGlobalPowerPolicy *)a->soap_in(soap, tag, type); + } + } + short soap_flag_GlobalPowerPolicy1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_GlobalPowerPolicy1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__GlobalPowerPolicyType(soap, "sai:GlobalPowerPolicy", &(((_sai__SetGlobalPowerPolicy*)a)->GlobalPowerPolicy), "sai:GlobalPowerPolicyType")) + { soap_flag_GlobalPowerPolicy1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_GlobalPowerPolicy1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetGlobalPowerPolicy *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetGlobalPowerPolicy, 0, sizeof(_sai__SetGlobalPowerPolicy), 0, soap_copy__sai__SetGlobalPowerPolicy); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetGlobalPowerPolicy * SOAP_FMAC6 soap_new__sai__SetGlobalPowerPolicy(struct soap *soap, int n) +{ return soap_instantiate__sai__SetGlobalPowerPolicy(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetGlobalPowerPolicy(struct soap *soap, _sai__SetGlobalPowerPolicy *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_instantiate__sai__SetGlobalPowerPolicy(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetGlobalPowerPolicy(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetGlobalPowerPolicy, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetGlobalPowerPolicy; + if (size) + *size = sizeof(_sai__SetGlobalPowerPolicy); + ((_sai__SetGlobalPowerPolicy*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetGlobalPowerPolicy[n]; + if (size) + *size = n * sizeof(_sai__SetGlobalPowerPolicy); + for (int i = 0; i < n; i++) + ((_sai__SetGlobalPowerPolicy*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetGlobalPowerPolicy*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetGlobalPowerPolicy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetGlobalPowerPolicy %p -> %p\n", q, p)); + *(_sai__SetGlobalPowerPolicy*)p = *(_sai__SetGlobalPowerPolicy*)q; +} + +void _sai__SetActivePowerPackageResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetActivePowerPackageResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__SetActivePowerPackageResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetActivePowerPackageResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetActivePowerPackageResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetActivePowerPackageResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetActivePowerPackageResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetActivePowerPackageResponse(struct soap *soap, const char *tag, int id, const _sai__SetActivePowerPackageResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetActivePowerPackageResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetActivePowerPackageResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetActivePowerPackageResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetActivePowerPackageResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetActivePowerPackageResponse * SOAP_FMAC4 soap_get__sai__SetActivePowerPackageResponse(struct soap *soap, _sai__SetActivePowerPackageResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetActivePowerPackageResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetActivePowerPackageResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetActivePowerPackageResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetActivePowerPackageResponse * SOAP_FMAC4 soap_in__sai__SetActivePowerPackageResponse(struct soap *soap, const char *tag, _sai__SetActivePowerPackageResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetActivePowerPackageResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetActivePowerPackageResponse, sizeof(_sai__SetActivePowerPackageResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetActivePowerPackageResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetActivePowerPackageResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetActivePowerPackageResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetActivePowerPackageResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetActivePowerPackageResponse, 0, sizeof(_sai__SetActivePowerPackageResponse), 0, soap_copy__sai__SetActivePowerPackageResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetActivePowerPackageResponse * SOAP_FMAC6 soap_new__sai__SetActivePowerPackageResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetActivePowerPackageResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetActivePowerPackageResponse(struct soap *soap, _sai__SetActivePowerPackageResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetActivePowerPackageResponse * SOAP_FMAC4 soap_instantiate__sai__SetActivePowerPackageResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetActivePowerPackageResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetActivePowerPackageResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetActivePowerPackageResponse; + if (size) + *size = sizeof(_sai__SetActivePowerPackageResponse); + ((_sai__SetActivePowerPackageResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetActivePowerPackageResponse[n]; + if (size) + *size = n * sizeof(_sai__SetActivePowerPackageResponse); + for (int i = 0; i < n; i++) + ((_sai__SetActivePowerPackageResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetActivePowerPackageResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetActivePowerPackageResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetActivePowerPackageResponse %p -> %p\n", q, p)); + *(_sai__SetActivePowerPackageResponse*)p = *(_sai__SetActivePowerPackageResponse*)q; +} + +void _sai__SetActivePowerPackage::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_cmn__GuidBuf(soap, &((_sai__SetActivePowerPackage*)this)->PolicyGUID); + /* transient soap skipped */ +} + +void _sai__SetActivePowerPackage::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__GuidBuf(soap, &((_sai__SetActivePowerPackage*)this)->PolicyGUID); + /* transient soap skipped */ +} + +int _sai__SetActivePowerPackage::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetActivePowerPackage); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetActivePowerPackage::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetActivePowerPackage(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetActivePowerPackage(struct soap *soap, const char *tag, int id, const _sai__SetActivePowerPackage *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetActivePowerPackage), type); + soap_out_cmn__GuidBuf(soap, "sai:PolicyGUID", -1, &(((_sai__SetActivePowerPackage*)a)->PolicyGUID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetActivePowerPackage::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetActivePowerPackage(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetActivePowerPackage * SOAP_FMAC4 soap_get__sai__SetActivePowerPackage(struct soap *soap, _sai__SetActivePowerPackage *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetActivePowerPackage(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetActivePowerPackage::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetActivePowerPackage(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetActivePowerPackage * SOAP_FMAC4 soap_in__sai__SetActivePowerPackage(struct soap *soap, const char *tag, _sai__SetActivePowerPackage *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetActivePowerPackage *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetActivePowerPackage, sizeof(_sai__SetActivePowerPackage), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetActivePowerPackage) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetActivePowerPackage *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PolicyGUID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PolicyGUID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__GuidBuf(soap, "sai:PolicyGUID", &(((_sai__SetActivePowerPackage*)a)->PolicyGUID), "cmn:GuidBuf")) + { soap_flag_PolicyGUID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PolicyGUID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetActivePowerPackage *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetActivePowerPackage, 0, sizeof(_sai__SetActivePowerPackage), 0, soap_copy__sai__SetActivePowerPackage); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetActivePowerPackage * SOAP_FMAC6 soap_new__sai__SetActivePowerPackage(struct soap *soap, int n) +{ return soap_instantiate__sai__SetActivePowerPackage(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetActivePowerPackage(struct soap *soap, _sai__SetActivePowerPackage *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetActivePowerPackage * SOAP_FMAC4 soap_instantiate__sai__SetActivePowerPackage(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetActivePowerPackage(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetActivePowerPackage, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetActivePowerPackage; + if (size) + *size = sizeof(_sai__SetActivePowerPackage); + ((_sai__SetActivePowerPackage*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetActivePowerPackage[n]; + if (size) + *size = n * sizeof(_sai__SetActivePowerPackage); + for (int i = 0; i < n; i++) + ((_sai__SetActivePowerPackage*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetActivePowerPackage*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetActivePowerPackage(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetActivePowerPackage %p -> %p\n", q, p)); + *(_sai__SetActivePowerPackage*)p = *(_sai__SetActivePowerPackage*)q; +} + +void _sai__GetPowerPackageResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetPowerPackageResponse*)this)->PolicyDescriptor, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_sai__GetPowerPackageResponse*)this)->PolicyDescriptor); + /* transient soap skipped */ +} + +void _sai__GetPowerPackageResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetPowerPackageResponse*)this)->StatusCode); + soap_default_std__string(soap, &((_sai__GetPowerPackageResponse*)this)->PolicyDescriptor); + /* transient soap skipped */ +} + +int _sai__GetPowerPackageResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetPowerPackageResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetPowerPackageResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetPowerPackageResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPowerPackageResponse(struct soap *soap, const char *tag, int id, const _sai__GetPowerPackageResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetPowerPackageResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetPowerPackageResponse*)a)->StatusCode), ""); + soap_out_std__string(soap, "sai:PolicyDescriptor", -1, &(((_sai__GetPowerPackageResponse*)a)->PolicyDescriptor), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetPowerPackageResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetPowerPackageResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetPowerPackageResponse * SOAP_FMAC4 soap_get__sai__GetPowerPackageResponse(struct soap *soap, _sai__GetPowerPackageResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetPowerPackageResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetPowerPackageResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetPowerPackageResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetPowerPackageResponse * SOAP_FMAC4 soap_in__sai__GetPowerPackageResponse(struct soap *soap, const char *tag, _sai__GetPowerPackageResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetPowerPackageResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetPowerPackageResponse, sizeof(_sai__GetPowerPackageResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetPowerPackageResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetPowerPackageResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_PolicyDescriptor1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetPowerPackageResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_PolicyDescriptor1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "sai:PolicyDescriptor", &(((_sai__GetPowerPackageResponse*)a)->PolicyDescriptor), "xsd:string")) + { soap_flag_PolicyDescriptor1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_PolicyDescriptor1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetPowerPackageResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetPowerPackageResponse, 0, sizeof(_sai__GetPowerPackageResponse), 0, soap_copy__sai__GetPowerPackageResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetPowerPackageResponse * SOAP_FMAC6 soap_new__sai__GetPowerPackageResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetPowerPackageResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPowerPackageResponse(struct soap *soap, _sai__GetPowerPackageResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetPowerPackageResponse * SOAP_FMAC4 soap_instantiate__sai__GetPowerPackageResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetPowerPackageResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetPowerPackageResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetPowerPackageResponse; + if (size) + *size = sizeof(_sai__GetPowerPackageResponse); + ((_sai__GetPowerPackageResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetPowerPackageResponse[n]; + if (size) + *size = n * sizeof(_sai__GetPowerPackageResponse); + for (int i = 0; i < n; i++) + ((_sai__GetPowerPackageResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetPowerPackageResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPowerPackageResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetPowerPackageResponse %p -> %p\n", q, p)); + *(_sai__GetPowerPackageResponse*)p = *(_sai__GetPowerPackageResponse*)q; +} + +void _sai__GetPowerPackage::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_cmn__GuidBuf(soap, &((_sai__GetPowerPackage*)this)->PolicyGUID); + /* transient soap skipped */ +} + +void _sai__GetPowerPackage::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__GuidBuf(soap, &((_sai__GetPowerPackage*)this)->PolicyGUID); + /* transient soap skipped */ +} + +int _sai__GetPowerPackage::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetPowerPackage); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetPowerPackage::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetPowerPackage(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPowerPackage(struct soap *soap, const char *tag, int id, const _sai__GetPowerPackage *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetPowerPackage), type); + soap_out_cmn__GuidBuf(soap, "sai:PolicyGUID", -1, &(((_sai__GetPowerPackage*)a)->PolicyGUID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetPowerPackage::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetPowerPackage(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetPowerPackage * SOAP_FMAC4 soap_get__sai__GetPowerPackage(struct soap *soap, _sai__GetPowerPackage *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetPowerPackage(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetPowerPackage::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetPowerPackage(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetPowerPackage * SOAP_FMAC4 soap_in__sai__GetPowerPackage(struct soap *soap, const char *tag, _sai__GetPowerPackage *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetPowerPackage *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetPowerPackage, sizeof(_sai__GetPowerPackage), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetPowerPackage) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetPowerPackage *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PolicyGUID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PolicyGUID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__GuidBuf(soap, "sai:PolicyGUID", &(((_sai__GetPowerPackage*)a)->PolicyGUID), "cmn:GuidBuf")) + { soap_flag_PolicyGUID1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PolicyGUID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetPowerPackage *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetPowerPackage, 0, sizeof(_sai__GetPowerPackage), 0, soap_copy__sai__GetPowerPackage); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetPowerPackage * SOAP_FMAC6 soap_new__sai__GetPowerPackage(struct soap *soap, int n) +{ return soap_instantiate__sai__GetPowerPackage(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPowerPackage(struct soap *soap, _sai__GetPowerPackage *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetPowerPackage * SOAP_FMAC4 soap_instantiate__sai__GetPowerPackage(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetPowerPackage(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetPowerPackage, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetPowerPackage; + if (size) + *size = sizeof(_sai__GetPowerPackage); + ((_sai__GetPowerPackage*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetPowerPackage[n]; + if (size) + *size = n * sizeof(_sai__GetPowerPackage); + for (int i = 0; i < n; i++) + ((_sai__GetPowerPackage*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetPowerPackage*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPowerPackage(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetPowerPackage %p -> %p\n", q, p)); + *(_sai__GetPowerPackage*)p = *(_sai__GetPowerPackage*)q; +} + +void _sai__GetActivePowerPackageResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_cmn__GuidBuf(soap, &((_sai__GetActivePowerPackageResponse*)this)->PolicyGUID); + /* transient soap skipped */ +} + +void _sai__GetActivePowerPackageResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetActivePowerPackageResponse*)this)->StatusCode); + soap_default_cmn__GuidBuf(soap, &((_sai__GetActivePowerPackageResponse*)this)->PolicyGUID); + /* transient soap skipped */ +} + +int _sai__GetActivePowerPackageResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetActivePowerPackageResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetActivePowerPackageResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetActivePowerPackageResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetActivePowerPackageResponse(struct soap *soap, const char *tag, int id, const _sai__GetActivePowerPackageResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetActivePowerPackageResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetActivePowerPackageResponse*)a)->StatusCode), ""); + soap_out_cmn__GuidBuf(soap, "sai:PolicyGUID", -1, &(((_sai__GetActivePowerPackageResponse*)a)->PolicyGUID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetActivePowerPackageResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetActivePowerPackageResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetActivePowerPackageResponse * SOAP_FMAC4 soap_get__sai__GetActivePowerPackageResponse(struct soap *soap, _sai__GetActivePowerPackageResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetActivePowerPackageResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetActivePowerPackageResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetActivePowerPackageResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetActivePowerPackageResponse * SOAP_FMAC4 soap_in__sai__GetActivePowerPackageResponse(struct soap *soap, const char *tag, _sai__GetActivePowerPackageResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetActivePowerPackageResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetActivePowerPackageResponse, sizeof(_sai__GetActivePowerPackageResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetActivePowerPackageResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetActivePowerPackageResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_PolicyGUID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetActivePowerPackageResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_PolicyGUID1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__GuidBuf(soap, "sai:PolicyGUID", &(((_sai__GetActivePowerPackageResponse*)a)->PolicyGUID), "cmn:GuidBuf")) + { soap_flag_PolicyGUID1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_PolicyGUID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetActivePowerPackageResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetActivePowerPackageResponse, 0, sizeof(_sai__GetActivePowerPackageResponse), 0, soap_copy__sai__GetActivePowerPackageResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetActivePowerPackageResponse * SOAP_FMAC6 soap_new__sai__GetActivePowerPackageResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetActivePowerPackageResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetActivePowerPackageResponse(struct soap *soap, _sai__GetActivePowerPackageResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetActivePowerPackageResponse * SOAP_FMAC4 soap_instantiate__sai__GetActivePowerPackageResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetActivePowerPackageResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetActivePowerPackageResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetActivePowerPackageResponse; + if (size) + *size = sizeof(_sai__GetActivePowerPackageResponse); + ((_sai__GetActivePowerPackageResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetActivePowerPackageResponse[n]; + if (size) + *size = n * sizeof(_sai__GetActivePowerPackageResponse); + for (int i = 0; i < n; i++) + ((_sai__GetActivePowerPackageResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetActivePowerPackageResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetActivePowerPackageResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetActivePowerPackageResponse %p -> %p\n", q, p)); + *(_sai__GetActivePowerPackageResponse*)p = *(_sai__GetActivePowerPackageResponse*)q; +} + +void _sai__GetActivePowerPackage::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetActivePowerPackage::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetActivePowerPackage::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetActivePowerPackage); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetActivePowerPackage::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetActivePowerPackage(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetActivePowerPackage(struct soap *soap, const char *tag, int id, const _sai__GetActivePowerPackage *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetActivePowerPackage), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetActivePowerPackage::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetActivePowerPackage(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetActivePowerPackage * SOAP_FMAC4 soap_get__sai__GetActivePowerPackage(struct soap *soap, _sai__GetActivePowerPackage *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetActivePowerPackage(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetActivePowerPackage::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetActivePowerPackage(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetActivePowerPackage * SOAP_FMAC4 soap_in__sai__GetActivePowerPackage(struct soap *soap, const char *tag, _sai__GetActivePowerPackage *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetActivePowerPackage *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetActivePowerPackage, sizeof(_sai__GetActivePowerPackage), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetActivePowerPackage) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetActivePowerPackage *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetActivePowerPackage *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetActivePowerPackage, 0, sizeof(_sai__GetActivePowerPackage), 0, soap_copy__sai__GetActivePowerPackage); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetActivePowerPackage * SOAP_FMAC6 soap_new__sai__GetActivePowerPackage(struct soap *soap, int n) +{ return soap_instantiate__sai__GetActivePowerPackage(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetActivePowerPackage(struct soap *soap, _sai__GetActivePowerPackage *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetActivePowerPackage * SOAP_FMAC4 soap_instantiate__sai__GetActivePowerPackage(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetActivePowerPackage(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetActivePowerPackage, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetActivePowerPackage; + if (size) + *size = sizeof(_sai__GetActivePowerPackage); + ((_sai__GetActivePowerPackage*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetActivePowerPackage[n]; + if (size) + *size = n * sizeof(_sai__GetActivePowerPackage); + for (int i = 0; i < n; i++) + ((_sai__GetActivePowerPackage*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetActivePowerPackage*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetActivePowerPackage(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetActivePowerPackage %p -> %p\n", q, p)); + *(_sai__GetActivePowerPackage*)p = *(_sai__GetActivePowerPackage*)q; +} + +void _sai__EnumeratePowerPackagesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfcmn__GuidBuf(soap, &((_sai__EnumeratePowerPackagesResponse*)this)->PolicyGUID); + /* transient soap skipped */ +} + +void _sai__EnumeratePowerPackagesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__EnumeratePowerPackagesResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfcmn__GuidBuf(soap, &((_sai__EnumeratePowerPackagesResponse*)this)->PolicyGUID); + /* transient soap skipped */ +} + +int _sai__EnumeratePowerPackagesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnumeratePowerPackagesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnumeratePowerPackagesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnumeratePowerPackagesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumeratePowerPackagesResponse(struct soap *soap, const char *tag, int id, const _sai__EnumeratePowerPackagesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnumeratePowerPackagesResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__EnumeratePowerPackagesResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfcmn__GuidBuf(soap, "sai:PolicyGUID", -1, &(((_sai__EnumeratePowerPackagesResponse*)a)->PolicyGUID), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnumeratePowerPackagesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnumeratePowerPackagesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse * SOAP_FMAC4 soap_get__sai__EnumeratePowerPackagesResponse(struct soap *soap, _sai__EnumeratePowerPackagesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnumeratePowerPackagesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnumeratePowerPackagesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnumeratePowerPackagesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse * SOAP_FMAC4 soap_in__sai__EnumeratePowerPackagesResponse(struct soap *soap, const char *tag, _sai__EnumeratePowerPackagesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnumeratePowerPackagesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnumeratePowerPackagesResponse, sizeof(_sai__EnumeratePowerPackagesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnumeratePowerPackagesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnumeratePowerPackagesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__EnumeratePowerPackagesResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfcmn__GuidBuf(soap, "sai:PolicyGUID", &(((_sai__EnumeratePowerPackagesResponse*)a)->PolicyGUID), "cmn:GuidBuf")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnumeratePowerPackagesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnumeratePowerPackagesResponse, 0, sizeof(_sai__EnumeratePowerPackagesResponse), 0, soap_copy__sai__EnumeratePowerPackagesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnumeratePowerPackagesResponse * SOAP_FMAC6 soap_new__sai__EnumeratePowerPackagesResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__EnumeratePowerPackagesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumeratePowerPackagesResponse(struct soap *soap, _sai__EnumeratePowerPackagesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse * SOAP_FMAC4 soap_instantiate__sai__EnumeratePowerPackagesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnumeratePowerPackagesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnumeratePowerPackagesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnumeratePowerPackagesResponse; + if (size) + *size = sizeof(_sai__EnumeratePowerPackagesResponse); + ((_sai__EnumeratePowerPackagesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnumeratePowerPackagesResponse[n]; + if (size) + *size = n * sizeof(_sai__EnumeratePowerPackagesResponse); + for (int i = 0; i < n; i++) + ((_sai__EnumeratePowerPackagesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnumeratePowerPackagesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumeratePowerPackagesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnumeratePowerPackagesResponse %p -> %p\n", q, p)); + *(_sai__EnumeratePowerPackagesResponse*)p = *(_sai__EnumeratePowerPackagesResponse*)q; +} + +void _sai__EnumeratePowerPackages::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__EnumeratePowerPackages::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__EnumeratePowerPackages::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnumeratePowerPackages); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnumeratePowerPackages::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnumeratePowerPackages(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumeratePowerPackages(struct soap *soap, const char *tag, int id, const _sai__EnumeratePowerPackages *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnumeratePowerPackages), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnumeratePowerPackages::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnumeratePowerPackages(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnumeratePowerPackages * SOAP_FMAC4 soap_get__sai__EnumeratePowerPackages(struct soap *soap, _sai__EnumeratePowerPackages *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnumeratePowerPackages(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnumeratePowerPackages::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnumeratePowerPackages(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnumeratePowerPackages * SOAP_FMAC4 soap_in__sai__EnumeratePowerPackages(struct soap *soap, const char *tag, _sai__EnumeratePowerPackages *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnumeratePowerPackages *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnumeratePowerPackages, sizeof(_sai__EnumeratePowerPackages), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnumeratePowerPackages) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnumeratePowerPackages *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnumeratePowerPackages *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnumeratePowerPackages, 0, sizeof(_sai__EnumeratePowerPackages), 0, soap_copy__sai__EnumeratePowerPackages); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnumeratePowerPackages * SOAP_FMAC6 soap_new__sai__EnumeratePowerPackages(struct soap *soap, int n) +{ return soap_instantiate__sai__EnumeratePowerPackages(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumeratePowerPackages(struct soap *soap, _sai__EnumeratePowerPackages *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnumeratePowerPackages * SOAP_FMAC4 soap_instantiate__sai__EnumeratePowerPackages(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnumeratePowerPackages(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnumeratePowerPackages, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnumeratePowerPackages; + if (size) + *size = sizeof(_sai__EnumeratePowerPackages); + ((_sai__EnumeratePowerPackages*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnumeratePowerPackages[n]; + if (size) + *size = n * sizeof(_sai__EnumeratePowerPackages); + for (int i = 0; i < n; i++) + ((_sai__EnumeratePowerPackages*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnumeratePowerPackages*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumeratePowerPackages(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnumeratePowerPackages %p -> %p\n", q, p)); + *(_sai__EnumeratePowerPackages*)p = *(_sai__EnumeratePowerPackages*)q; +} + +void _sai__GetEnvironmentDetectionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__EnvironmentDetectionType(soap, &((_sai__GetEnvironmentDetectionResponse*)this)->Params); + /* transient soap skipped */ +} + +void _sai__GetEnvironmentDetectionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetEnvironmentDetectionResponse*)this)->StatusCode); + ((_sai__GetEnvironmentDetectionResponse*)this)->Params = NULL; + /* transient soap skipped */ +} + +int _sai__GetEnvironmentDetectionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetEnvironmentDetectionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetEnvironmentDetectionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetEnvironmentDetectionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetEnvironmentDetectionResponse(struct soap *soap, const char *tag, int id, const _sai__GetEnvironmentDetectionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetEnvironmentDetectionResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetEnvironmentDetectionResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__EnvironmentDetectionType(soap, "sai:Params", -1, &(((_sai__GetEnvironmentDetectionResponse*)a)->Params), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetEnvironmentDetectionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetEnvironmentDetectionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse * SOAP_FMAC4 soap_get__sai__GetEnvironmentDetectionResponse(struct soap *soap, _sai__GetEnvironmentDetectionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetEnvironmentDetectionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetEnvironmentDetectionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetEnvironmentDetectionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse * SOAP_FMAC4 soap_in__sai__GetEnvironmentDetectionResponse(struct soap *soap, const char *tag, _sai__GetEnvironmentDetectionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetEnvironmentDetectionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetEnvironmentDetectionResponse, sizeof(_sai__GetEnvironmentDetectionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetEnvironmentDetectionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetEnvironmentDetectionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Params1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetEnvironmentDetectionResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Params1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__EnvironmentDetectionType(soap, "sai:Params", &(((_sai__GetEnvironmentDetectionResponse*)a)->Params), "sai:EnvironmentDetectionType")) + { soap_flag_Params1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Params1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetEnvironmentDetectionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetEnvironmentDetectionResponse, 0, sizeof(_sai__GetEnvironmentDetectionResponse), 0, soap_copy__sai__GetEnvironmentDetectionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetEnvironmentDetectionResponse * SOAP_FMAC6 soap_new__sai__GetEnvironmentDetectionResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetEnvironmentDetectionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetEnvironmentDetectionResponse(struct soap *soap, _sai__GetEnvironmentDetectionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse * SOAP_FMAC4 soap_instantiate__sai__GetEnvironmentDetectionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetEnvironmentDetectionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetEnvironmentDetectionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetEnvironmentDetectionResponse; + if (size) + *size = sizeof(_sai__GetEnvironmentDetectionResponse); + ((_sai__GetEnvironmentDetectionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetEnvironmentDetectionResponse[n]; + if (size) + *size = n * sizeof(_sai__GetEnvironmentDetectionResponse); + for (int i = 0; i < n; i++) + ((_sai__GetEnvironmentDetectionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetEnvironmentDetectionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetEnvironmentDetectionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetEnvironmentDetectionResponse %p -> %p\n", q, p)); + *(_sai__GetEnvironmentDetectionResponse*)p = *(_sai__GetEnvironmentDetectionResponse*)q; +} + +void _sai__GetEnvironmentDetection::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetEnvironmentDetection::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetEnvironmentDetection::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetEnvironmentDetection); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetEnvironmentDetection::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetEnvironmentDetection(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetEnvironmentDetection(struct soap *soap, const char *tag, int id, const _sai__GetEnvironmentDetection *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetEnvironmentDetection), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetEnvironmentDetection::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetEnvironmentDetection(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetEnvironmentDetection * SOAP_FMAC4 soap_get__sai__GetEnvironmentDetection(struct soap *soap, _sai__GetEnvironmentDetection *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetEnvironmentDetection(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetEnvironmentDetection::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetEnvironmentDetection(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetEnvironmentDetection * SOAP_FMAC4 soap_in__sai__GetEnvironmentDetection(struct soap *soap, const char *tag, _sai__GetEnvironmentDetection *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetEnvironmentDetection *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetEnvironmentDetection, sizeof(_sai__GetEnvironmentDetection), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetEnvironmentDetection) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetEnvironmentDetection *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetEnvironmentDetection *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetEnvironmentDetection, 0, sizeof(_sai__GetEnvironmentDetection), 0, soap_copy__sai__GetEnvironmentDetection); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetEnvironmentDetection * SOAP_FMAC6 soap_new__sai__GetEnvironmentDetection(struct soap *soap, int n) +{ return soap_instantiate__sai__GetEnvironmentDetection(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetEnvironmentDetection(struct soap *soap, _sai__GetEnvironmentDetection *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetEnvironmentDetection * SOAP_FMAC4 soap_instantiate__sai__GetEnvironmentDetection(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetEnvironmentDetection(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetEnvironmentDetection, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetEnvironmentDetection; + if (size) + *size = sizeof(_sai__GetEnvironmentDetection); + ((_sai__GetEnvironmentDetection*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetEnvironmentDetection[n]; + if (size) + *size = n * sizeof(_sai__GetEnvironmentDetection); + for (int i = 0; i < n; i++) + ((_sai__GetEnvironmentDetection*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetEnvironmentDetection*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetEnvironmentDetection(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetEnvironmentDetection %p -> %p\n", q, p)); + *(_sai__GetEnvironmentDetection*)p = *(_sai__GetEnvironmentDetection*)q; +} + +void _sai__SetEnvironmentDetectionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetEnvironmentDetectionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__SetEnvironmentDetectionResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetEnvironmentDetectionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetEnvironmentDetectionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetEnvironmentDetectionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetEnvironmentDetectionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetEnvironmentDetectionResponse(struct soap *soap, const char *tag, int id, const _sai__SetEnvironmentDetectionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetEnvironmentDetectionResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetEnvironmentDetectionResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetEnvironmentDetectionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetEnvironmentDetectionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse * SOAP_FMAC4 soap_get__sai__SetEnvironmentDetectionResponse(struct soap *soap, _sai__SetEnvironmentDetectionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetEnvironmentDetectionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetEnvironmentDetectionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetEnvironmentDetectionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse * SOAP_FMAC4 soap_in__sai__SetEnvironmentDetectionResponse(struct soap *soap, const char *tag, _sai__SetEnvironmentDetectionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetEnvironmentDetectionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetEnvironmentDetectionResponse, sizeof(_sai__SetEnvironmentDetectionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetEnvironmentDetectionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetEnvironmentDetectionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetEnvironmentDetectionResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetEnvironmentDetectionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetEnvironmentDetectionResponse, 0, sizeof(_sai__SetEnvironmentDetectionResponse), 0, soap_copy__sai__SetEnvironmentDetectionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetEnvironmentDetectionResponse * SOAP_FMAC6 soap_new__sai__SetEnvironmentDetectionResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetEnvironmentDetectionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetEnvironmentDetectionResponse(struct soap *soap, _sai__SetEnvironmentDetectionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse * SOAP_FMAC4 soap_instantiate__sai__SetEnvironmentDetectionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetEnvironmentDetectionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetEnvironmentDetectionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetEnvironmentDetectionResponse; + if (size) + *size = sizeof(_sai__SetEnvironmentDetectionResponse); + ((_sai__SetEnvironmentDetectionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetEnvironmentDetectionResponse[n]; + if (size) + *size = n * sizeof(_sai__SetEnvironmentDetectionResponse); + for (int i = 0; i < n; i++) + ((_sai__SetEnvironmentDetectionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetEnvironmentDetectionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetEnvironmentDetectionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetEnvironmentDetectionResponse %p -> %p\n", q, p)); + *(_sai__SetEnvironmentDetectionResponse*)p = *(_sai__SetEnvironmentDetectionResponse*)q; +} + +void _sai__SetEnvironmentDetection::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__EnvironmentDetectionType(soap, &((_sai__SetEnvironmentDetection*)this)->Params); + /* transient soap skipped */ +} + +void _sai__SetEnvironmentDetection::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetEnvironmentDetection*)this)->Params = NULL; + /* transient soap skipped */ +} + +int _sai__SetEnvironmentDetection::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetEnvironmentDetection); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetEnvironmentDetection::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetEnvironmentDetection(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetEnvironmentDetection(struct soap *soap, const char *tag, int id, const _sai__SetEnvironmentDetection *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetEnvironmentDetection), type); + soap_out_PointerTosai__EnvironmentDetectionType(soap, "sai:Params", -1, &(((_sai__SetEnvironmentDetection*)a)->Params), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetEnvironmentDetection::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetEnvironmentDetection(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetEnvironmentDetection * SOAP_FMAC4 soap_get__sai__SetEnvironmentDetection(struct soap *soap, _sai__SetEnvironmentDetection *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetEnvironmentDetection(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetEnvironmentDetection::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetEnvironmentDetection(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetEnvironmentDetection * SOAP_FMAC4 soap_in__sai__SetEnvironmentDetection(struct soap *soap, const char *tag, _sai__SetEnvironmentDetection *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetEnvironmentDetection *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetEnvironmentDetection, sizeof(_sai__SetEnvironmentDetection), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetEnvironmentDetection) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetEnvironmentDetection *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Params1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Params1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__EnvironmentDetectionType(soap, "sai:Params", &(((_sai__SetEnvironmentDetection*)a)->Params), "sai:EnvironmentDetectionType")) + { soap_flag_Params1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Params1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetEnvironmentDetection *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetEnvironmentDetection, 0, sizeof(_sai__SetEnvironmentDetection), 0, soap_copy__sai__SetEnvironmentDetection); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetEnvironmentDetection * SOAP_FMAC6 soap_new__sai__SetEnvironmentDetection(struct soap *soap, int n) +{ return soap_instantiate__sai__SetEnvironmentDetection(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetEnvironmentDetection(struct soap *soap, _sai__SetEnvironmentDetection *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetEnvironmentDetection * SOAP_FMAC4 soap_instantiate__sai__SetEnvironmentDetection(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetEnvironmentDetection(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetEnvironmentDetection, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetEnvironmentDetection; + if (size) + *size = sizeof(_sai__SetEnvironmentDetection); + ((_sai__SetEnvironmentDetection*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetEnvironmentDetection[n]; + if (size) + *size = n * sizeof(_sai__SetEnvironmentDetection); + for (int i = 0; i < n; i++) + ((_sai__SetEnvironmentDetection*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetEnvironmentDetection*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetEnvironmentDetection(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetEnvironmentDetection %p -> %p\n", q, p)); + *(_sai__SetEnvironmentDetection*)p = *(_sai__SetEnvironmentDetection*)q; +} + +void _sai__SetRealmAuthOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetRealmAuthOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetRealmAuthOptionsResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetRealmAuthOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetRealmAuthOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetRealmAuthOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetRealmAuthOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetRealmAuthOptionsResponse(struct soap *soap, const char *tag, int id, const _sai__SetRealmAuthOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetRealmAuthOptionsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetRealmAuthOptionsResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetRealmAuthOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetRealmAuthOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse * SOAP_FMAC4 soap_get__sai__SetRealmAuthOptionsResponse(struct soap *soap, _sai__SetRealmAuthOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetRealmAuthOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetRealmAuthOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetRealmAuthOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse * SOAP_FMAC4 soap_in__sai__SetRealmAuthOptionsResponse(struct soap *soap, const char *tag, _sai__SetRealmAuthOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetRealmAuthOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetRealmAuthOptionsResponse, sizeof(_sai__SetRealmAuthOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetRealmAuthOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetRealmAuthOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetRealmAuthOptionsResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetRealmAuthOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetRealmAuthOptionsResponse, 0, sizeof(_sai__SetRealmAuthOptionsResponse), 0, soap_copy__sai__SetRealmAuthOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetRealmAuthOptionsResponse * SOAP_FMAC6 soap_new__sai__SetRealmAuthOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetRealmAuthOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetRealmAuthOptionsResponse(struct soap *soap, _sai__SetRealmAuthOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__SetRealmAuthOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetRealmAuthOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetRealmAuthOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetRealmAuthOptionsResponse; + if (size) + *size = sizeof(_sai__SetRealmAuthOptionsResponse); + ((_sai__SetRealmAuthOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetRealmAuthOptionsResponse[n]; + if (size) + *size = n * sizeof(_sai__SetRealmAuthOptionsResponse); + for (int i = 0; i < n; i++) + ((_sai__SetRealmAuthOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetRealmAuthOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetRealmAuthOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetRealmAuthOptionsResponse %p -> %p\n", q, p)); + *(_sai__SetRealmAuthOptionsResponse*)p = *(_sai__SetRealmAuthOptionsResponse*)q; +} + +void _sai__SetRealmAuthOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetRealmAuthOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__UserAclRealmType(soap, &((_sai__SetRealmAuthOptions*)this)->Realm); + soap_default_sai__HTTPAuthOptionType(soap, &((_sai__SetRealmAuthOptions*)this)->HTTPAuthOption); + /* transient soap skipped */ +} + +int _sai__SetRealmAuthOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetRealmAuthOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetRealmAuthOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetRealmAuthOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetRealmAuthOptions(struct soap *soap, const char *tag, int id, const _sai__SetRealmAuthOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetRealmAuthOptions), type); + soap_out_sai__UserAclRealmType(soap, "sai:Realm", -1, &(((_sai__SetRealmAuthOptions*)a)->Realm), ""); + soap_out_sai__HTTPAuthOptionType(soap, "sai:HTTPAuthOption", -1, &(((_sai__SetRealmAuthOptions*)a)->HTTPAuthOption), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetRealmAuthOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetRealmAuthOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetRealmAuthOptions * SOAP_FMAC4 soap_get__sai__SetRealmAuthOptions(struct soap *soap, _sai__SetRealmAuthOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetRealmAuthOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetRealmAuthOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetRealmAuthOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetRealmAuthOptions * SOAP_FMAC4 soap_in__sai__SetRealmAuthOptions(struct soap *soap, const char *tag, _sai__SetRealmAuthOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetRealmAuthOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetRealmAuthOptions, sizeof(_sai__SetRealmAuthOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetRealmAuthOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetRealmAuthOptions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Realm1 = 1, soap_flag_HTTPAuthOption1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Realm1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclRealmType(soap, "sai:Realm", &(((_sai__SetRealmAuthOptions*)a)->Realm), "sai:UserAclRealmType")) + { soap_flag_Realm1--; + continue; + } + if (soap_flag_HTTPAuthOption1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__HTTPAuthOptionType(soap, "sai:HTTPAuthOption", &(((_sai__SetRealmAuthOptions*)a)->HTTPAuthOption), "sai:HTTPAuthOptionType")) + { soap_flag_HTTPAuthOption1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Realm1 > 0 || soap_flag_HTTPAuthOption1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetRealmAuthOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetRealmAuthOptions, 0, sizeof(_sai__SetRealmAuthOptions), 0, soap_copy__sai__SetRealmAuthOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetRealmAuthOptions * SOAP_FMAC6 soap_new__sai__SetRealmAuthOptions(struct soap *soap, int n) +{ return soap_instantiate__sai__SetRealmAuthOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetRealmAuthOptions(struct soap *soap, _sai__SetRealmAuthOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetRealmAuthOptions * SOAP_FMAC4 soap_instantiate__sai__SetRealmAuthOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetRealmAuthOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetRealmAuthOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetRealmAuthOptions; + if (size) + *size = sizeof(_sai__SetRealmAuthOptions); + ((_sai__SetRealmAuthOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetRealmAuthOptions[n]; + if (size) + *size = n * sizeof(_sai__SetRealmAuthOptions); + for (int i = 0; i < n; i++) + ((_sai__SetRealmAuthOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetRealmAuthOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetRealmAuthOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetRealmAuthOptions %p -> %p\n", q, p)); + *(_sai__SetRealmAuthOptions*)p = *(_sai__SetRealmAuthOptions*)q; +} + +void _sai__GetRealmAuthOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetRealmAuthOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetRealmAuthOptionsResponse*)this)->StatusCode); + soap_default_sai__HTTPAuthOptionType(soap, &((_sai__GetRealmAuthOptionsResponse*)this)->HTTPAuthOption); + /* transient soap skipped */ +} + +int _sai__GetRealmAuthOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetRealmAuthOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetRealmAuthOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetRealmAuthOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetRealmAuthOptionsResponse(struct soap *soap, const char *tag, int id, const _sai__GetRealmAuthOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetRealmAuthOptionsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetRealmAuthOptionsResponse*)a)->StatusCode), ""); + soap_out_sai__HTTPAuthOptionType(soap, "sai:HTTPAuthOption", -1, &(((_sai__GetRealmAuthOptionsResponse*)a)->HTTPAuthOption), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetRealmAuthOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetRealmAuthOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse * SOAP_FMAC4 soap_get__sai__GetRealmAuthOptionsResponse(struct soap *soap, _sai__GetRealmAuthOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetRealmAuthOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetRealmAuthOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetRealmAuthOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse * SOAP_FMAC4 soap_in__sai__GetRealmAuthOptionsResponse(struct soap *soap, const char *tag, _sai__GetRealmAuthOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetRealmAuthOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetRealmAuthOptionsResponse, sizeof(_sai__GetRealmAuthOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetRealmAuthOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetRealmAuthOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_HTTPAuthOption1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetRealmAuthOptionsResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_HTTPAuthOption1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__HTTPAuthOptionType(soap, "sai:HTTPAuthOption", &(((_sai__GetRealmAuthOptionsResponse*)a)->HTTPAuthOption), "sai:HTTPAuthOptionType")) + { soap_flag_HTTPAuthOption1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_HTTPAuthOption1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetRealmAuthOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetRealmAuthOptionsResponse, 0, sizeof(_sai__GetRealmAuthOptionsResponse), 0, soap_copy__sai__GetRealmAuthOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetRealmAuthOptionsResponse * SOAP_FMAC6 soap_new__sai__GetRealmAuthOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetRealmAuthOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetRealmAuthOptionsResponse(struct soap *soap, _sai__GetRealmAuthOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__GetRealmAuthOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetRealmAuthOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetRealmAuthOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetRealmAuthOptionsResponse; + if (size) + *size = sizeof(_sai__GetRealmAuthOptionsResponse); + ((_sai__GetRealmAuthOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetRealmAuthOptionsResponse[n]; + if (size) + *size = n * sizeof(_sai__GetRealmAuthOptionsResponse); + for (int i = 0; i < n; i++) + ((_sai__GetRealmAuthOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetRealmAuthOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetRealmAuthOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetRealmAuthOptionsResponse %p -> %p\n", q, p)); + *(_sai__GetRealmAuthOptionsResponse*)p = *(_sai__GetRealmAuthOptionsResponse*)q; +} + +void _sai__GetRealmAuthOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetRealmAuthOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__UserAclRealmType(soap, &((_sai__GetRealmAuthOptions*)this)->Realm); + /* transient soap skipped */ +} + +int _sai__GetRealmAuthOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetRealmAuthOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetRealmAuthOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetRealmAuthOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetRealmAuthOptions(struct soap *soap, const char *tag, int id, const _sai__GetRealmAuthOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetRealmAuthOptions), type); + soap_out_sai__UserAclRealmType(soap, "sai:Realm", -1, &(((_sai__GetRealmAuthOptions*)a)->Realm), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetRealmAuthOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetRealmAuthOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetRealmAuthOptions * SOAP_FMAC4 soap_get__sai__GetRealmAuthOptions(struct soap *soap, _sai__GetRealmAuthOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetRealmAuthOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetRealmAuthOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetRealmAuthOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetRealmAuthOptions * SOAP_FMAC4 soap_in__sai__GetRealmAuthOptions(struct soap *soap, const char *tag, _sai__GetRealmAuthOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetRealmAuthOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetRealmAuthOptions, sizeof(_sai__GetRealmAuthOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetRealmAuthOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetRealmAuthOptions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Realm1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Realm1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclRealmType(soap, "sai:Realm", &(((_sai__GetRealmAuthOptions*)a)->Realm), "sai:UserAclRealmType")) + { soap_flag_Realm1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Realm1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetRealmAuthOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetRealmAuthOptions, 0, sizeof(_sai__GetRealmAuthOptions), 0, soap_copy__sai__GetRealmAuthOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetRealmAuthOptions * SOAP_FMAC6 soap_new__sai__GetRealmAuthOptions(struct soap *soap, int n) +{ return soap_instantiate__sai__GetRealmAuthOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetRealmAuthOptions(struct soap *soap, _sai__GetRealmAuthOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetRealmAuthOptions * SOAP_FMAC4 soap_instantiate__sai__GetRealmAuthOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetRealmAuthOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetRealmAuthOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetRealmAuthOptions; + if (size) + *size = sizeof(_sai__GetRealmAuthOptions); + ((_sai__GetRealmAuthOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetRealmAuthOptions[n]; + if (size) + *size = n * sizeof(_sai__GetRealmAuthOptions); + for (int i = 0; i < n; i++) + ((_sai__GetRealmAuthOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetRealmAuthOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetRealmAuthOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetRealmAuthOptions %p -> %p\n", q, p)); + *(_sai__GetRealmAuthOptions*)p = *(_sai__GetRealmAuthOptions*)q; +} + +void _sai__ExtendProvisioningPeriodResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__ExtendProvisioningPeriodResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__ExtendProvisioningPeriodResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__ExtendProvisioningPeriodResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__ExtendProvisioningPeriodResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__ExtendProvisioningPeriodResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__ExtendProvisioningPeriodResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__ExtendProvisioningPeriodResponse(struct soap *soap, const char *tag, int id, const _sai__ExtendProvisioningPeriodResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__ExtendProvisioningPeriodResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__ExtendProvisioningPeriodResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__ExtendProvisioningPeriodResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__ExtendProvisioningPeriodResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse * SOAP_FMAC4 soap_get__sai__ExtendProvisioningPeriodResponse(struct soap *soap, _sai__ExtendProvisioningPeriodResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__ExtendProvisioningPeriodResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__ExtendProvisioningPeriodResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__ExtendProvisioningPeriodResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse * SOAP_FMAC4 soap_in__sai__ExtendProvisioningPeriodResponse(struct soap *soap, const char *tag, _sai__ExtendProvisioningPeriodResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__ExtendProvisioningPeriodResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__ExtendProvisioningPeriodResponse, sizeof(_sai__ExtendProvisioningPeriodResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__ExtendProvisioningPeriodResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__ExtendProvisioningPeriodResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__ExtendProvisioningPeriodResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__ExtendProvisioningPeriodResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__ExtendProvisioningPeriodResponse, 0, sizeof(_sai__ExtendProvisioningPeriodResponse), 0, soap_copy__sai__ExtendProvisioningPeriodResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__ExtendProvisioningPeriodResponse * SOAP_FMAC6 soap_new__sai__ExtendProvisioningPeriodResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__ExtendProvisioningPeriodResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__ExtendProvisioningPeriodResponse(struct soap *soap, _sai__ExtendProvisioningPeriodResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse * SOAP_FMAC4 soap_instantiate__sai__ExtendProvisioningPeriodResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__ExtendProvisioningPeriodResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__ExtendProvisioningPeriodResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__ExtendProvisioningPeriodResponse; + if (size) + *size = sizeof(_sai__ExtendProvisioningPeriodResponse); + ((_sai__ExtendProvisioningPeriodResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__ExtendProvisioningPeriodResponse[n]; + if (size) + *size = n * sizeof(_sai__ExtendProvisioningPeriodResponse); + for (int i = 0; i < n; i++) + ((_sai__ExtendProvisioningPeriodResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__ExtendProvisioningPeriodResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__ExtendProvisioningPeriodResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__ExtendProvisioningPeriodResponse %p -> %p\n", q, p)); + *(_sai__ExtendProvisioningPeriodResponse*)p = *(_sai__ExtendProvisioningPeriodResponse*)q; +} + +void _sai__ExtendProvisioningPeriod::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__ExtendProvisioningPeriod*)this)->Duration, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _sai__ExtendProvisioningPeriod::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_sai__ExtendProvisioningPeriod*)this)->Duration); + /* transient soap skipped */ +} + +int _sai__ExtendProvisioningPeriod::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__ExtendProvisioningPeriod); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__ExtendProvisioningPeriod::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__ExtendProvisioningPeriod(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__ExtendProvisioningPeriod(struct soap *soap, const char *tag, int id, const _sai__ExtendProvisioningPeriod *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__ExtendProvisioningPeriod), type); + soap_out_unsignedInt(soap, "sai:Duration", -1, &(((_sai__ExtendProvisioningPeriod*)a)->Duration), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__ExtendProvisioningPeriod::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__ExtendProvisioningPeriod(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_get__sai__ExtendProvisioningPeriod(struct soap *soap, _sai__ExtendProvisioningPeriod *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__ExtendProvisioningPeriod(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__ExtendProvisioningPeriod::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__ExtendProvisioningPeriod(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_in__sai__ExtendProvisioningPeriod(struct soap *soap, const char *tag, _sai__ExtendProvisioningPeriod *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__ExtendProvisioningPeriod *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__ExtendProvisioningPeriod, sizeof(_sai__ExtendProvisioningPeriod), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__ExtendProvisioningPeriod) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__ExtendProvisioningPeriod *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Duration1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Duration1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:Duration", &(((_sai__ExtendProvisioningPeriod*)a)->Duration), "xsd:unsignedInt")) + { soap_flag_Duration1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Duration1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__ExtendProvisioningPeriod *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__ExtendProvisioningPeriod, 0, sizeof(_sai__ExtendProvisioningPeriod), 0, soap_copy__sai__ExtendProvisioningPeriod); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__ExtendProvisioningPeriod * SOAP_FMAC6 soap_new__sai__ExtendProvisioningPeriod(struct soap *soap, int n) +{ return soap_instantiate__sai__ExtendProvisioningPeriod(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__ExtendProvisioningPeriod(struct soap *soap, _sai__ExtendProvisioningPeriod *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_instantiate__sai__ExtendProvisioningPeriod(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__ExtendProvisioningPeriod(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__ExtendProvisioningPeriod, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__ExtendProvisioningPeriod; + if (size) + *size = sizeof(_sai__ExtendProvisioningPeriod); + ((_sai__ExtendProvisioningPeriod*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__ExtendProvisioningPeriod[n]; + if (size) + *size = n * sizeof(_sai__ExtendProvisioningPeriod); + for (int i = 0; i < n; i++) + ((_sai__ExtendProvisioningPeriod*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__ExtendProvisioningPeriod*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__ExtendProvisioningPeriod(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__ExtendProvisioningPeriod %p -> %p\n", q, p)); + *(_sai__ExtendProvisioningPeriod*)p = *(_sai__ExtendProvisioningPeriod*)q; +} + +void _sai__GetProvisioningPIDResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetProvisioningPIDResponse*)this)->PID, SOAP_TYPE_xsd__base64Binary); + ((_sai__GetProvisioningPIDResponse*)this)->PID.soap_serialize(soap); + /* transient soap skipped */ +} + +void _sai__GetProvisioningPIDResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetProvisioningPIDResponse*)this)->StatusCode); + ((_sai__GetProvisioningPIDResponse*)this)->PID.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int _sai__GetProvisioningPIDResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetProvisioningPIDResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetProvisioningPIDResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetProvisioningPIDResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningPIDResponse(struct soap *soap, const char *tag, int id, const _sai__GetProvisioningPIDResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetProvisioningPIDResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetProvisioningPIDResponse*)a)->StatusCode), ""); + (((_sai__GetProvisioningPIDResponse*)a)->PID).soap_out(soap, "sai:PID", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetProvisioningPIDResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetProvisioningPIDResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetProvisioningPIDResponse * SOAP_FMAC4 soap_get__sai__GetProvisioningPIDResponse(struct soap *soap, _sai__GetProvisioningPIDResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetProvisioningPIDResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetProvisioningPIDResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetProvisioningPIDResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetProvisioningPIDResponse * SOAP_FMAC4 soap_in__sai__GetProvisioningPIDResponse(struct soap *soap, const char *tag, _sai__GetProvisioningPIDResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetProvisioningPIDResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetProvisioningPIDResponse, sizeof(_sai__GetProvisioningPIDResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetProvisioningPIDResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetProvisioningPIDResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_PID1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetProvisioningPIDResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_PID1 && soap->error == SOAP_TAG_MISMATCH) + if ((((_sai__GetProvisioningPIDResponse*)a)->PID).soap_in(soap, "sai:PID", "xsd:base64Binary")) + { soap_flag_PID1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_PID1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetProvisioningPIDResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetProvisioningPIDResponse, 0, sizeof(_sai__GetProvisioningPIDResponse), 0, soap_copy__sai__GetProvisioningPIDResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetProvisioningPIDResponse * SOAP_FMAC6 soap_new__sai__GetProvisioningPIDResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetProvisioningPIDResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningPIDResponse(struct soap *soap, _sai__GetProvisioningPIDResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetProvisioningPIDResponse * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningPIDResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetProvisioningPIDResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetProvisioningPIDResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetProvisioningPIDResponse; + if (size) + *size = sizeof(_sai__GetProvisioningPIDResponse); + ((_sai__GetProvisioningPIDResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetProvisioningPIDResponse[n]; + if (size) + *size = n * sizeof(_sai__GetProvisioningPIDResponse); + for (int i = 0; i < n; i++) + ((_sai__GetProvisioningPIDResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetProvisioningPIDResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningPIDResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetProvisioningPIDResponse %p -> %p\n", q, p)); + *(_sai__GetProvisioningPIDResponse*)p = *(_sai__GetProvisioningPIDResponse*)q; +} + +void _sai__GetProvisioningPID::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetProvisioningPID::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetProvisioningPID::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetProvisioningPID); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetProvisioningPID::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetProvisioningPID(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningPID(struct soap *soap, const char *tag, int id, const _sai__GetProvisioningPID *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetProvisioningPID), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetProvisioningPID::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetProvisioningPID(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetProvisioningPID * SOAP_FMAC4 soap_get__sai__GetProvisioningPID(struct soap *soap, _sai__GetProvisioningPID *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetProvisioningPID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetProvisioningPID::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetProvisioningPID(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetProvisioningPID * SOAP_FMAC4 soap_in__sai__GetProvisioningPID(struct soap *soap, const char *tag, _sai__GetProvisioningPID *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetProvisioningPID *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetProvisioningPID, sizeof(_sai__GetProvisioningPID), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetProvisioningPID) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetProvisioningPID *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetProvisioningPID *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetProvisioningPID, 0, sizeof(_sai__GetProvisioningPID), 0, soap_copy__sai__GetProvisioningPID); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetProvisioningPID * SOAP_FMAC6 soap_new__sai__GetProvisioningPID(struct soap *soap, int n) +{ return soap_instantiate__sai__GetProvisioningPID(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningPID(struct soap *soap, _sai__GetProvisioningPID *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetProvisioningPID * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningPID(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetProvisioningPID(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetProvisioningPID, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetProvisioningPID; + if (size) + *size = sizeof(_sai__GetProvisioningPID); + ((_sai__GetProvisioningPID*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetProvisioningPID[n]; + if (size) + *size = n * sizeof(_sai__GetProvisioningPID); + for (int i = 0; i < n; i++) + ((_sai__GetProvisioningPID*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetProvisioningPID*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningPID(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetProvisioningPID %p -> %p\n", q, p)); + *(_sai__GetProvisioningPID*)p = *(_sai__GetProvisioningPID*)q; +} + +void _sai__GetProvisioningAuditRecordResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__ProvisioningAuditRecordType(soap, &((_sai__GetProvisioningAuditRecordResponse*)this)->ProvisioningAuditRecord); + /* transient soap skipped */ +} + +void _sai__GetProvisioningAuditRecordResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetProvisioningAuditRecordResponse*)this)->StatusCode); + ((_sai__GetProvisioningAuditRecordResponse*)this)->ProvisioningAuditRecord = NULL; + /* transient soap skipped */ +} + +int _sai__GetProvisioningAuditRecordResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetProvisioningAuditRecordResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetProvisioningAuditRecordResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetProvisioningAuditRecordResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningAuditRecordResponse(struct soap *soap, const char *tag, int id, const _sai__GetProvisioningAuditRecordResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetProvisioningAuditRecordResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetProvisioningAuditRecordResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__ProvisioningAuditRecordType(soap, "sai:ProvisioningAuditRecord", -1, &(((_sai__GetProvisioningAuditRecordResponse*)a)->ProvisioningAuditRecord), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetProvisioningAuditRecordResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetProvisioningAuditRecordResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse * SOAP_FMAC4 soap_get__sai__GetProvisioningAuditRecordResponse(struct soap *soap, _sai__GetProvisioningAuditRecordResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetProvisioningAuditRecordResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetProvisioningAuditRecordResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetProvisioningAuditRecordResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse * SOAP_FMAC4 soap_in__sai__GetProvisioningAuditRecordResponse(struct soap *soap, const char *tag, _sai__GetProvisioningAuditRecordResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetProvisioningAuditRecordResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetProvisioningAuditRecordResponse, sizeof(_sai__GetProvisioningAuditRecordResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetProvisioningAuditRecordResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetProvisioningAuditRecordResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_ProvisioningAuditRecord1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetProvisioningAuditRecordResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_ProvisioningAuditRecord1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__ProvisioningAuditRecordType(soap, "sai:ProvisioningAuditRecord", &(((_sai__GetProvisioningAuditRecordResponse*)a)->ProvisioningAuditRecord), "sai:ProvisioningAuditRecordType")) + { soap_flag_ProvisioningAuditRecord1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_ProvisioningAuditRecord1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetProvisioningAuditRecordResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetProvisioningAuditRecordResponse, 0, sizeof(_sai__GetProvisioningAuditRecordResponse), 0, soap_copy__sai__GetProvisioningAuditRecordResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetProvisioningAuditRecordResponse * SOAP_FMAC6 soap_new__sai__GetProvisioningAuditRecordResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetProvisioningAuditRecordResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningAuditRecordResponse(struct soap *soap, _sai__GetProvisioningAuditRecordResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningAuditRecordResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetProvisioningAuditRecordResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetProvisioningAuditRecordResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetProvisioningAuditRecordResponse; + if (size) + *size = sizeof(_sai__GetProvisioningAuditRecordResponse); + ((_sai__GetProvisioningAuditRecordResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetProvisioningAuditRecordResponse[n]; + if (size) + *size = n * sizeof(_sai__GetProvisioningAuditRecordResponse); + for (int i = 0; i < n; i++) + ((_sai__GetProvisioningAuditRecordResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetProvisioningAuditRecordResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningAuditRecordResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetProvisioningAuditRecordResponse %p -> %p\n", q, p)); + *(_sai__GetProvisioningAuditRecordResponse*)p = *(_sai__GetProvisioningAuditRecordResponse*)q; +} + +void _sai__GetProvisioningAuditRecord::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetProvisioningAuditRecord::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetProvisioningAuditRecord::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetProvisioningAuditRecord); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetProvisioningAuditRecord::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetProvisioningAuditRecord(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningAuditRecord(struct soap *soap, const char *tag, int id, const _sai__GetProvisioningAuditRecord *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetProvisioningAuditRecord), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetProvisioningAuditRecord::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetProvisioningAuditRecord(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_get__sai__GetProvisioningAuditRecord(struct soap *soap, _sai__GetProvisioningAuditRecord *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetProvisioningAuditRecord(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetProvisioningAuditRecord::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetProvisioningAuditRecord(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_in__sai__GetProvisioningAuditRecord(struct soap *soap, const char *tag, _sai__GetProvisioningAuditRecord *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetProvisioningAuditRecord *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetProvisioningAuditRecord, sizeof(_sai__GetProvisioningAuditRecord), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetProvisioningAuditRecord) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetProvisioningAuditRecord *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetProvisioningAuditRecord *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetProvisioningAuditRecord, 0, sizeof(_sai__GetProvisioningAuditRecord), 0, soap_copy__sai__GetProvisioningAuditRecord); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetProvisioningAuditRecord * SOAP_FMAC6 soap_new__sai__GetProvisioningAuditRecord(struct soap *soap, int n) +{ return soap_instantiate__sai__GetProvisioningAuditRecord(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningAuditRecord(struct soap *soap, _sai__GetProvisioningAuditRecord *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningAuditRecord(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetProvisioningAuditRecord(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetProvisioningAuditRecord, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetProvisioningAuditRecord; + if (size) + *size = sizeof(_sai__GetProvisioningAuditRecord); + ((_sai__GetProvisioningAuditRecord*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetProvisioningAuditRecord[n]; + if (size) + *size = n * sizeof(_sai__GetProvisioningAuditRecord); + for (int i = 0; i < n; i++) + ((_sai__GetProvisioningAuditRecord*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetProvisioningAuditRecord*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningAuditRecord(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetProvisioningAuditRecord %p -> %p\n", q, p)); + *(_sai__GetProvisioningAuditRecord*)p = *(_sai__GetProvisioningAuditRecord*)q; +} + +void _sai__SetZeroTouchConfigurationModeResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetZeroTouchConfigurationModeResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__SetZeroTouchConfigurationModeResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetZeroTouchConfigurationModeResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetZeroTouchConfigurationModeResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetZeroTouchConfigurationModeResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, const char *tag, int id, const _sai__SetZeroTouchConfigurationModeResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetZeroTouchConfigurationModeResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetZeroTouchConfigurationModeResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetZeroTouchConfigurationModeResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_get__sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__SetZeroTouchConfigurationModeResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetZeroTouchConfigurationModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetZeroTouchConfigurationModeResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetZeroTouchConfigurationModeResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_in__sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, const char *tag, _sai__SetZeroTouchConfigurationModeResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetZeroTouchConfigurationModeResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse, sizeof(_sai__SetZeroTouchConfigurationModeResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetZeroTouchConfigurationModeResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetZeroTouchConfigurationModeResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetZeroTouchConfigurationModeResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse, 0, sizeof(_sai__SetZeroTouchConfigurationModeResponse), 0, soap_copy__sai__SetZeroTouchConfigurationModeResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetZeroTouchConfigurationModeResponse * SOAP_FMAC6 soap_new__sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetZeroTouchConfigurationModeResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__SetZeroTouchConfigurationModeResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_instantiate__sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetZeroTouchConfigurationModeResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetZeroTouchConfigurationModeResponse; + if (size) + *size = sizeof(_sai__SetZeroTouchConfigurationModeResponse); + ((_sai__SetZeroTouchConfigurationModeResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetZeroTouchConfigurationModeResponse[n]; + if (size) + *size = n * sizeof(_sai__SetZeroTouchConfigurationModeResponse); + for (int i = 0; i < n; i++) + ((_sai__SetZeroTouchConfigurationModeResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetZeroTouchConfigurationModeResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetZeroTouchConfigurationModeResponse %p -> %p\n", q, p)); + *(_sai__SetZeroTouchConfigurationModeResponse*)p = *(_sai__SetZeroTouchConfigurationModeResponse*)q; +} + +void _sai__SetZeroTouchConfigurationMode::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__SetZeroTouchConfigurationMode*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _sai__SetZeroTouchConfigurationMode::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((_sai__SetZeroTouchConfigurationMode*)this)->Enabled); + /* transient soap skipped */ +} + +int _sai__SetZeroTouchConfigurationMode::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetZeroTouchConfigurationMode); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetZeroTouchConfigurationMode::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetZeroTouchConfigurationMode(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetZeroTouchConfigurationMode(struct soap *soap, const char *tag, int id, const _sai__SetZeroTouchConfigurationMode *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetZeroTouchConfigurationMode), type); + soap_out_bool(soap, "sai:Enabled", -1, &(((_sai__SetZeroTouchConfigurationMode*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetZeroTouchConfigurationMode::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetZeroTouchConfigurationMode(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_get__sai__SetZeroTouchConfigurationMode(struct soap *soap, _sai__SetZeroTouchConfigurationMode *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetZeroTouchConfigurationMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetZeroTouchConfigurationMode::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetZeroTouchConfigurationMode(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_in__sai__SetZeroTouchConfigurationMode(struct soap *soap, const char *tag, _sai__SetZeroTouchConfigurationMode *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetZeroTouchConfigurationMode *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetZeroTouchConfigurationMode, sizeof(_sai__SetZeroTouchConfigurationMode), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetZeroTouchConfigurationMode) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetZeroTouchConfigurationMode *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:Enabled", &(((_sai__SetZeroTouchConfigurationMode*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetZeroTouchConfigurationMode *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetZeroTouchConfigurationMode, 0, sizeof(_sai__SetZeroTouchConfigurationMode), 0, soap_copy__sai__SetZeroTouchConfigurationMode); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetZeroTouchConfigurationMode * SOAP_FMAC6 soap_new__sai__SetZeroTouchConfigurationMode(struct soap *soap, int n) +{ return soap_instantiate__sai__SetZeroTouchConfigurationMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetZeroTouchConfigurationMode(struct soap *soap, _sai__SetZeroTouchConfigurationMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_instantiate__sai__SetZeroTouchConfigurationMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetZeroTouchConfigurationMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetZeroTouchConfigurationMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetZeroTouchConfigurationMode; + if (size) + *size = sizeof(_sai__SetZeroTouchConfigurationMode); + ((_sai__SetZeroTouchConfigurationMode*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetZeroTouchConfigurationMode[n]; + if (size) + *size = n * sizeof(_sai__SetZeroTouchConfigurationMode); + for (int i = 0; i < n; i++) + ((_sai__SetZeroTouchConfigurationMode*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetZeroTouchConfigurationMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetZeroTouchConfigurationMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetZeroTouchConfigurationMode %p -> %p\n", q, p)); + *(_sai__SetZeroTouchConfigurationMode*)p = *(_sai__SetZeroTouchConfigurationMode*)q; +} + +void _sai__GetZeroTouchConfigurationModeResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetZeroTouchConfigurationModeResponse*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _sai__GetZeroTouchConfigurationModeResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetZeroTouchConfigurationModeResponse*)this)->StatusCode); + soap_default_bool(soap, &((_sai__GetZeroTouchConfigurationModeResponse*)this)->Enabled); + /* transient soap skipped */ +} + +int _sai__GetZeroTouchConfigurationModeResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetZeroTouchConfigurationModeResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetZeroTouchConfigurationModeResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, const char *tag, int id, const _sai__GetZeroTouchConfigurationModeResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetZeroTouchConfigurationModeResponse*)a)->StatusCode), ""); + soap_out_bool(soap, "sai:Enabled", -1, &(((_sai__GetZeroTouchConfigurationModeResponse*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetZeroTouchConfigurationModeResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetZeroTouchConfigurationModeResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_get__sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__GetZeroTouchConfigurationModeResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetZeroTouchConfigurationModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetZeroTouchConfigurationModeResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetZeroTouchConfigurationModeResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_in__sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, const char *tag, _sai__GetZeroTouchConfigurationModeResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetZeroTouchConfigurationModeResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse, sizeof(_sai__GetZeroTouchConfigurationModeResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetZeroTouchConfigurationModeResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetZeroTouchConfigurationModeResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:Enabled", &(((_sai__GetZeroTouchConfigurationModeResponse*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetZeroTouchConfigurationModeResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse, 0, sizeof(_sai__GetZeroTouchConfigurationModeResponse), 0, soap_copy__sai__GetZeroTouchConfigurationModeResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetZeroTouchConfigurationModeResponse * SOAP_FMAC6 soap_new__sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetZeroTouchConfigurationModeResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__GetZeroTouchConfigurationModeResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse * SOAP_FMAC4 soap_instantiate__sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetZeroTouchConfigurationModeResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetZeroTouchConfigurationModeResponse; + if (size) + *size = sizeof(_sai__GetZeroTouchConfigurationModeResponse); + ((_sai__GetZeroTouchConfigurationModeResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetZeroTouchConfigurationModeResponse[n]; + if (size) + *size = n * sizeof(_sai__GetZeroTouchConfigurationModeResponse); + for (int i = 0; i < n; i++) + ((_sai__GetZeroTouchConfigurationModeResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetZeroTouchConfigurationModeResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetZeroTouchConfigurationModeResponse %p -> %p\n", q, p)); + *(_sai__GetZeroTouchConfigurationModeResponse*)p = *(_sai__GetZeroTouchConfigurationModeResponse*)q; +} + +void _sai__GetZeroTouchConfigurationMode::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetZeroTouchConfigurationMode::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetZeroTouchConfigurationMode::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetZeroTouchConfigurationMode); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetZeroTouchConfigurationMode::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetZeroTouchConfigurationMode(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetZeroTouchConfigurationMode(struct soap *soap, const char *tag, int id, const _sai__GetZeroTouchConfigurationMode *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetZeroTouchConfigurationMode), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetZeroTouchConfigurationMode::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetZeroTouchConfigurationMode(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_get__sai__GetZeroTouchConfigurationMode(struct soap *soap, _sai__GetZeroTouchConfigurationMode *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetZeroTouchConfigurationMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetZeroTouchConfigurationMode::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetZeroTouchConfigurationMode(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_in__sai__GetZeroTouchConfigurationMode(struct soap *soap, const char *tag, _sai__GetZeroTouchConfigurationMode *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetZeroTouchConfigurationMode *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetZeroTouchConfigurationMode, sizeof(_sai__GetZeroTouchConfigurationMode), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetZeroTouchConfigurationMode) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetZeroTouchConfigurationMode *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetZeroTouchConfigurationMode *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetZeroTouchConfigurationMode, 0, sizeof(_sai__GetZeroTouchConfigurationMode), 0, soap_copy__sai__GetZeroTouchConfigurationMode); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetZeroTouchConfigurationMode * SOAP_FMAC6 soap_new__sai__GetZeroTouchConfigurationMode(struct soap *soap, int n) +{ return soap_instantiate__sai__GetZeroTouchConfigurationMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetZeroTouchConfigurationMode(struct soap *soap, _sai__GetZeroTouchConfigurationMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_instantiate__sai__GetZeroTouchConfigurationMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetZeroTouchConfigurationMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetZeroTouchConfigurationMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetZeroTouchConfigurationMode; + if (size) + *size = sizeof(_sai__GetZeroTouchConfigurationMode); + ((_sai__GetZeroTouchConfigurationMode*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetZeroTouchConfigurationMode[n]; + if (size) + *size = n * sizeof(_sai__GetZeroTouchConfigurationMode); + for (int i = 0; i < n; i++) + ((_sai__GetZeroTouchConfigurationMode*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetZeroTouchConfigurationMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetZeroTouchConfigurationMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetZeroTouchConfigurationMode %p -> %p\n", q, p)); + *(_sai__GetZeroTouchConfigurationMode*)p = *(_sai__GetZeroTouchConfigurationMode*)q; +} + +void _sai__EnableCertificateHashEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__EnableCertificateHashEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__EnableCertificateHashEntryResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__EnableCertificateHashEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnableCertificateHashEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnableCertificateHashEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnableCertificateHashEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnableCertificateHashEntryResponse(struct soap *soap, const char *tag, int id, const _sai__EnableCertificateHashEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnableCertificateHashEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__EnableCertificateHashEntryResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnableCertificateHashEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnableCertificateHashEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse * SOAP_FMAC4 soap_get__sai__EnableCertificateHashEntryResponse(struct soap *soap, _sai__EnableCertificateHashEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnableCertificateHashEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnableCertificateHashEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnableCertificateHashEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse * SOAP_FMAC4 soap_in__sai__EnableCertificateHashEntryResponse(struct soap *soap, const char *tag, _sai__EnableCertificateHashEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnableCertificateHashEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnableCertificateHashEntryResponse, sizeof(_sai__EnableCertificateHashEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnableCertificateHashEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnableCertificateHashEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__EnableCertificateHashEntryResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnableCertificateHashEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnableCertificateHashEntryResponse, 0, sizeof(_sai__EnableCertificateHashEntryResponse), 0, soap_copy__sai__EnableCertificateHashEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnableCertificateHashEntryResponse * SOAP_FMAC6 soap_new__sai__EnableCertificateHashEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__EnableCertificateHashEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnableCertificateHashEntryResponse(struct soap *soap, _sai__EnableCertificateHashEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse * SOAP_FMAC4 soap_instantiate__sai__EnableCertificateHashEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnableCertificateHashEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnableCertificateHashEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnableCertificateHashEntryResponse; + if (size) + *size = sizeof(_sai__EnableCertificateHashEntryResponse); + ((_sai__EnableCertificateHashEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnableCertificateHashEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__EnableCertificateHashEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__EnableCertificateHashEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnableCertificateHashEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnableCertificateHashEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnableCertificateHashEntryResponse %p -> %p\n", q, p)); + *(_sai__EnableCertificateHashEntryResponse*)p = *(_sai__EnableCertificateHashEntryResponse*)q; +} + +void _sai__EnableCertificateHashEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__EnableCertificateHashEntry*)this)->Handle, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_sai__EnableCertificateHashEntry*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _sai__EnableCertificateHashEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_sai__EnableCertificateHashEntry*)this)->Handle); + soap_default_bool(soap, &((_sai__EnableCertificateHashEntry*)this)->Enabled); + /* transient soap skipped */ +} + +int _sai__EnableCertificateHashEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnableCertificateHashEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnableCertificateHashEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnableCertificateHashEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnableCertificateHashEntry(struct soap *soap, const char *tag, int id, const _sai__EnableCertificateHashEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnableCertificateHashEntry), type); + soap_out_unsignedInt(soap, "sai:Handle", -1, &(((_sai__EnableCertificateHashEntry*)a)->Handle), ""); + soap_out_bool(soap, "sai:Enabled", -1, &(((_sai__EnableCertificateHashEntry*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnableCertificateHashEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnableCertificateHashEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_get__sai__EnableCertificateHashEntry(struct soap *soap, _sai__EnableCertificateHashEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnableCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnableCertificateHashEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnableCertificateHashEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_in__sai__EnableCertificateHashEntry(struct soap *soap, const char *tag, _sai__EnableCertificateHashEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnableCertificateHashEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnableCertificateHashEntry, sizeof(_sai__EnableCertificateHashEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnableCertificateHashEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnableCertificateHashEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1, soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:Handle", &(((_sai__EnableCertificateHashEntry*)a)->Handle), "xsd:unsignedInt")) + { soap_flag_Handle1--; + continue; + } + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:Enabled", &(((_sai__EnableCertificateHashEntry*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0 || soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnableCertificateHashEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnableCertificateHashEntry, 0, sizeof(_sai__EnableCertificateHashEntry), 0, soap_copy__sai__EnableCertificateHashEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnableCertificateHashEntry * SOAP_FMAC6 soap_new__sai__EnableCertificateHashEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__EnableCertificateHashEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnableCertificateHashEntry(struct soap *soap, _sai__EnableCertificateHashEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_instantiate__sai__EnableCertificateHashEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnableCertificateHashEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnableCertificateHashEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnableCertificateHashEntry; + if (size) + *size = sizeof(_sai__EnableCertificateHashEntry); + ((_sai__EnableCertificateHashEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnableCertificateHashEntry[n]; + if (size) + *size = n * sizeof(_sai__EnableCertificateHashEntry); + for (int i = 0; i < n; i++) + ((_sai__EnableCertificateHashEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnableCertificateHashEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnableCertificateHashEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnableCertificateHashEntry %p -> %p\n", q, p)); + *(_sai__EnableCertificateHashEntry*)p = *(_sai__EnableCertificateHashEntry*)q; +} + +void _sai__DeleteCertificateHashEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__DeleteCertificateHashEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__DeleteCertificateHashEntryResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__DeleteCertificateHashEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__DeleteCertificateHashEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__DeleteCertificateHashEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__DeleteCertificateHashEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__DeleteCertificateHashEntryResponse(struct soap *soap, const char *tag, int id, const _sai__DeleteCertificateHashEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__DeleteCertificateHashEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__DeleteCertificateHashEntryResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__DeleteCertificateHashEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__DeleteCertificateHashEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse * SOAP_FMAC4 soap_get__sai__DeleteCertificateHashEntryResponse(struct soap *soap, _sai__DeleteCertificateHashEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__DeleteCertificateHashEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__DeleteCertificateHashEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__DeleteCertificateHashEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse * SOAP_FMAC4 soap_in__sai__DeleteCertificateHashEntryResponse(struct soap *soap, const char *tag, _sai__DeleteCertificateHashEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__DeleteCertificateHashEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__DeleteCertificateHashEntryResponse, sizeof(_sai__DeleteCertificateHashEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__DeleteCertificateHashEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__DeleteCertificateHashEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__DeleteCertificateHashEntryResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__DeleteCertificateHashEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__DeleteCertificateHashEntryResponse, 0, sizeof(_sai__DeleteCertificateHashEntryResponse), 0, soap_copy__sai__DeleteCertificateHashEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__DeleteCertificateHashEntryResponse * SOAP_FMAC6 soap_new__sai__DeleteCertificateHashEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__DeleteCertificateHashEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__DeleteCertificateHashEntryResponse(struct soap *soap, _sai__DeleteCertificateHashEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse * SOAP_FMAC4 soap_instantiate__sai__DeleteCertificateHashEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__DeleteCertificateHashEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__DeleteCertificateHashEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__DeleteCertificateHashEntryResponse; + if (size) + *size = sizeof(_sai__DeleteCertificateHashEntryResponse); + ((_sai__DeleteCertificateHashEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__DeleteCertificateHashEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__DeleteCertificateHashEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__DeleteCertificateHashEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__DeleteCertificateHashEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__DeleteCertificateHashEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__DeleteCertificateHashEntryResponse %p -> %p\n", q, p)); + *(_sai__DeleteCertificateHashEntryResponse*)p = *(_sai__DeleteCertificateHashEntryResponse*)q; +} + +void _sai__DeleteCertificateHashEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__DeleteCertificateHashEntry*)this)->Handle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _sai__DeleteCertificateHashEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_sai__DeleteCertificateHashEntry*)this)->Handle); + /* transient soap skipped */ +} + +int _sai__DeleteCertificateHashEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__DeleteCertificateHashEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__DeleteCertificateHashEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__DeleteCertificateHashEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__DeleteCertificateHashEntry(struct soap *soap, const char *tag, int id, const _sai__DeleteCertificateHashEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__DeleteCertificateHashEntry), type); + soap_out_unsignedInt(soap, "sai:Handle", -1, &(((_sai__DeleteCertificateHashEntry*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__DeleteCertificateHashEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__DeleteCertificateHashEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_get__sai__DeleteCertificateHashEntry(struct soap *soap, _sai__DeleteCertificateHashEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__DeleteCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__DeleteCertificateHashEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__DeleteCertificateHashEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_in__sai__DeleteCertificateHashEntry(struct soap *soap, const char *tag, _sai__DeleteCertificateHashEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__DeleteCertificateHashEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__DeleteCertificateHashEntry, sizeof(_sai__DeleteCertificateHashEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__DeleteCertificateHashEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__DeleteCertificateHashEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:Handle", &(((_sai__DeleteCertificateHashEntry*)a)->Handle), "xsd:unsignedInt")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__DeleteCertificateHashEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__DeleteCertificateHashEntry, 0, sizeof(_sai__DeleteCertificateHashEntry), 0, soap_copy__sai__DeleteCertificateHashEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__DeleteCertificateHashEntry * SOAP_FMAC6 soap_new__sai__DeleteCertificateHashEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__DeleteCertificateHashEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__DeleteCertificateHashEntry(struct soap *soap, _sai__DeleteCertificateHashEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_instantiate__sai__DeleteCertificateHashEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__DeleteCertificateHashEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__DeleteCertificateHashEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__DeleteCertificateHashEntry; + if (size) + *size = sizeof(_sai__DeleteCertificateHashEntry); + ((_sai__DeleteCertificateHashEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__DeleteCertificateHashEntry[n]; + if (size) + *size = n * sizeof(_sai__DeleteCertificateHashEntry); + for (int i = 0; i < n; i++) + ((_sai__DeleteCertificateHashEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__DeleteCertificateHashEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__DeleteCertificateHashEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__DeleteCertificateHashEntry %p -> %p\n", q, p)); + *(_sai__DeleteCertificateHashEntry*)p = *(_sai__DeleteCertificateHashEntry*)q; +} + +void _sai__AddCertificateHashEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__AddCertificateHashEntryResponse*)this)->Handle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _sai__AddCertificateHashEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__AddCertificateHashEntryResponse*)this)->StatusCode); + soap_default_unsignedInt(soap, &((_sai__AddCertificateHashEntryResponse*)this)->Handle); + /* transient soap skipped */ +} + +int _sai__AddCertificateHashEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__AddCertificateHashEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__AddCertificateHashEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__AddCertificateHashEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddCertificateHashEntryResponse(struct soap *soap, const char *tag, int id, const _sai__AddCertificateHashEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__AddCertificateHashEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__AddCertificateHashEntryResponse*)a)->StatusCode), ""); + soap_out_unsignedInt(soap, "sai:Handle", -1, &(((_sai__AddCertificateHashEntryResponse*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__AddCertificateHashEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__AddCertificateHashEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse * SOAP_FMAC4 soap_get__sai__AddCertificateHashEntryResponse(struct soap *soap, _sai__AddCertificateHashEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__AddCertificateHashEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__AddCertificateHashEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__AddCertificateHashEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse * SOAP_FMAC4 soap_in__sai__AddCertificateHashEntryResponse(struct soap *soap, const char *tag, _sai__AddCertificateHashEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__AddCertificateHashEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__AddCertificateHashEntryResponse, sizeof(_sai__AddCertificateHashEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__AddCertificateHashEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__AddCertificateHashEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__AddCertificateHashEntryResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:Handle", &(((_sai__AddCertificateHashEntryResponse*)a)->Handle), "xsd:unsignedInt")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__AddCertificateHashEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__AddCertificateHashEntryResponse, 0, sizeof(_sai__AddCertificateHashEntryResponse), 0, soap_copy__sai__AddCertificateHashEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__AddCertificateHashEntryResponse * SOAP_FMAC6 soap_new__sai__AddCertificateHashEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__AddCertificateHashEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddCertificateHashEntryResponse(struct soap *soap, _sai__AddCertificateHashEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse * SOAP_FMAC4 soap_instantiate__sai__AddCertificateHashEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__AddCertificateHashEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__AddCertificateHashEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__AddCertificateHashEntryResponse; + if (size) + *size = sizeof(_sai__AddCertificateHashEntryResponse); + ((_sai__AddCertificateHashEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__AddCertificateHashEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__AddCertificateHashEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__AddCertificateHashEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__AddCertificateHashEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddCertificateHashEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__AddCertificateHashEntryResponse %p -> %p\n", q, p)); + *(_sai__AddCertificateHashEntryResponse*)p = *(_sai__AddCertificateHashEntryResponse*)q; +} + +void _sai__AddCertificateHashEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertHashEntryType(soap, &((_sai__AddCertificateHashEntry*)this)->CertHashEntry); + /* transient soap skipped */ +} + +void _sai__AddCertificateHashEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__AddCertificateHashEntry*)this)->CertHashEntry = NULL; + /* transient soap skipped */ +} + +int _sai__AddCertificateHashEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__AddCertificateHashEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__AddCertificateHashEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__AddCertificateHashEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddCertificateHashEntry(struct soap *soap, const char *tag, int id, const _sai__AddCertificateHashEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__AddCertificateHashEntry), type); + soap_out_PointerTosai__CertHashEntryType(soap, "sai:CertHashEntry", -1, &(((_sai__AddCertificateHashEntry*)a)->CertHashEntry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__AddCertificateHashEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__AddCertificateHashEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__AddCertificateHashEntry * SOAP_FMAC4 soap_get__sai__AddCertificateHashEntry(struct soap *soap, _sai__AddCertificateHashEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__AddCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__AddCertificateHashEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__AddCertificateHashEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__AddCertificateHashEntry * SOAP_FMAC4 soap_in__sai__AddCertificateHashEntry(struct soap *soap, const char *tag, _sai__AddCertificateHashEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__AddCertificateHashEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__AddCertificateHashEntry, sizeof(_sai__AddCertificateHashEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__AddCertificateHashEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__AddCertificateHashEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CertHashEntry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CertHashEntry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertHashEntryType(soap, "sai:CertHashEntry", &(((_sai__AddCertificateHashEntry*)a)->CertHashEntry), "sai:CertHashEntryType")) + { soap_flag_CertHashEntry1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CertHashEntry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__AddCertificateHashEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__AddCertificateHashEntry, 0, sizeof(_sai__AddCertificateHashEntry), 0, soap_copy__sai__AddCertificateHashEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__AddCertificateHashEntry * SOAP_FMAC6 soap_new__sai__AddCertificateHashEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__AddCertificateHashEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddCertificateHashEntry(struct soap *soap, _sai__AddCertificateHashEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__AddCertificateHashEntry * SOAP_FMAC4 soap_instantiate__sai__AddCertificateHashEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__AddCertificateHashEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__AddCertificateHashEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__AddCertificateHashEntry; + if (size) + *size = sizeof(_sai__AddCertificateHashEntry); + ((_sai__AddCertificateHashEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__AddCertificateHashEntry[n]; + if (size) + *size = n * sizeof(_sai__AddCertificateHashEntry); + for (int i = 0; i < n; i++) + ((_sai__AddCertificateHashEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__AddCertificateHashEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddCertificateHashEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__AddCertificateHashEntry %p -> %p\n", q, p)); + *(_sai__AddCertificateHashEntry*)p = *(_sai__AddCertificateHashEntry*)q; +} + +void _sai__GetCertificateHashEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertHashEntryType(soap, &((_sai__GetCertificateHashEntryResponse*)this)->CertHashEntry); + /* transient soap skipped */ +} + +void _sai__GetCertificateHashEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetCertificateHashEntryResponse*)this)->StatusCode); + ((_sai__GetCertificateHashEntryResponse*)this)->CertHashEntry = NULL; + /* transient soap skipped */ +} + +int _sai__GetCertificateHashEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetCertificateHashEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetCertificateHashEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetCertificateHashEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCertificateHashEntryResponse(struct soap *soap, const char *tag, int id, const _sai__GetCertificateHashEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetCertificateHashEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetCertificateHashEntryResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__CertHashEntryType(soap, "sai:CertHashEntry", -1, &(((_sai__GetCertificateHashEntryResponse*)a)->CertHashEntry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetCertificateHashEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetCertificateHashEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse * SOAP_FMAC4 soap_get__sai__GetCertificateHashEntryResponse(struct soap *soap, _sai__GetCertificateHashEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetCertificateHashEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetCertificateHashEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetCertificateHashEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse * SOAP_FMAC4 soap_in__sai__GetCertificateHashEntryResponse(struct soap *soap, const char *tag, _sai__GetCertificateHashEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetCertificateHashEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetCertificateHashEntryResponse, sizeof(_sai__GetCertificateHashEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetCertificateHashEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetCertificateHashEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_CertHashEntry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetCertificateHashEntryResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_CertHashEntry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertHashEntryType(soap, "sai:CertHashEntry", &(((_sai__GetCertificateHashEntryResponse*)a)->CertHashEntry), "sai:CertHashEntryType")) + { soap_flag_CertHashEntry1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_CertHashEntry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetCertificateHashEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetCertificateHashEntryResponse, 0, sizeof(_sai__GetCertificateHashEntryResponse), 0, soap_copy__sai__GetCertificateHashEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetCertificateHashEntryResponse * SOAP_FMAC6 soap_new__sai__GetCertificateHashEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetCertificateHashEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCertificateHashEntryResponse(struct soap *soap, _sai__GetCertificateHashEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse * SOAP_FMAC4 soap_instantiate__sai__GetCertificateHashEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetCertificateHashEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetCertificateHashEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetCertificateHashEntryResponse; + if (size) + *size = sizeof(_sai__GetCertificateHashEntryResponse); + ((_sai__GetCertificateHashEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetCertificateHashEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__GetCertificateHashEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__GetCertificateHashEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetCertificateHashEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCertificateHashEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetCertificateHashEntryResponse %p -> %p\n", q, p)); + *(_sai__GetCertificateHashEntryResponse*)p = *(_sai__GetCertificateHashEntryResponse*)q; +} + +void _sai__GetCertificateHashEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetCertificateHashEntry*)this)->Handle, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _sai__GetCertificateHashEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_sai__GetCertificateHashEntry*)this)->Handle); + /* transient soap skipped */ +} + +int _sai__GetCertificateHashEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetCertificateHashEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetCertificateHashEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetCertificateHashEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCertificateHashEntry(struct soap *soap, const char *tag, int id, const _sai__GetCertificateHashEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetCertificateHashEntry), type); + soap_out_unsignedInt(soap, "sai:Handle", -1, &(((_sai__GetCertificateHashEntry*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetCertificateHashEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetCertificateHashEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetCertificateHashEntry * SOAP_FMAC4 soap_get__sai__GetCertificateHashEntry(struct soap *soap, _sai__GetCertificateHashEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetCertificateHashEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetCertificateHashEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetCertificateHashEntry * SOAP_FMAC4 soap_in__sai__GetCertificateHashEntry(struct soap *soap, const char *tag, _sai__GetCertificateHashEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetCertificateHashEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetCertificateHashEntry, sizeof(_sai__GetCertificateHashEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetCertificateHashEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetCertificateHashEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:Handle", &(((_sai__GetCertificateHashEntry*)a)->Handle), "xsd:unsignedInt")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetCertificateHashEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetCertificateHashEntry, 0, sizeof(_sai__GetCertificateHashEntry), 0, soap_copy__sai__GetCertificateHashEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetCertificateHashEntry * SOAP_FMAC6 soap_new__sai__GetCertificateHashEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__GetCertificateHashEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCertificateHashEntry(struct soap *soap, _sai__GetCertificateHashEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetCertificateHashEntry * SOAP_FMAC4 soap_instantiate__sai__GetCertificateHashEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetCertificateHashEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetCertificateHashEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetCertificateHashEntry; + if (size) + *size = sizeof(_sai__GetCertificateHashEntry); + ((_sai__GetCertificateHashEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetCertificateHashEntry[n]; + if (size) + *size = n * sizeof(_sai__GetCertificateHashEntry); + for (int i = 0; i < n; i++) + ((_sai__GetCertificateHashEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetCertificateHashEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCertificateHashEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetCertificateHashEntry %p -> %p\n", q, p)); + *(_sai__GetCertificateHashEntry*)p = *(_sai__GetCertificateHashEntry*)q; +} + +void _sai__EnumerateCertificateHashEntriesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfunsignedInt(soap, &((_sai__EnumerateCertificateHashEntriesResponse*)this)->Handles); + /* transient soap skipped */ +} + +void _sai__EnumerateCertificateHashEntriesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__EnumerateCertificateHashEntriesResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfunsignedInt(soap, &((_sai__EnumerateCertificateHashEntriesResponse*)this)->Handles); + /* transient soap skipped */ +} + +int _sai__EnumerateCertificateHashEntriesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnumerateCertificateHashEntriesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnumerateCertificateHashEntriesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, const char *tag, int id, const _sai__EnumerateCertificateHashEntriesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__EnumerateCertificateHashEntriesResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfunsignedInt(soap, "sai:Handles", -1, &(((_sai__EnumerateCertificateHashEntriesResponse*)a)->Handles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnumerateCertificateHashEntriesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnumerateCertificateHashEntriesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse * SOAP_FMAC4 soap_get__sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, _sai__EnumerateCertificateHashEntriesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnumerateCertificateHashEntriesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnumerateCertificateHashEntriesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnumerateCertificateHashEntriesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse * SOAP_FMAC4 soap_in__sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, const char *tag, _sai__EnumerateCertificateHashEntriesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnumerateCertificateHashEntriesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse, sizeof(_sai__EnumerateCertificateHashEntriesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnumerateCertificateHashEntriesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__EnumerateCertificateHashEntriesResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedInt(soap, "sai:Handles", &(((_sai__EnumerateCertificateHashEntriesResponse*)a)->Handles), "xsd:unsignedInt")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnumerateCertificateHashEntriesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse, 0, sizeof(_sai__EnumerateCertificateHashEntriesResponse), 0, soap_copy__sai__EnumerateCertificateHashEntriesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnumerateCertificateHashEntriesResponse * SOAP_FMAC6 soap_new__sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__EnumerateCertificateHashEntriesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, _sai__EnumerateCertificateHashEntriesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse * SOAP_FMAC4 soap_instantiate__sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnumerateCertificateHashEntriesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnumerateCertificateHashEntriesResponse; + if (size) + *size = sizeof(_sai__EnumerateCertificateHashEntriesResponse); + ((_sai__EnumerateCertificateHashEntriesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnumerateCertificateHashEntriesResponse[n]; + if (size) + *size = n * sizeof(_sai__EnumerateCertificateHashEntriesResponse); + for (int i = 0; i < n; i++) + ((_sai__EnumerateCertificateHashEntriesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnumerateCertificateHashEntriesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnumerateCertificateHashEntriesResponse %p -> %p\n", q, p)); + *(_sai__EnumerateCertificateHashEntriesResponse*)p = *(_sai__EnumerateCertificateHashEntriesResponse*)q; +} + +void _sai__EnumerateCertificateHashEntries::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__EnumerateCertificateHashEntries::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__EnumerateCertificateHashEntries::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnumerateCertificateHashEntries); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnumerateCertificateHashEntries::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnumerateCertificateHashEntries(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateCertificateHashEntries(struct soap *soap, const char *tag, int id, const _sai__EnumerateCertificateHashEntries *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnumerateCertificateHashEntries), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnumerateCertificateHashEntries::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnumerateCertificateHashEntries(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_get__sai__EnumerateCertificateHashEntries(struct soap *soap, _sai__EnumerateCertificateHashEntries *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnumerateCertificateHashEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnumerateCertificateHashEntries::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnumerateCertificateHashEntries(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_in__sai__EnumerateCertificateHashEntries(struct soap *soap, const char *tag, _sai__EnumerateCertificateHashEntries *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnumerateCertificateHashEntries *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnumerateCertificateHashEntries, sizeof(_sai__EnumerateCertificateHashEntries), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnumerateCertificateHashEntries) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnumerateCertificateHashEntries *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnumerateCertificateHashEntries *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnumerateCertificateHashEntries, 0, sizeof(_sai__EnumerateCertificateHashEntries), 0, soap_copy__sai__EnumerateCertificateHashEntries); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnumerateCertificateHashEntries * SOAP_FMAC6 soap_new__sai__EnumerateCertificateHashEntries(struct soap *soap, int n) +{ return soap_instantiate__sai__EnumerateCertificateHashEntries(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateCertificateHashEntries(struct soap *soap, _sai__EnumerateCertificateHashEntries *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_instantiate__sai__EnumerateCertificateHashEntries(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnumerateCertificateHashEntries(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnumerateCertificateHashEntries, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnumerateCertificateHashEntries; + if (size) + *size = sizeof(_sai__EnumerateCertificateHashEntries); + ((_sai__EnumerateCertificateHashEntries*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnumerateCertificateHashEntries[n]; + if (size) + *size = n * sizeof(_sai__EnumerateCertificateHashEntries); + for (int i = 0; i < n; i++) + ((_sai__EnumerateCertificateHashEntries*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnumerateCertificateHashEntries*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateCertificateHashEntries(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnumerateCertificateHashEntries %p -> %p\n", q, p)); + *(_sai__EnumerateCertificateHashEntries*)p = *(_sai__EnumerateCertificateHashEntries*)q; +} + +void _sai__GetProvisioningServerOTPResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetProvisioningServerOTPResponse*)this)->OTP, SOAP_TYPE_xsd__base64Binary); + ((_sai__GetProvisioningServerOTPResponse*)this)->OTP.soap_serialize(soap); + /* transient soap skipped */ +} + +void _sai__GetProvisioningServerOTPResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__GetProvisioningServerOTPResponse*)this)->StatusCode); + ((_sai__GetProvisioningServerOTPResponse*)this)->OTP.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int _sai__GetProvisioningServerOTPResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetProvisioningServerOTPResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetProvisioningServerOTPResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetProvisioningServerOTPResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningServerOTPResponse(struct soap *soap, const char *tag, int id, const _sai__GetProvisioningServerOTPResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetProvisioningServerOTPResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetProvisioningServerOTPResponse*)a)->StatusCode), ""); + (((_sai__GetProvisioningServerOTPResponse*)a)->OTP).soap_out(soap, "sai:OTP", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetProvisioningServerOTPResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetProvisioningServerOTPResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse * SOAP_FMAC4 soap_get__sai__GetProvisioningServerOTPResponse(struct soap *soap, _sai__GetProvisioningServerOTPResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetProvisioningServerOTPResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetProvisioningServerOTPResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetProvisioningServerOTPResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse * SOAP_FMAC4 soap_in__sai__GetProvisioningServerOTPResponse(struct soap *soap, const char *tag, _sai__GetProvisioningServerOTPResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetProvisioningServerOTPResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetProvisioningServerOTPResponse, sizeof(_sai__GetProvisioningServerOTPResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetProvisioningServerOTPResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetProvisioningServerOTPResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_OTP1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetProvisioningServerOTPResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_OTP1 && soap->error == SOAP_TAG_MISMATCH) + if ((((_sai__GetProvisioningServerOTPResponse*)a)->OTP).soap_in(soap, "sai:OTP", "xsd:base64Binary")) + { soap_flag_OTP1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_OTP1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetProvisioningServerOTPResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetProvisioningServerOTPResponse, 0, sizeof(_sai__GetProvisioningServerOTPResponse), 0, soap_copy__sai__GetProvisioningServerOTPResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetProvisioningServerOTPResponse * SOAP_FMAC6 soap_new__sai__GetProvisioningServerOTPResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetProvisioningServerOTPResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningServerOTPResponse(struct soap *soap, _sai__GetProvisioningServerOTPResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningServerOTPResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetProvisioningServerOTPResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetProvisioningServerOTPResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetProvisioningServerOTPResponse; + if (size) + *size = sizeof(_sai__GetProvisioningServerOTPResponse); + ((_sai__GetProvisioningServerOTPResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetProvisioningServerOTPResponse[n]; + if (size) + *size = n * sizeof(_sai__GetProvisioningServerOTPResponse); + for (int i = 0; i < n; i++) + ((_sai__GetProvisioningServerOTPResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetProvisioningServerOTPResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningServerOTPResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetProvisioningServerOTPResponse %p -> %p\n", q, p)); + *(_sai__GetProvisioningServerOTPResponse*)p = *(_sai__GetProvisioningServerOTPResponse*)q; +} + +void _sai__GetProvisioningServerOTP::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetProvisioningServerOTP::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetProvisioningServerOTP::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetProvisioningServerOTP); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetProvisioningServerOTP::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetProvisioningServerOTP(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningServerOTP(struct soap *soap, const char *tag, int id, const _sai__GetProvisioningServerOTP *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetProvisioningServerOTP), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetProvisioningServerOTP::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetProvisioningServerOTP(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_get__sai__GetProvisioningServerOTP(struct soap *soap, _sai__GetProvisioningServerOTP *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetProvisioningServerOTP(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetProvisioningServerOTP::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetProvisioningServerOTP(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_in__sai__GetProvisioningServerOTP(struct soap *soap, const char *tag, _sai__GetProvisioningServerOTP *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetProvisioningServerOTP *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetProvisioningServerOTP, sizeof(_sai__GetProvisioningServerOTP), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetProvisioningServerOTP) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetProvisioningServerOTP *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetProvisioningServerOTP *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetProvisioningServerOTP, 0, sizeof(_sai__GetProvisioningServerOTP), 0, soap_copy__sai__GetProvisioningServerOTP); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetProvisioningServerOTP * SOAP_FMAC6 soap_new__sai__GetProvisioningServerOTP(struct soap *soap, int n) +{ return soap_instantiate__sai__GetProvisioningServerOTP(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningServerOTP(struct soap *soap, _sai__GetProvisioningServerOTP *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningServerOTP(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetProvisioningServerOTP(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetProvisioningServerOTP, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetProvisioningServerOTP; + if (size) + *size = sizeof(_sai__GetProvisioningServerOTP); + ((_sai__GetProvisioningServerOTP*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetProvisioningServerOTP[n]; + if (size) + *size = n * sizeof(_sai__GetProvisioningServerOTP); + for (int i = 0; i < n; i++) + ((_sai__GetProvisioningServerOTP*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetProvisioningServerOTP*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningServerOTP(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetProvisioningServerOTP %p -> %p\n", q, p)); + *(_sai__GetProvisioningServerOTP*)p = *(_sai__GetProvisioningServerOTP*)q; +} + +void _sai__SetProvisioningServerOTPResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetProvisioningServerOTPResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__SetProvisioningServerOTPResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetProvisioningServerOTPResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetProvisioningServerOTPResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetProvisioningServerOTPResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetProvisioningServerOTPResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetProvisioningServerOTPResponse(struct soap *soap, const char *tag, int id, const _sai__SetProvisioningServerOTPResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetProvisioningServerOTPResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetProvisioningServerOTPResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetProvisioningServerOTPResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetProvisioningServerOTPResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse * SOAP_FMAC4 soap_get__sai__SetProvisioningServerOTPResponse(struct soap *soap, _sai__SetProvisioningServerOTPResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetProvisioningServerOTPResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetProvisioningServerOTPResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetProvisioningServerOTPResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse * SOAP_FMAC4 soap_in__sai__SetProvisioningServerOTPResponse(struct soap *soap, const char *tag, _sai__SetProvisioningServerOTPResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetProvisioningServerOTPResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetProvisioningServerOTPResponse, sizeof(_sai__SetProvisioningServerOTPResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetProvisioningServerOTPResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetProvisioningServerOTPResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetProvisioningServerOTPResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetProvisioningServerOTPResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetProvisioningServerOTPResponse, 0, sizeof(_sai__SetProvisioningServerOTPResponse), 0, soap_copy__sai__SetProvisioningServerOTPResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetProvisioningServerOTPResponse * SOAP_FMAC6 soap_new__sai__SetProvisioningServerOTPResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetProvisioningServerOTPResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetProvisioningServerOTPResponse(struct soap *soap, _sai__SetProvisioningServerOTPResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse * SOAP_FMAC4 soap_instantiate__sai__SetProvisioningServerOTPResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetProvisioningServerOTPResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetProvisioningServerOTPResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetProvisioningServerOTPResponse; + if (size) + *size = sizeof(_sai__SetProvisioningServerOTPResponse); + ((_sai__SetProvisioningServerOTPResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetProvisioningServerOTPResponse[n]; + if (size) + *size = n * sizeof(_sai__SetProvisioningServerOTPResponse); + for (int i = 0; i < n; i++) + ((_sai__SetProvisioningServerOTPResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetProvisioningServerOTPResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetProvisioningServerOTPResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetProvisioningServerOTPResponse %p -> %p\n", q, p)); + *(_sai__SetProvisioningServerOTPResponse*)p = *(_sai__SetProvisioningServerOTPResponse*)q; +} + +void _sai__SetProvisioningServerOTP::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__ProvisioningOTPType(soap, &((_sai__SetProvisioningServerOTP*)this)->OTP); + /* transient soap skipped */ +} + +void _sai__SetProvisioningServerOTP::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetProvisioningServerOTP*)this)->OTP = NULL; + /* transient soap skipped */ +} + +int _sai__SetProvisioningServerOTP::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetProvisioningServerOTP); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetProvisioningServerOTP::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetProvisioningServerOTP(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetProvisioningServerOTP(struct soap *soap, const char *tag, int id, const _sai__SetProvisioningServerOTP *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetProvisioningServerOTP), type); + soap_out_PointerTosai__ProvisioningOTPType(soap, "sai:OTP", -1, &(((_sai__SetProvisioningServerOTP*)a)->OTP), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetProvisioningServerOTP::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetProvisioningServerOTP(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_get__sai__SetProvisioningServerOTP(struct soap *soap, _sai__SetProvisioningServerOTP *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetProvisioningServerOTP(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetProvisioningServerOTP::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetProvisioningServerOTP(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_in__sai__SetProvisioningServerOTP(struct soap *soap, const char *tag, _sai__SetProvisioningServerOTP *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetProvisioningServerOTP *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetProvisioningServerOTP, sizeof(_sai__SetProvisioningServerOTP), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetProvisioningServerOTP) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetProvisioningServerOTP *)a->soap_in(soap, tag, type); + } + } + short soap_flag_OTP1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_OTP1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__ProvisioningOTPType(soap, "sai:OTP", &(((_sai__SetProvisioningServerOTP*)a)->OTP), "sai:ProvisioningOTPType")) + { soap_flag_OTP1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetProvisioningServerOTP *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetProvisioningServerOTP, 0, sizeof(_sai__SetProvisioningServerOTP), 0, soap_copy__sai__SetProvisioningServerOTP); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetProvisioningServerOTP * SOAP_FMAC6 soap_new__sai__SetProvisioningServerOTP(struct soap *soap, int n) +{ return soap_instantiate__sai__SetProvisioningServerOTP(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetProvisioningServerOTP(struct soap *soap, _sai__SetProvisioningServerOTP *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_instantiate__sai__SetProvisioningServerOTP(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetProvisioningServerOTP(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetProvisioningServerOTP, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetProvisioningServerOTP; + if (size) + *size = sizeof(_sai__SetProvisioningServerOTP); + ((_sai__SetProvisioningServerOTP*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetProvisioningServerOTP[n]; + if (size) + *size = n * sizeof(_sai__SetProvisioningServerOTP); + for (int i = 0; i < n; i++) + ((_sai__SetProvisioningServerOTP*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetProvisioningServerOTP*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetProvisioningServerOTP(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetProvisioningServerOTP %p -> %p\n", q, p)); + *(_sai__SetProvisioningServerOTP*)p = *(_sai__SetProvisioningServerOTP*)q; +} + +void _sai__SetMEBxPasswordResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetMEBxPasswordResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_cmn__PT_USCORESTATUS(soap, &((_sai__SetMEBxPasswordResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetMEBxPasswordResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetMEBxPasswordResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetMEBxPasswordResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetMEBxPasswordResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetMEBxPasswordResponse(struct soap *soap, const char *tag, int id, const _sai__SetMEBxPasswordResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetMEBxPasswordResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetMEBxPasswordResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetMEBxPasswordResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetMEBxPasswordResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetMEBxPasswordResponse * SOAP_FMAC4 soap_get__sai__SetMEBxPasswordResponse(struct soap *soap, _sai__SetMEBxPasswordResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetMEBxPasswordResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetMEBxPasswordResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetMEBxPasswordResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetMEBxPasswordResponse * SOAP_FMAC4 soap_in__sai__SetMEBxPasswordResponse(struct soap *soap, const char *tag, _sai__SetMEBxPasswordResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetMEBxPasswordResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetMEBxPasswordResponse, sizeof(_sai__SetMEBxPasswordResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetMEBxPasswordResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetMEBxPasswordResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_cmn__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetMEBxPasswordResponse*)a)->StatusCode), "cmn:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetMEBxPasswordResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetMEBxPasswordResponse, 0, sizeof(_sai__SetMEBxPasswordResponse), 0, soap_copy__sai__SetMEBxPasswordResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetMEBxPasswordResponse * SOAP_FMAC6 soap_new__sai__SetMEBxPasswordResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetMEBxPasswordResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetMEBxPasswordResponse(struct soap *soap, _sai__SetMEBxPasswordResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetMEBxPasswordResponse * SOAP_FMAC4 soap_instantiate__sai__SetMEBxPasswordResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetMEBxPasswordResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetMEBxPasswordResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetMEBxPasswordResponse; + if (size) + *size = sizeof(_sai__SetMEBxPasswordResponse); + ((_sai__SetMEBxPasswordResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetMEBxPasswordResponse[n]; + if (size) + *size = n * sizeof(_sai__SetMEBxPasswordResponse); + for (int i = 0; i < n; i++) + ((_sai__SetMEBxPasswordResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetMEBxPasswordResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetMEBxPasswordResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetMEBxPasswordResponse %p -> %p\n", q, p)); + *(_sai__SetMEBxPasswordResponse*)p = *(_sai__SetMEBxPasswordResponse*)q; +} + +void _sai__SetMEBxPassword::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_sai__MEBxPasswordType(soap, &((_sai__SetMEBxPassword*)this)->Password); + /* transient soap skipped */ +} + +void _sai__SetMEBxPassword::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__MEBxPasswordType(soap, &((_sai__SetMEBxPassword*)this)->Password); + /* transient soap skipped */ +} + +int _sai__SetMEBxPassword::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetMEBxPassword); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetMEBxPassword::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetMEBxPassword(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetMEBxPassword(struct soap *soap, const char *tag, int id, const _sai__SetMEBxPassword *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetMEBxPassword), type); + soap_out_sai__MEBxPasswordType(soap, "sai:Password", -1, &(((_sai__SetMEBxPassword*)a)->Password), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetMEBxPassword::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetMEBxPassword(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetMEBxPassword * SOAP_FMAC4 soap_get__sai__SetMEBxPassword(struct soap *soap, _sai__SetMEBxPassword *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetMEBxPassword(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetMEBxPassword::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetMEBxPassword(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetMEBxPassword * SOAP_FMAC4 soap_in__sai__SetMEBxPassword(struct soap *soap, const char *tag, _sai__SetMEBxPassword *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetMEBxPassword *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetMEBxPassword, sizeof(_sai__SetMEBxPassword), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetMEBxPassword) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetMEBxPassword *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Password1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Password1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_sai__MEBxPasswordType(soap, "sai:Password", &(((_sai__SetMEBxPassword*)a)->Password), "sai:MEBxPasswordType")) + { soap_flag_Password1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Password1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetMEBxPassword *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetMEBxPassword, 0, sizeof(_sai__SetMEBxPassword), 0, soap_copy__sai__SetMEBxPassword); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetMEBxPassword * SOAP_FMAC6 soap_new__sai__SetMEBxPassword(struct soap *soap, int n) +{ return soap_instantiate__sai__SetMEBxPassword(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetMEBxPassword(struct soap *soap, _sai__SetMEBxPassword *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetMEBxPassword * SOAP_FMAC4 soap_instantiate__sai__SetMEBxPassword(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetMEBxPassword(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetMEBxPassword, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetMEBxPassword; + if (size) + *size = sizeof(_sai__SetMEBxPassword); + ((_sai__SetMEBxPassword*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetMEBxPassword[n]; + if (size) + *size = n * sizeof(_sai__SetMEBxPassword); + for (int i = 0; i < n; i++) + ((_sai__SetMEBxPassword*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetMEBxPassword*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetMEBxPassword(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetMEBxPassword %p -> %p\n", q, p)); + *(_sai__SetMEBxPassword*)p = *(_sai__SetMEBxPassword*)q; +} + +void _sai__PartialUnprovisionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__PartialUnprovisionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__PartialUnprovisionResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__PartialUnprovisionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__PartialUnprovisionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__PartialUnprovisionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__PartialUnprovisionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__PartialUnprovisionResponse(struct soap *soap, const char *tag, int id, const _sai__PartialUnprovisionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__PartialUnprovisionResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__PartialUnprovisionResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__PartialUnprovisionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__PartialUnprovisionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__PartialUnprovisionResponse * SOAP_FMAC4 soap_get__sai__PartialUnprovisionResponse(struct soap *soap, _sai__PartialUnprovisionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__PartialUnprovisionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__PartialUnprovisionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__PartialUnprovisionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__PartialUnprovisionResponse * SOAP_FMAC4 soap_in__sai__PartialUnprovisionResponse(struct soap *soap, const char *tag, _sai__PartialUnprovisionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__PartialUnprovisionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__PartialUnprovisionResponse, sizeof(_sai__PartialUnprovisionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__PartialUnprovisionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__PartialUnprovisionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__PartialUnprovisionResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__PartialUnprovisionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__PartialUnprovisionResponse, 0, sizeof(_sai__PartialUnprovisionResponse), 0, soap_copy__sai__PartialUnprovisionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__PartialUnprovisionResponse * SOAP_FMAC6 soap_new__sai__PartialUnprovisionResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__PartialUnprovisionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__PartialUnprovisionResponse(struct soap *soap, _sai__PartialUnprovisionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__PartialUnprovisionResponse * SOAP_FMAC4 soap_instantiate__sai__PartialUnprovisionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__PartialUnprovisionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__PartialUnprovisionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__PartialUnprovisionResponse; + if (size) + *size = sizeof(_sai__PartialUnprovisionResponse); + ((_sai__PartialUnprovisionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__PartialUnprovisionResponse[n]; + if (size) + *size = n * sizeof(_sai__PartialUnprovisionResponse); + for (int i = 0; i < n; i++) + ((_sai__PartialUnprovisionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__PartialUnprovisionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__PartialUnprovisionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__PartialUnprovisionResponse %p -> %p\n", q, p)); + *(_sai__PartialUnprovisionResponse*)p = *(_sai__PartialUnprovisionResponse*)q; +} + +void _sai__PartialUnprovision::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__PartialUnprovision::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__PartialUnprovision::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__PartialUnprovision); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__PartialUnprovision::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__PartialUnprovision(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__PartialUnprovision(struct soap *soap, const char *tag, int id, const _sai__PartialUnprovision *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__PartialUnprovision), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__PartialUnprovision::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__PartialUnprovision(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__PartialUnprovision * SOAP_FMAC4 soap_get__sai__PartialUnprovision(struct soap *soap, _sai__PartialUnprovision *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__PartialUnprovision(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__PartialUnprovision::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__PartialUnprovision(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__PartialUnprovision * SOAP_FMAC4 soap_in__sai__PartialUnprovision(struct soap *soap, const char *tag, _sai__PartialUnprovision *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__PartialUnprovision *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__PartialUnprovision, sizeof(_sai__PartialUnprovision), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__PartialUnprovision) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__PartialUnprovision *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__PartialUnprovision *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__PartialUnprovision, 0, sizeof(_sai__PartialUnprovision), 0, soap_copy__sai__PartialUnprovision); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__PartialUnprovision * SOAP_FMAC6 soap_new__sai__PartialUnprovision(struct soap *soap, int n) +{ return soap_instantiate__sai__PartialUnprovision(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__PartialUnprovision(struct soap *soap, _sai__PartialUnprovision *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__PartialUnprovision * SOAP_FMAC4 soap_instantiate__sai__PartialUnprovision(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__PartialUnprovision(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__PartialUnprovision, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__PartialUnprovision; + if (size) + *size = sizeof(_sai__PartialUnprovision); + ((_sai__PartialUnprovision*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__PartialUnprovision[n]; + if (size) + *size = n * sizeof(_sai__PartialUnprovision); + for (int i = 0; i < n; i++) + ((_sai__PartialUnprovision*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__PartialUnprovision*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__PartialUnprovision(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__PartialUnprovision %p -> %p\n", q, p)); + *(_sai__PartialUnprovision*)p = *(_sai__PartialUnprovision*)q; +} + +void _sai__SetTLSPSKResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetTLSPSKResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetTLSPSKResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetTLSPSKResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTLSPSKResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTLSPSKResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTLSPSKResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSPSKResponse(struct soap *soap, const char *tag, int id, const _sai__SetTLSPSKResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTLSPSKResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetTLSPSKResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTLSPSKResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTLSPSKResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTLSPSKResponse * SOAP_FMAC4 soap_get__sai__SetTLSPSKResponse(struct soap *soap, _sai__SetTLSPSKResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTLSPSKResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTLSPSKResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTLSPSKResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTLSPSKResponse * SOAP_FMAC4 soap_in__sai__SetTLSPSKResponse(struct soap *soap, const char *tag, _sai__SetTLSPSKResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTLSPSKResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTLSPSKResponse, sizeof(_sai__SetTLSPSKResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTLSPSKResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTLSPSKResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetTLSPSKResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTLSPSKResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTLSPSKResponse, 0, sizeof(_sai__SetTLSPSKResponse), 0, soap_copy__sai__SetTLSPSKResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTLSPSKResponse * SOAP_FMAC6 soap_new__sai__SetTLSPSKResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTLSPSKResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSPSKResponse(struct soap *soap, _sai__SetTLSPSKResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTLSPSKResponse * SOAP_FMAC4 soap_instantiate__sai__SetTLSPSKResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTLSPSKResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTLSPSKResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTLSPSKResponse; + if (size) + *size = sizeof(_sai__SetTLSPSKResponse); + ((_sai__SetTLSPSKResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTLSPSKResponse[n]; + if (size) + *size = n * sizeof(_sai__SetTLSPSKResponse); + for (int i = 0; i < n; i++) + ((_sai__SetTLSPSKResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTLSPSKResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSPSKResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTLSPSKResponse %p -> %p\n", q, p)); + *(_sai__SetTLSPSKResponse*)p = *(_sai__SetTLSPSKResponse*)q; +} + +void _sai__SetTLSPSK::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__SetTLSPSK*)this)->PID, SOAP_TYPE_xsd__base64Binary); + ((_sai__SetTLSPSK*)this)->PID.soap_serialize(soap); + soap_embedded(soap, &((_sai__SetTLSPSK*)this)->PPS, SOAP_TYPE_xsd__base64Binary); + ((_sai__SetTLSPSK*)this)->PPS.soap_serialize(soap); + /* transient soap skipped */ +} + +void _sai__SetTLSPSK::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetTLSPSK*)this)->PID.xsd__base64Binary::soap_default(soap); + ((_sai__SetTLSPSK*)this)->PPS.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int _sai__SetTLSPSK::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTLSPSK); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTLSPSK::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTLSPSK(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSPSK(struct soap *soap, const char *tag, int id, const _sai__SetTLSPSK *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTLSPSK), type); + (((_sai__SetTLSPSK*)a)->PID).soap_out(soap, "sai:PID", -1, ""); + (((_sai__SetTLSPSK*)a)->PPS).soap_out(soap, "sai:PPS", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTLSPSK::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTLSPSK(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTLSPSK * SOAP_FMAC4 soap_get__sai__SetTLSPSK(struct soap *soap, _sai__SetTLSPSK *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTLSPSK(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTLSPSK::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTLSPSK(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTLSPSK * SOAP_FMAC4 soap_in__sai__SetTLSPSK(struct soap *soap, const char *tag, _sai__SetTLSPSK *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTLSPSK *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTLSPSK, sizeof(_sai__SetTLSPSK), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTLSPSK) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTLSPSK *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PID1 = 1, soap_flag_PPS1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PID1 && soap->error == SOAP_TAG_MISMATCH) + if ((((_sai__SetTLSPSK*)a)->PID).soap_in(soap, "sai:PID", "xsd:base64Binary")) + { soap_flag_PID1--; + continue; + } + if (soap_flag_PPS1 && soap->error == SOAP_TAG_MISMATCH) + if ((((_sai__SetTLSPSK*)a)->PPS).soap_in(soap, "sai:PPS", "xsd:base64Binary")) + { soap_flag_PPS1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_PID1 > 0 || soap_flag_PPS1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTLSPSK *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTLSPSK, 0, sizeof(_sai__SetTLSPSK), 0, soap_copy__sai__SetTLSPSK); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTLSPSK * SOAP_FMAC6 soap_new__sai__SetTLSPSK(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTLSPSK(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSPSK(struct soap *soap, _sai__SetTLSPSK *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTLSPSK * SOAP_FMAC4 soap_instantiate__sai__SetTLSPSK(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTLSPSK(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTLSPSK, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTLSPSK; + if (size) + *size = sizeof(_sai__SetTLSPSK); + ((_sai__SetTLSPSK*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTLSPSK[n]; + if (size) + *size = n * sizeof(_sai__SetTLSPSK); + for (int i = 0; i < n; i++) + ((_sai__SetTLSPSK*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTLSPSK*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSPSK(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTLSPSK %p -> %p\n", q, p)); + *(_sai__SetTLSPSK*)p = *(_sai__SetTLSPSK*)q; +} + +void _sai__GetPowerSavingOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetPowerSavingOptionsResponse*)this)->ActiveStateAC, SOAP_TYPE_sai__PowerStateType); + soap_serialize_PointerTosai__PowerStateType(soap, &((_sai__GetPowerSavingOptionsResponse*)this)->WakeOnNetAccessThresholdAC); + soap_serialize_PointerTounsignedShort(soap, &((_sai__GetPowerSavingOptionsResponse*)this)->WakeOnNetAccessSleepTimer); + /* transient soap skipped */ +} + +void _sai__GetPowerSavingOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetPowerSavingOptionsResponse*)this)->StatusCode); + soap_default_sai__PowerStateType(soap, &((_sai__GetPowerSavingOptionsResponse*)this)->ActiveStateAC); + ((_sai__GetPowerSavingOptionsResponse*)this)->WakeOnNetAccessThresholdAC = NULL; + ((_sai__GetPowerSavingOptionsResponse*)this)->WakeOnNetAccessSleepTimer = NULL; + /* transient soap skipped */ +} + +int _sai__GetPowerSavingOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetPowerSavingOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetPowerSavingOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetPowerSavingOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPowerSavingOptionsResponse(struct soap *soap, const char *tag, int id, const _sai__GetPowerSavingOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetPowerSavingOptionsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetPowerSavingOptionsResponse*)a)->StatusCode), ""); + soap_out_sai__PowerStateType(soap, "sai:ActiveStateAC", -1, &(((_sai__GetPowerSavingOptionsResponse*)a)->ActiveStateAC), ""); + soap_out_PointerTosai__PowerStateType(soap, "sai:WakeOnNetAccessThresholdAC", -1, &(((_sai__GetPowerSavingOptionsResponse*)a)->WakeOnNetAccessThresholdAC), ""); + soap_out_PointerTounsignedShort(soap, "sai:WakeOnNetAccessSleepTimer", -1, &(((_sai__GetPowerSavingOptionsResponse*)a)->WakeOnNetAccessSleepTimer), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetPowerSavingOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetPowerSavingOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse * SOAP_FMAC4 soap_get__sai__GetPowerSavingOptionsResponse(struct soap *soap, _sai__GetPowerSavingOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetPowerSavingOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetPowerSavingOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetPowerSavingOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse * SOAP_FMAC4 soap_in__sai__GetPowerSavingOptionsResponse(struct soap *soap, const char *tag, _sai__GetPowerSavingOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetPowerSavingOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetPowerSavingOptionsResponse, sizeof(_sai__GetPowerSavingOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetPowerSavingOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetPowerSavingOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_ActiveStateAC1 = 1, soap_flag_WakeOnNetAccessThresholdAC1 = 1, soap_flag_WakeOnNetAccessSleepTimer1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetPowerSavingOptionsResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_ActiveStateAC1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PowerStateType(soap, "sai:ActiveStateAC", &(((_sai__GetPowerSavingOptionsResponse*)a)->ActiveStateAC), "sai:PowerStateType")) + { soap_flag_ActiveStateAC1--; + continue; + } + if (soap_flag_WakeOnNetAccessThresholdAC1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__PowerStateType(soap, "sai:WakeOnNetAccessThresholdAC", &(((_sai__GetPowerSavingOptionsResponse*)a)->WakeOnNetAccessThresholdAC), "sai:PowerStateType")) + { soap_flag_WakeOnNetAccessThresholdAC1--; + continue; + } + if (soap_flag_WakeOnNetAccessSleepTimer1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedShort(soap, "sai:WakeOnNetAccessSleepTimer", &(((_sai__GetPowerSavingOptionsResponse*)a)->WakeOnNetAccessSleepTimer), "xsd:unsignedShort")) + { soap_flag_WakeOnNetAccessSleepTimer1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_ActiveStateAC1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetPowerSavingOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetPowerSavingOptionsResponse, 0, sizeof(_sai__GetPowerSavingOptionsResponse), 0, soap_copy__sai__GetPowerSavingOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetPowerSavingOptionsResponse * SOAP_FMAC6 soap_new__sai__GetPowerSavingOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetPowerSavingOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPowerSavingOptionsResponse(struct soap *soap, _sai__GetPowerSavingOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__GetPowerSavingOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetPowerSavingOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetPowerSavingOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetPowerSavingOptionsResponse; + if (size) + *size = sizeof(_sai__GetPowerSavingOptionsResponse); + ((_sai__GetPowerSavingOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetPowerSavingOptionsResponse[n]; + if (size) + *size = n * sizeof(_sai__GetPowerSavingOptionsResponse); + for (int i = 0; i < n; i++) + ((_sai__GetPowerSavingOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetPowerSavingOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPowerSavingOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetPowerSavingOptionsResponse %p -> %p\n", q, p)); + *(_sai__GetPowerSavingOptionsResponse*)p = *(_sai__GetPowerSavingOptionsResponse*)q; +} + +void _sai__GetPowerSavingOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetPowerSavingOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetPowerSavingOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetPowerSavingOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetPowerSavingOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetPowerSavingOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPowerSavingOptions(struct soap *soap, const char *tag, int id, const _sai__GetPowerSavingOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetPowerSavingOptions), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetPowerSavingOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetPowerSavingOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetPowerSavingOptions * SOAP_FMAC4 soap_get__sai__GetPowerSavingOptions(struct soap *soap, _sai__GetPowerSavingOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetPowerSavingOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetPowerSavingOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetPowerSavingOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetPowerSavingOptions * SOAP_FMAC4 soap_in__sai__GetPowerSavingOptions(struct soap *soap, const char *tag, _sai__GetPowerSavingOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetPowerSavingOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetPowerSavingOptions, sizeof(_sai__GetPowerSavingOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetPowerSavingOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetPowerSavingOptions *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetPowerSavingOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetPowerSavingOptions, 0, sizeof(_sai__GetPowerSavingOptions), 0, soap_copy__sai__GetPowerSavingOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetPowerSavingOptions * SOAP_FMAC6 soap_new__sai__GetPowerSavingOptions(struct soap *soap, int n) +{ return soap_instantiate__sai__GetPowerSavingOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPowerSavingOptions(struct soap *soap, _sai__GetPowerSavingOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetPowerSavingOptions * SOAP_FMAC4 soap_instantiate__sai__GetPowerSavingOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetPowerSavingOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetPowerSavingOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetPowerSavingOptions; + if (size) + *size = sizeof(_sai__GetPowerSavingOptions); + ((_sai__GetPowerSavingOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetPowerSavingOptions[n]; + if (size) + *size = n * sizeof(_sai__GetPowerSavingOptions); + for (int i = 0; i < n; i++) + ((_sai__GetPowerSavingOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetPowerSavingOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPowerSavingOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetPowerSavingOptions %p -> %p\n", q, p)); + *(_sai__GetPowerSavingOptions*)p = *(_sai__GetPowerSavingOptions*)q; +} + +void _sai__SetPowerSavingOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetPowerSavingOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetPowerSavingOptionsResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetPowerSavingOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetPowerSavingOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetPowerSavingOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetPowerSavingOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetPowerSavingOptionsResponse(struct soap *soap, const char *tag, int id, const _sai__SetPowerSavingOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetPowerSavingOptionsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetPowerSavingOptionsResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetPowerSavingOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetPowerSavingOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse * SOAP_FMAC4 soap_get__sai__SetPowerSavingOptionsResponse(struct soap *soap, _sai__SetPowerSavingOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetPowerSavingOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetPowerSavingOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetPowerSavingOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse * SOAP_FMAC4 soap_in__sai__SetPowerSavingOptionsResponse(struct soap *soap, const char *tag, _sai__SetPowerSavingOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetPowerSavingOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetPowerSavingOptionsResponse, sizeof(_sai__SetPowerSavingOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetPowerSavingOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetPowerSavingOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetPowerSavingOptionsResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetPowerSavingOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetPowerSavingOptionsResponse, 0, sizeof(_sai__SetPowerSavingOptionsResponse), 0, soap_copy__sai__SetPowerSavingOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetPowerSavingOptionsResponse * SOAP_FMAC6 soap_new__sai__SetPowerSavingOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetPowerSavingOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetPowerSavingOptionsResponse(struct soap *soap, _sai__SetPowerSavingOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__SetPowerSavingOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetPowerSavingOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetPowerSavingOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetPowerSavingOptionsResponse; + if (size) + *size = sizeof(_sai__SetPowerSavingOptionsResponse); + ((_sai__SetPowerSavingOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetPowerSavingOptionsResponse[n]; + if (size) + *size = n * sizeof(_sai__SetPowerSavingOptionsResponse); + for (int i = 0; i < n; i++) + ((_sai__SetPowerSavingOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetPowerSavingOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetPowerSavingOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetPowerSavingOptionsResponse %p -> %p\n", q, p)); + *(_sai__SetPowerSavingOptionsResponse*)p = *(_sai__SetPowerSavingOptionsResponse*)q; +} + +void _sai__SetPowerSavingOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__SetPowerSavingOptions*)this)->ActiveStateAC, SOAP_TYPE_sai__PowerStateType); + soap_serialize_PointerTosai__PowerStateType(soap, &((_sai__SetPowerSavingOptions*)this)->WakeOnNetAccessThresholdAC); + soap_serialize_PointerTounsignedShort(soap, &((_sai__SetPowerSavingOptions*)this)->WakeOnNetAccessSleepTimer); + /* transient soap skipped */ +} + +void _sai__SetPowerSavingOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PowerStateType(soap, &((_sai__SetPowerSavingOptions*)this)->ActiveStateAC); + ((_sai__SetPowerSavingOptions*)this)->WakeOnNetAccessThresholdAC = NULL; + ((_sai__SetPowerSavingOptions*)this)->WakeOnNetAccessSleepTimer = NULL; + /* transient soap skipped */ +} + +int _sai__SetPowerSavingOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetPowerSavingOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetPowerSavingOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetPowerSavingOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetPowerSavingOptions(struct soap *soap, const char *tag, int id, const _sai__SetPowerSavingOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetPowerSavingOptions), type); + soap_out_sai__PowerStateType(soap, "sai:ActiveStateAC", -1, &(((_sai__SetPowerSavingOptions*)a)->ActiveStateAC), ""); + soap_out_PointerTosai__PowerStateType(soap, "sai:WakeOnNetAccessThresholdAC", -1, &(((_sai__SetPowerSavingOptions*)a)->WakeOnNetAccessThresholdAC), ""); + soap_out_PointerTounsignedShort(soap, "sai:WakeOnNetAccessSleepTimer", -1, &(((_sai__SetPowerSavingOptions*)a)->WakeOnNetAccessSleepTimer), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetPowerSavingOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetPowerSavingOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetPowerSavingOptions * SOAP_FMAC4 soap_get__sai__SetPowerSavingOptions(struct soap *soap, _sai__SetPowerSavingOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetPowerSavingOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetPowerSavingOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetPowerSavingOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetPowerSavingOptions * SOAP_FMAC4 soap_in__sai__SetPowerSavingOptions(struct soap *soap, const char *tag, _sai__SetPowerSavingOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetPowerSavingOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetPowerSavingOptions, sizeof(_sai__SetPowerSavingOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetPowerSavingOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetPowerSavingOptions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ActiveStateAC1 = 1, soap_flag_WakeOnNetAccessThresholdAC1 = 1, soap_flag_WakeOnNetAccessSleepTimer1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ActiveStateAC1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PowerStateType(soap, "sai:ActiveStateAC", &(((_sai__SetPowerSavingOptions*)a)->ActiveStateAC), "sai:PowerStateType")) + { soap_flag_ActiveStateAC1--; + continue; + } + if (soap_flag_WakeOnNetAccessThresholdAC1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__PowerStateType(soap, "sai:WakeOnNetAccessThresholdAC", &(((_sai__SetPowerSavingOptions*)a)->WakeOnNetAccessThresholdAC), "sai:PowerStateType")) + { soap_flag_WakeOnNetAccessThresholdAC1--; + continue; + } + if (soap_flag_WakeOnNetAccessSleepTimer1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedShort(soap, "sai:WakeOnNetAccessSleepTimer", &(((_sai__SetPowerSavingOptions*)a)->WakeOnNetAccessSleepTimer), "xsd:unsignedShort")) + { soap_flag_WakeOnNetAccessSleepTimer1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ActiveStateAC1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetPowerSavingOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetPowerSavingOptions, 0, sizeof(_sai__SetPowerSavingOptions), 0, soap_copy__sai__SetPowerSavingOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetPowerSavingOptions * SOAP_FMAC6 soap_new__sai__SetPowerSavingOptions(struct soap *soap, int n) +{ return soap_instantiate__sai__SetPowerSavingOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetPowerSavingOptions(struct soap *soap, _sai__SetPowerSavingOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetPowerSavingOptions * SOAP_FMAC4 soap_instantiate__sai__SetPowerSavingOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetPowerSavingOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetPowerSavingOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetPowerSavingOptions; + if (size) + *size = sizeof(_sai__SetPowerSavingOptions); + ((_sai__SetPowerSavingOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetPowerSavingOptions[n]; + if (size) + *size = n * sizeof(_sai__SetPowerSavingOptions); + for (int i = 0; i < n; i++) + ((_sai__SetPowerSavingOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetPowerSavingOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetPowerSavingOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetPowerSavingOptions %p -> %p\n", q, p)); + *(_sai__SetPowerSavingOptions*)p = *(_sai__SetPowerSavingOptions*)q; +} + +void _sai__GetPkiCapabilitiesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__PkiCapsType(soap, &((_sai__GetPkiCapabilitiesResponse*)this)->PkiCaps); + /* transient soap skipped */ +} + +void _sai__GetPkiCapabilitiesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetPkiCapabilitiesResponse*)this)->StatusCode); + ((_sai__GetPkiCapabilitiesResponse*)this)->PkiCaps = NULL; + /* transient soap skipped */ +} + +int _sai__GetPkiCapabilitiesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetPkiCapabilitiesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetPkiCapabilitiesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetPkiCapabilitiesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPkiCapabilitiesResponse(struct soap *soap, const char *tag, int id, const _sai__GetPkiCapabilitiesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetPkiCapabilitiesResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetPkiCapabilitiesResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__PkiCapsType(soap, "sai:PkiCaps", -1, &(((_sai__GetPkiCapabilitiesResponse*)a)->PkiCaps), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetPkiCapabilitiesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetPkiCapabilitiesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse * SOAP_FMAC4 soap_get__sai__GetPkiCapabilitiesResponse(struct soap *soap, _sai__GetPkiCapabilitiesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetPkiCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetPkiCapabilitiesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetPkiCapabilitiesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse * SOAP_FMAC4 soap_in__sai__GetPkiCapabilitiesResponse(struct soap *soap, const char *tag, _sai__GetPkiCapabilitiesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetPkiCapabilitiesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetPkiCapabilitiesResponse, sizeof(_sai__GetPkiCapabilitiesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetPkiCapabilitiesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetPkiCapabilitiesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_PkiCaps1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetPkiCapabilitiesResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_PkiCaps1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__PkiCapsType(soap, "sai:PkiCaps", &(((_sai__GetPkiCapabilitiesResponse*)a)->PkiCaps), "sai:PkiCapsType")) + { soap_flag_PkiCaps1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_PkiCaps1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetPkiCapabilitiesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetPkiCapabilitiesResponse, 0, sizeof(_sai__GetPkiCapabilitiesResponse), 0, soap_copy__sai__GetPkiCapabilitiesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetPkiCapabilitiesResponse * SOAP_FMAC6 soap_new__sai__GetPkiCapabilitiesResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetPkiCapabilitiesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPkiCapabilitiesResponse(struct soap *soap, _sai__GetPkiCapabilitiesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse * SOAP_FMAC4 soap_instantiate__sai__GetPkiCapabilitiesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetPkiCapabilitiesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetPkiCapabilitiesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetPkiCapabilitiesResponse; + if (size) + *size = sizeof(_sai__GetPkiCapabilitiesResponse); + ((_sai__GetPkiCapabilitiesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetPkiCapabilitiesResponse[n]; + if (size) + *size = n * sizeof(_sai__GetPkiCapabilitiesResponse); + for (int i = 0; i < n; i++) + ((_sai__GetPkiCapabilitiesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetPkiCapabilitiesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPkiCapabilitiesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetPkiCapabilitiesResponse %p -> %p\n", q, p)); + *(_sai__GetPkiCapabilitiesResponse*)p = *(_sai__GetPkiCapabilitiesResponse*)q; +} + +void _sai__GetPkiCapabilities::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetPkiCapabilities::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetPkiCapabilities::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetPkiCapabilities); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetPkiCapabilities::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetPkiCapabilities(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetPkiCapabilities(struct soap *soap, const char *tag, int id, const _sai__GetPkiCapabilities *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetPkiCapabilities), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetPkiCapabilities::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetPkiCapabilities(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetPkiCapabilities * SOAP_FMAC4 soap_get__sai__GetPkiCapabilities(struct soap *soap, _sai__GetPkiCapabilities *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetPkiCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetPkiCapabilities::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetPkiCapabilities(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetPkiCapabilities * SOAP_FMAC4 soap_in__sai__GetPkiCapabilities(struct soap *soap, const char *tag, _sai__GetPkiCapabilities *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetPkiCapabilities *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetPkiCapabilities, sizeof(_sai__GetPkiCapabilities), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetPkiCapabilities) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetPkiCapabilities *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetPkiCapabilities *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetPkiCapabilities, 0, sizeof(_sai__GetPkiCapabilities), 0, soap_copy__sai__GetPkiCapabilities); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetPkiCapabilities * SOAP_FMAC6 soap_new__sai__GetPkiCapabilities(struct soap *soap, int n) +{ return soap_instantiate__sai__GetPkiCapabilities(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetPkiCapabilities(struct soap *soap, _sai__GetPkiCapabilities *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetPkiCapabilities * SOAP_FMAC4 soap_instantiate__sai__GetPkiCapabilities(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetPkiCapabilities(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetPkiCapabilities, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetPkiCapabilities; + if (size) + *size = sizeof(_sai__GetPkiCapabilities); + ((_sai__GetPkiCapabilities*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetPkiCapabilities[n]; + if (size) + *size = n * sizeof(_sai__GetPkiCapabilities); + for (int i = 0; i < n; i++) + ((_sai__GetPkiCapabilities*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetPkiCapabilities*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetPkiCapabilities(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetPkiCapabilities %p -> %p\n", q, p)); + *(_sai__GetPkiCapabilities*)p = *(_sai__GetPkiCapabilities*)q; +} + +void _sai__GetServerCertificateReqResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetServerCertificateReqResponse*)this)->CertReq, SOAP_TYPE_xsd__base64Binary); + ((_sai__GetServerCertificateReqResponse*)this)->CertReq.soap_serialize(soap); + /* transient soap skipped */ +} + +void _sai__GetServerCertificateReqResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetServerCertificateReqResponse*)this)->StatusCode); + ((_sai__GetServerCertificateReqResponse*)this)->CertReq.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int _sai__GetServerCertificateReqResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetServerCertificateReqResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetServerCertificateReqResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetServerCertificateReqResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetServerCertificateReqResponse(struct soap *soap, const char *tag, int id, const _sai__GetServerCertificateReqResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetServerCertificateReqResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetServerCertificateReqResponse*)a)->StatusCode), ""); + (((_sai__GetServerCertificateReqResponse*)a)->CertReq).soap_out(soap, "sai:CertReq", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetServerCertificateReqResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetServerCertificateReqResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetServerCertificateReqResponse * SOAP_FMAC4 soap_get__sai__GetServerCertificateReqResponse(struct soap *soap, _sai__GetServerCertificateReqResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetServerCertificateReqResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetServerCertificateReqResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetServerCertificateReqResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetServerCertificateReqResponse * SOAP_FMAC4 soap_in__sai__GetServerCertificateReqResponse(struct soap *soap, const char *tag, _sai__GetServerCertificateReqResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetServerCertificateReqResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetServerCertificateReqResponse, sizeof(_sai__GetServerCertificateReqResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetServerCertificateReqResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetServerCertificateReqResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_CertReq1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetServerCertificateReqResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_CertReq1 && soap->error == SOAP_TAG_MISMATCH) + if ((((_sai__GetServerCertificateReqResponse*)a)->CertReq).soap_in(soap, "sai:CertReq", "xsd:base64Binary")) + { soap_flag_CertReq1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_CertReq1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetServerCertificateReqResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetServerCertificateReqResponse, 0, sizeof(_sai__GetServerCertificateReqResponse), 0, soap_copy__sai__GetServerCertificateReqResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetServerCertificateReqResponse * SOAP_FMAC6 soap_new__sai__GetServerCertificateReqResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetServerCertificateReqResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetServerCertificateReqResponse(struct soap *soap, _sai__GetServerCertificateReqResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetServerCertificateReqResponse * SOAP_FMAC4 soap_instantiate__sai__GetServerCertificateReqResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetServerCertificateReqResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetServerCertificateReqResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetServerCertificateReqResponse; + if (size) + *size = sizeof(_sai__GetServerCertificateReqResponse); + ((_sai__GetServerCertificateReqResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetServerCertificateReqResponse[n]; + if (size) + *size = n * sizeof(_sai__GetServerCertificateReqResponse); + for (int i = 0; i < n; i++) + ((_sai__GetServerCertificateReqResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetServerCertificateReqResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetServerCertificateReqResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetServerCertificateReqResponse %p -> %p\n", q, p)); + *(_sai__GetServerCertificateReqResponse*)p = *(_sai__GetServerCertificateReqResponse*)q; +} + +void _sai__GetServerCertificateReq::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetServerCertificateReq::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetServerCertificateReq::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetServerCertificateReq); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetServerCertificateReq::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetServerCertificateReq(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetServerCertificateReq(struct soap *soap, const char *tag, int id, const _sai__GetServerCertificateReq *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetServerCertificateReq), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetServerCertificateReq::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetServerCertificateReq(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetServerCertificateReq * SOAP_FMAC4 soap_get__sai__GetServerCertificateReq(struct soap *soap, _sai__GetServerCertificateReq *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetServerCertificateReq(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetServerCertificateReq::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetServerCertificateReq(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetServerCertificateReq * SOAP_FMAC4 soap_in__sai__GetServerCertificateReq(struct soap *soap, const char *tag, _sai__GetServerCertificateReq *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetServerCertificateReq *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetServerCertificateReq, sizeof(_sai__GetServerCertificateReq), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetServerCertificateReq) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetServerCertificateReq *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetServerCertificateReq *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetServerCertificateReq, 0, sizeof(_sai__GetServerCertificateReq), 0, soap_copy__sai__GetServerCertificateReq); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetServerCertificateReq * SOAP_FMAC6 soap_new__sai__GetServerCertificateReq(struct soap *soap, int n) +{ return soap_instantiate__sai__GetServerCertificateReq(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetServerCertificateReq(struct soap *soap, _sai__GetServerCertificateReq *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetServerCertificateReq * SOAP_FMAC4 soap_instantiate__sai__GetServerCertificateReq(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetServerCertificateReq(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetServerCertificateReq, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetServerCertificateReq; + if (size) + *size = sizeof(_sai__GetServerCertificateReq); + ((_sai__GetServerCertificateReq*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetServerCertificateReq[n]; + if (size) + *size = n * sizeof(_sai__GetServerCertificateReq); + for (int i = 0; i < n; i++) + ((_sai__GetServerCertificateReq*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetServerCertificateReq*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetServerCertificateReq(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetServerCertificateReq %p -> %p\n", q, p)); + *(_sai__GetServerCertificateReq*)p = *(_sai__GetServerCertificateReq*)q; +} + +void _sai__GetCRLResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTosai__CrlType(soap, &((_sai__GetCRLResponse*)this)->Crl); + /* transient soap skipped */ +} + +void _sai__GetCRLResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetCRLResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfPointerTosai__CrlType(soap, &((_sai__GetCRLResponse*)this)->Crl); + /* transient soap skipped */ +} + +int _sai__GetCRLResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetCRLResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetCRLResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetCRLResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCRLResponse(struct soap *soap, const char *tag, int id, const _sai__GetCRLResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetCRLResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetCRLResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfPointerTosai__CrlType(soap, "sai:Crl", -1, &(((_sai__GetCRLResponse*)a)->Crl), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetCRLResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetCRLResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetCRLResponse * SOAP_FMAC4 soap_get__sai__GetCRLResponse(struct soap *soap, _sai__GetCRLResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetCRLResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetCRLResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetCRLResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetCRLResponse * SOAP_FMAC4 soap_in__sai__GetCRLResponse(struct soap *soap, const char *tag, _sai__GetCRLResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetCRLResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetCRLResponse, sizeof(_sai__GetCRLResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetCRLResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetCRLResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetCRLResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTosai__CrlType(soap, "sai:Crl", &(((_sai__GetCRLResponse*)a)->Crl), "sai:CrlType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetCRLResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetCRLResponse, 0, sizeof(_sai__GetCRLResponse), 0, soap_copy__sai__GetCRLResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetCRLResponse * SOAP_FMAC6 soap_new__sai__GetCRLResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetCRLResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCRLResponse(struct soap *soap, _sai__GetCRLResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetCRLResponse * SOAP_FMAC4 soap_instantiate__sai__GetCRLResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetCRLResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetCRLResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetCRLResponse; + if (size) + *size = sizeof(_sai__GetCRLResponse); + ((_sai__GetCRLResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetCRLResponse[n]; + if (size) + *size = n * sizeof(_sai__GetCRLResponse); + for (int i = 0; i < n; i++) + ((_sai__GetCRLResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetCRLResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCRLResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetCRLResponse %p -> %p\n", q, p)); + *(_sai__GetCRLResponse*)p = *(_sai__GetCRLResponse*)q; +} + +void _sai__GetCRL::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetCRL::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetCRL::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetCRL); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetCRL::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetCRL(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCRL(struct soap *soap, const char *tag, int id, const _sai__GetCRL *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetCRL), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetCRL::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetCRL(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetCRL * SOAP_FMAC4 soap_get__sai__GetCRL(struct soap *soap, _sai__GetCRL *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetCRL(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetCRL::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetCRL(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetCRL * SOAP_FMAC4 soap_in__sai__GetCRL(struct soap *soap, const char *tag, _sai__GetCRL *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetCRL *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetCRL, sizeof(_sai__GetCRL), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetCRL) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetCRL *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetCRL *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetCRL, 0, sizeof(_sai__GetCRL), 0, soap_copy__sai__GetCRL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetCRL * SOAP_FMAC6 soap_new__sai__GetCRL(struct soap *soap, int n) +{ return soap_instantiate__sai__GetCRL(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCRL(struct soap *soap, _sai__GetCRL *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetCRL * SOAP_FMAC4 soap_instantiate__sai__GetCRL(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetCRL(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetCRL, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetCRL; + if (size) + *size = sizeof(_sai__GetCRL); + ((_sai__GetCRL*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetCRL[n]; + if (size) + *size = n * sizeof(_sai__GetCRL); + for (int i = 0; i < n; i++) + ((_sai__GetCRL*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetCRL*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCRL(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetCRL %p -> %p\n", q, p)); + *(_sai__GetCRL*)p = *(_sai__GetCRL*)q; +} + +void _sai__SetCRLResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetCRLResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetCRLResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetCRLResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetCRLResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetCRLResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetCRLResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetCRLResponse(struct soap *soap, const char *tag, int id, const _sai__SetCRLResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetCRLResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetCRLResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetCRLResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetCRLResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetCRLResponse * SOAP_FMAC4 soap_get__sai__SetCRLResponse(struct soap *soap, _sai__SetCRLResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetCRLResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetCRLResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetCRLResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetCRLResponse * SOAP_FMAC4 soap_in__sai__SetCRLResponse(struct soap *soap, const char *tag, _sai__SetCRLResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetCRLResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetCRLResponse, sizeof(_sai__SetCRLResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetCRLResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetCRLResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetCRLResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetCRLResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetCRLResponse, 0, sizeof(_sai__SetCRLResponse), 0, soap_copy__sai__SetCRLResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetCRLResponse * SOAP_FMAC6 soap_new__sai__SetCRLResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetCRLResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetCRLResponse(struct soap *soap, _sai__SetCRLResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetCRLResponse * SOAP_FMAC4 soap_instantiate__sai__SetCRLResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetCRLResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetCRLResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetCRLResponse; + if (size) + *size = sizeof(_sai__SetCRLResponse); + ((_sai__SetCRLResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetCRLResponse[n]; + if (size) + *size = n * sizeof(_sai__SetCRLResponse); + for (int i = 0; i < n; i++) + ((_sai__SetCRLResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetCRLResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetCRLResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetCRLResponse %p -> %p\n", q, p)); + *(_sai__SetCRLResponse*)p = *(_sai__SetCRLResponse*)q; +} + +void _sai__SetCRL::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTosai__CrlType(soap, &((_sai__SetCRL*)this)->Crl); + /* transient soap skipped */ +} + +void _sai__SetCRL::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfPointerTosai__CrlType(soap, &((_sai__SetCRL*)this)->Crl); + /* transient soap skipped */ +} + +int _sai__SetCRL::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetCRL); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetCRL::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetCRL(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetCRL(struct soap *soap, const char *tag, int id, const _sai__SetCRL *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetCRL), type); + soap_out_std__vectorTemplateOfPointerTosai__CrlType(soap, "sai:Crl", -1, &(((_sai__SetCRL*)a)->Crl), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetCRL::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetCRL(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetCRL * SOAP_FMAC4 soap_get__sai__SetCRL(struct soap *soap, _sai__SetCRL *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetCRL(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetCRL::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetCRL(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetCRL * SOAP_FMAC4 soap_in__sai__SetCRL(struct soap *soap, const char *tag, _sai__SetCRL *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetCRL *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetCRL, sizeof(_sai__SetCRL), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetCRL) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetCRL *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTosai__CrlType(soap, "sai:Crl", &(((_sai__SetCRL*)a)->Crl), "sai:CrlType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetCRL *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetCRL, 0, sizeof(_sai__SetCRL), 0, soap_copy__sai__SetCRL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetCRL * SOAP_FMAC6 soap_new__sai__SetCRL(struct soap *soap, int n) +{ return soap_instantiate__sai__SetCRL(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetCRL(struct soap *soap, _sai__SetCRL *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetCRL * SOAP_FMAC4 soap_instantiate__sai__SetCRL(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetCRL(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetCRL, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetCRL; + if (size) + *size = sizeof(_sai__SetCRL); + ((_sai__SetCRL*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetCRL[n]; + if (size) + *size = n * sizeof(_sai__SetCRL); + for (int i = 0; i < n; i++) + ((_sai__SetCRL*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetCRL*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetCRL(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetCRL %p -> %p\n", q, p)); + *(_sai__SetCRL*)p = *(_sai__SetCRL*)q; +} + +void _sai__GetTrustedFqdnCNResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfstd__string(soap, &((_sai__GetTrustedFqdnCNResponse*)this)->FqdnSuffix); + /* transient soap skipped */ +} + +void _sai__GetTrustedFqdnCNResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetTrustedFqdnCNResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfstd__string(soap, &((_sai__GetTrustedFqdnCNResponse*)this)->FqdnSuffix); + /* transient soap skipped */ +} + +int _sai__GetTrustedFqdnCNResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTrustedFqdnCNResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTrustedFqdnCNResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTrustedFqdnCNResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTrustedFqdnCNResponse(struct soap *soap, const char *tag, int id, const _sai__GetTrustedFqdnCNResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTrustedFqdnCNResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetTrustedFqdnCNResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfstd__string(soap, "sai:FqdnSuffix", -1, &(((_sai__GetTrustedFqdnCNResponse*)a)->FqdnSuffix), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTrustedFqdnCNResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTrustedFqdnCNResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse * SOAP_FMAC4 soap_get__sai__GetTrustedFqdnCNResponse(struct soap *soap, _sai__GetTrustedFqdnCNResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTrustedFqdnCNResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTrustedFqdnCNResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTrustedFqdnCNResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse * SOAP_FMAC4 soap_in__sai__GetTrustedFqdnCNResponse(struct soap *soap, const char *tag, _sai__GetTrustedFqdnCNResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTrustedFqdnCNResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTrustedFqdnCNResponse, sizeof(_sai__GetTrustedFqdnCNResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTrustedFqdnCNResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTrustedFqdnCNResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetTrustedFqdnCNResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfstd__string(soap, "sai:FqdnSuffix", &(((_sai__GetTrustedFqdnCNResponse*)a)->FqdnSuffix), "xsd:string")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTrustedFqdnCNResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTrustedFqdnCNResponse, 0, sizeof(_sai__GetTrustedFqdnCNResponse), 0, soap_copy__sai__GetTrustedFqdnCNResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTrustedFqdnCNResponse * SOAP_FMAC6 soap_new__sai__GetTrustedFqdnCNResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTrustedFqdnCNResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTrustedFqdnCNResponse(struct soap *soap, _sai__GetTrustedFqdnCNResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse * SOAP_FMAC4 soap_instantiate__sai__GetTrustedFqdnCNResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTrustedFqdnCNResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTrustedFqdnCNResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTrustedFqdnCNResponse; + if (size) + *size = sizeof(_sai__GetTrustedFqdnCNResponse); + ((_sai__GetTrustedFqdnCNResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTrustedFqdnCNResponse[n]; + if (size) + *size = n * sizeof(_sai__GetTrustedFqdnCNResponse); + for (int i = 0; i < n; i++) + ((_sai__GetTrustedFqdnCNResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTrustedFqdnCNResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTrustedFqdnCNResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTrustedFqdnCNResponse %p -> %p\n", q, p)); + *(_sai__GetTrustedFqdnCNResponse*)p = *(_sai__GetTrustedFqdnCNResponse*)q; +} + +void _sai__GetTrustedFqdnCN::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetTrustedFqdnCN::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetTrustedFqdnCN::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTrustedFqdnCN); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTrustedFqdnCN::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTrustedFqdnCN(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTrustedFqdnCN(struct soap *soap, const char *tag, int id, const _sai__GetTrustedFqdnCN *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTrustedFqdnCN), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTrustedFqdnCN::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTrustedFqdnCN(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_get__sai__GetTrustedFqdnCN(struct soap *soap, _sai__GetTrustedFqdnCN *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTrustedFqdnCN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTrustedFqdnCN::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTrustedFqdnCN(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_in__sai__GetTrustedFqdnCN(struct soap *soap, const char *tag, _sai__GetTrustedFqdnCN *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTrustedFqdnCN *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTrustedFqdnCN, sizeof(_sai__GetTrustedFqdnCN), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTrustedFqdnCN) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTrustedFqdnCN *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTrustedFqdnCN *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTrustedFqdnCN, 0, sizeof(_sai__GetTrustedFqdnCN), 0, soap_copy__sai__GetTrustedFqdnCN); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTrustedFqdnCN * SOAP_FMAC6 soap_new__sai__GetTrustedFqdnCN(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTrustedFqdnCN(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTrustedFqdnCN(struct soap *soap, _sai__GetTrustedFqdnCN *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_instantiate__sai__GetTrustedFqdnCN(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTrustedFqdnCN(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTrustedFqdnCN, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTrustedFqdnCN; + if (size) + *size = sizeof(_sai__GetTrustedFqdnCN); + ((_sai__GetTrustedFqdnCN*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTrustedFqdnCN[n]; + if (size) + *size = n * sizeof(_sai__GetTrustedFqdnCN); + for (int i = 0; i < n; i++) + ((_sai__GetTrustedFqdnCN*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTrustedFqdnCN*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTrustedFqdnCN(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTrustedFqdnCN %p -> %p\n", q, p)); + *(_sai__GetTrustedFqdnCN*)p = *(_sai__GetTrustedFqdnCN*)q; +} + +void _sai__SetTrustedFqdnCNResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetTrustedFqdnCNResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetTrustedFqdnCNResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetTrustedFqdnCNResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTrustedFqdnCNResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTrustedFqdnCNResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTrustedFqdnCNResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTrustedFqdnCNResponse(struct soap *soap, const char *tag, int id, const _sai__SetTrustedFqdnCNResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTrustedFqdnCNResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetTrustedFqdnCNResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTrustedFqdnCNResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTrustedFqdnCNResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse * SOAP_FMAC4 soap_get__sai__SetTrustedFqdnCNResponse(struct soap *soap, _sai__SetTrustedFqdnCNResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTrustedFqdnCNResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTrustedFqdnCNResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTrustedFqdnCNResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse * SOAP_FMAC4 soap_in__sai__SetTrustedFqdnCNResponse(struct soap *soap, const char *tag, _sai__SetTrustedFqdnCNResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTrustedFqdnCNResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTrustedFqdnCNResponse, sizeof(_sai__SetTrustedFqdnCNResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTrustedFqdnCNResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTrustedFqdnCNResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetTrustedFqdnCNResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTrustedFqdnCNResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTrustedFqdnCNResponse, 0, sizeof(_sai__SetTrustedFqdnCNResponse), 0, soap_copy__sai__SetTrustedFqdnCNResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTrustedFqdnCNResponse * SOAP_FMAC6 soap_new__sai__SetTrustedFqdnCNResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTrustedFqdnCNResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTrustedFqdnCNResponse(struct soap *soap, _sai__SetTrustedFqdnCNResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse * SOAP_FMAC4 soap_instantiate__sai__SetTrustedFqdnCNResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTrustedFqdnCNResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTrustedFqdnCNResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTrustedFqdnCNResponse; + if (size) + *size = sizeof(_sai__SetTrustedFqdnCNResponse); + ((_sai__SetTrustedFqdnCNResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTrustedFqdnCNResponse[n]; + if (size) + *size = n * sizeof(_sai__SetTrustedFqdnCNResponse); + for (int i = 0; i < n; i++) + ((_sai__SetTrustedFqdnCNResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTrustedFqdnCNResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTrustedFqdnCNResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTrustedFqdnCNResponse %p -> %p\n", q, p)); + *(_sai__SetTrustedFqdnCNResponse*)p = *(_sai__SetTrustedFqdnCNResponse*)q; +} + +void _sai__SetTrustedFqdnCN::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfstd__string(soap, &((_sai__SetTrustedFqdnCN*)this)->FqdnSuffix); + /* transient soap skipped */ +} + +void _sai__SetTrustedFqdnCN::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfstd__string(soap, &((_sai__SetTrustedFqdnCN*)this)->FqdnSuffix); + /* transient soap skipped */ +} + +int _sai__SetTrustedFqdnCN::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTrustedFqdnCN); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTrustedFqdnCN::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTrustedFqdnCN(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTrustedFqdnCN(struct soap *soap, const char *tag, int id, const _sai__SetTrustedFqdnCN *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTrustedFqdnCN), type); + soap_out_std__vectorTemplateOfstd__string(soap, "sai:FqdnSuffix", -1, &(((_sai__SetTrustedFqdnCN*)a)->FqdnSuffix), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTrustedFqdnCN::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTrustedFqdnCN(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_get__sai__SetTrustedFqdnCN(struct soap *soap, _sai__SetTrustedFqdnCN *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTrustedFqdnCN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTrustedFqdnCN::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTrustedFqdnCN(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_in__sai__SetTrustedFqdnCN(struct soap *soap, const char *tag, _sai__SetTrustedFqdnCN *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTrustedFqdnCN *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTrustedFqdnCN, sizeof(_sai__SetTrustedFqdnCN), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTrustedFqdnCN) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTrustedFqdnCN *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfstd__string(soap, "sai:FqdnSuffix", &(((_sai__SetTrustedFqdnCN*)a)->FqdnSuffix), "xsd:string")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTrustedFqdnCN *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTrustedFqdnCN, 0, sizeof(_sai__SetTrustedFqdnCN), 0, soap_copy__sai__SetTrustedFqdnCN); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTrustedFqdnCN * SOAP_FMAC6 soap_new__sai__SetTrustedFqdnCN(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTrustedFqdnCN(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTrustedFqdnCN(struct soap *soap, _sai__SetTrustedFqdnCN *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_instantiate__sai__SetTrustedFqdnCN(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTrustedFqdnCN(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTrustedFqdnCN, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTrustedFqdnCN; + if (size) + *size = sizeof(_sai__SetTrustedFqdnCN); + ((_sai__SetTrustedFqdnCN*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTrustedFqdnCN[n]; + if (size) + *size = n * sizeof(_sai__SetTrustedFqdnCN); + for (int i = 0; i < n; i++) + ((_sai__SetTrustedFqdnCN*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTrustedFqdnCN*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTrustedFqdnCN(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTrustedFqdnCN %p -> %p\n", q, p)); + *(_sai__SetTrustedFqdnCN*)p = *(_sai__SetTrustedFqdnCN*)q; +} + +void _sai__EnumerateTrustedRootCertificatesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfsai__CertificateHandleType(soap, &((_sai__EnumerateTrustedRootCertificatesResponse*)this)->CertHandle); + /* transient soap skipped */ +} + +void _sai__EnumerateTrustedRootCertificatesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__EnumerateTrustedRootCertificatesResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfsai__CertificateHandleType(soap, &((_sai__EnumerateTrustedRootCertificatesResponse*)this)->CertHandle); + /* transient soap skipped */ +} + +int _sai__EnumerateTrustedRootCertificatesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnumerateTrustedRootCertificatesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnumerateTrustedRootCertificatesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, const char *tag, int id, const _sai__EnumerateTrustedRootCertificatesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__EnumerateTrustedRootCertificatesResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfsai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__EnumerateTrustedRootCertificatesResponse*)a)->CertHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnumerateTrustedRootCertificatesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnumerateTrustedRootCertificatesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse * SOAP_FMAC4 soap_get__sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, _sai__EnumerateTrustedRootCertificatesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnumerateTrustedRootCertificatesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnumerateTrustedRootCertificatesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnumerateTrustedRootCertificatesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse * SOAP_FMAC4 soap_in__sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, const char *tag, _sai__EnumerateTrustedRootCertificatesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnumerateTrustedRootCertificatesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse, sizeof(_sai__EnumerateTrustedRootCertificatesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnumerateTrustedRootCertificatesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__EnumerateTrustedRootCertificatesResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfsai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__EnumerateTrustedRootCertificatesResponse*)a)->CertHandle), "sai:CertificateHandleType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnumerateTrustedRootCertificatesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse, 0, sizeof(_sai__EnumerateTrustedRootCertificatesResponse), 0, soap_copy__sai__EnumerateTrustedRootCertificatesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnumerateTrustedRootCertificatesResponse * SOAP_FMAC6 soap_new__sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__EnumerateTrustedRootCertificatesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, _sai__EnumerateTrustedRootCertificatesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse * SOAP_FMAC4 soap_instantiate__sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnumerateTrustedRootCertificatesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnumerateTrustedRootCertificatesResponse; + if (size) + *size = sizeof(_sai__EnumerateTrustedRootCertificatesResponse); + ((_sai__EnumerateTrustedRootCertificatesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnumerateTrustedRootCertificatesResponse[n]; + if (size) + *size = n * sizeof(_sai__EnumerateTrustedRootCertificatesResponse); + for (int i = 0; i < n; i++) + ((_sai__EnumerateTrustedRootCertificatesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnumerateTrustedRootCertificatesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnumerateTrustedRootCertificatesResponse %p -> %p\n", q, p)); + *(_sai__EnumerateTrustedRootCertificatesResponse*)p = *(_sai__EnumerateTrustedRootCertificatesResponse*)q; +} + +void _sai__EnumerateTrustedRootCertificates::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__EnumerateTrustedRootCertificates::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__EnumerateTrustedRootCertificates::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnumerateTrustedRootCertificates); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnumerateTrustedRootCertificates::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnumerateTrustedRootCertificates(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateTrustedRootCertificates(struct soap *soap, const char *tag, int id, const _sai__EnumerateTrustedRootCertificates *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnumerateTrustedRootCertificates), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnumerateTrustedRootCertificates::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnumerateTrustedRootCertificates(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_get__sai__EnumerateTrustedRootCertificates(struct soap *soap, _sai__EnumerateTrustedRootCertificates *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnumerateTrustedRootCertificates(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnumerateTrustedRootCertificates::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnumerateTrustedRootCertificates(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_in__sai__EnumerateTrustedRootCertificates(struct soap *soap, const char *tag, _sai__EnumerateTrustedRootCertificates *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnumerateTrustedRootCertificates *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnumerateTrustedRootCertificates, sizeof(_sai__EnumerateTrustedRootCertificates), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnumerateTrustedRootCertificates) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnumerateTrustedRootCertificates *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnumerateTrustedRootCertificates *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnumerateTrustedRootCertificates, 0, sizeof(_sai__EnumerateTrustedRootCertificates), 0, soap_copy__sai__EnumerateTrustedRootCertificates); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnumerateTrustedRootCertificates * SOAP_FMAC6 soap_new__sai__EnumerateTrustedRootCertificates(struct soap *soap, int n) +{ return soap_instantiate__sai__EnumerateTrustedRootCertificates(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateTrustedRootCertificates(struct soap *soap, _sai__EnumerateTrustedRootCertificates *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_instantiate__sai__EnumerateTrustedRootCertificates(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnumerateTrustedRootCertificates(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnumerateTrustedRootCertificates, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnumerateTrustedRootCertificates; + if (size) + *size = sizeof(_sai__EnumerateTrustedRootCertificates); + ((_sai__EnumerateTrustedRootCertificates*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnumerateTrustedRootCertificates[n]; + if (size) + *size = n * sizeof(_sai__EnumerateTrustedRootCertificates); + for (int i = 0; i < n; i++) + ((_sai__EnumerateTrustedRootCertificates*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnumerateTrustedRootCertificates*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateTrustedRootCertificates(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnumerateTrustedRootCertificates %p -> %p\n", q, p)); + *(_sai__EnumerateTrustedRootCertificates*)p = *(_sai__EnumerateTrustedRootCertificates*)q; +} + +void _sai__DeleteTrustedRootCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__DeleteTrustedRootCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__DeleteTrustedRootCertificateResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__DeleteTrustedRootCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__DeleteTrustedRootCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__DeleteTrustedRootCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__DeleteTrustedRootCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__DeleteTrustedRootCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__DeleteTrustedRootCertificateResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__DeleteTrustedRootCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__DeleteTrustedRootCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse * SOAP_FMAC4 soap_get__sai__DeleteTrustedRootCertificateResponse(struct soap *soap, _sai__DeleteTrustedRootCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__DeleteTrustedRootCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__DeleteTrustedRootCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__DeleteTrustedRootCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse * SOAP_FMAC4 soap_in__sai__DeleteTrustedRootCertificateResponse(struct soap *soap, const char *tag, _sai__DeleteTrustedRootCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__DeleteTrustedRootCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse, sizeof(_sai__DeleteTrustedRootCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__DeleteTrustedRootCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__DeleteTrustedRootCertificateResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__DeleteTrustedRootCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse, 0, sizeof(_sai__DeleteTrustedRootCertificateResponse), 0, soap_copy__sai__DeleteTrustedRootCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__DeleteTrustedRootCertificateResponse * SOAP_FMAC6 soap_new__sai__DeleteTrustedRootCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__DeleteTrustedRootCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__DeleteTrustedRootCertificateResponse(struct soap *soap, _sai__DeleteTrustedRootCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__DeleteTrustedRootCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__DeleteTrustedRootCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__DeleteTrustedRootCertificateResponse; + if (size) + *size = sizeof(_sai__DeleteTrustedRootCertificateResponse); + ((_sai__DeleteTrustedRootCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__DeleteTrustedRootCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__DeleteTrustedRootCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__DeleteTrustedRootCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__DeleteTrustedRootCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__DeleteTrustedRootCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__DeleteTrustedRootCertificateResponse %p -> %p\n", q, p)); + *(_sai__DeleteTrustedRootCertificateResponse*)p = *(_sai__DeleteTrustedRootCertificateResponse*)q; +} + +void _sai__DeleteTrustedRootCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__DeleteTrustedRootCertificate*)this)->CertHandle, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void _sai__DeleteTrustedRootCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__CertificateHandleType(soap, &((_sai__DeleteTrustedRootCertificate*)this)->CertHandle); + /* transient soap skipped */ +} + +int _sai__DeleteTrustedRootCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__DeleteTrustedRootCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__DeleteTrustedRootCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__DeleteTrustedRootCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__DeleteTrustedRootCertificate(struct soap *soap, const char *tag, int id, const _sai__DeleteTrustedRootCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__DeleteTrustedRootCertificate), type); + soap_out_sai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__DeleteTrustedRootCertificate*)a)->CertHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__DeleteTrustedRootCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__DeleteTrustedRootCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_get__sai__DeleteTrustedRootCertificate(struct soap *soap, _sai__DeleteTrustedRootCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__DeleteTrustedRootCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__DeleteTrustedRootCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__DeleteTrustedRootCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_in__sai__DeleteTrustedRootCertificate(struct soap *soap, const char *tag, _sai__DeleteTrustedRootCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__DeleteTrustedRootCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__DeleteTrustedRootCertificate, sizeof(_sai__DeleteTrustedRootCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__DeleteTrustedRootCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__DeleteTrustedRootCertificate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CertHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CertHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__DeleteTrustedRootCertificate*)a)->CertHandle), "sai:CertificateHandleType")) + { soap_flag_CertHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CertHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__DeleteTrustedRootCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__DeleteTrustedRootCertificate, 0, sizeof(_sai__DeleteTrustedRootCertificate), 0, soap_copy__sai__DeleteTrustedRootCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__DeleteTrustedRootCertificate * SOAP_FMAC6 soap_new__sai__DeleteTrustedRootCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__DeleteTrustedRootCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__DeleteTrustedRootCertificate(struct soap *soap, _sai__DeleteTrustedRootCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_instantiate__sai__DeleteTrustedRootCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__DeleteTrustedRootCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__DeleteTrustedRootCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__DeleteTrustedRootCertificate; + if (size) + *size = sizeof(_sai__DeleteTrustedRootCertificate); + ((_sai__DeleteTrustedRootCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__DeleteTrustedRootCertificate[n]; + if (size) + *size = n * sizeof(_sai__DeleteTrustedRootCertificate); + for (int i = 0; i < n; i++) + ((_sai__DeleteTrustedRootCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__DeleteTrustedRootCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__DeleteTrustedRootCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__DeleteTrustedRootCertificate %p -> %p\n", q, p)); + *(_sai__DeleteTrustedRootCertificate*)p = *(_sai__DeleteTrustedRootCertificate*)q; +} + +void _sai__GetTrustedRootCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateType(soap, &((_sai__GetTrustedRootCertificateResponse*)this)->Certificate); + /* transient soap skipped */ +} + +void _sai__GetTrustedRootCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetTrustedRootCertificateResponse*)this)->StatusCode); + ((_sai__GetTrustedRootCertificateResponse*)this)->Certificate = NULL; + /* transient soap skipped */ +} + +int _sai__GetTrustedRootCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTrustedRootCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTrustedRootCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTrustedRootCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTrustedRootCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__GetTrustedRootCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTrustedRootCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetTrustedRootCertificateResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__CertificateType(soap, "sai:Certificate", -1, &(((_sai__GetTrustedRootCertificateResponse*)a)->Certificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTrustedRootCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTrustedRootCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse * SOAP_FMAC4 soap_get__sai__GetTrustedRootCertificateResponse(struct soap *soap, _sai__GetTrustedRootCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTrustedRootCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTrustedRootCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTrustedRootCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse * SOAP_FMAC4 soap_in__sai__GetTrustedRootCertificateResponse(struct soap *soap, const char *tag, _sai__GetTrustedRootCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTrustedRootCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTrustedRootCertificateResponse, sizeof(_sai__GetTrustedRootCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTrustedRootCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTrustedRootCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Certificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetTrustedRootCertificateResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Certificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateType(soap, "sai:Certificate", &(((_sai__GetTrustedRootCertificateResponse*)a)->Certificate), "sai:CertificateType")) + { soap_flag_Certificate1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Certificate1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTrustedRootCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTrustedRootCertificateResponse, 0, sizeof(_sai__GetTrustedRootCertificateResponse), 0, soap_copy__sai__GetTrustedRootCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTrustedRootCertificateResponse * SOAP_FMAC6 soap_new__sai__GetTrustedRootCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTrustedRootCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTrustedRootCertificateResponse(struct soap *soap, _sai__GetTrustedRootCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__GetTrustedRootCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTrustedRootCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTrustedRootCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTrustedRootCertificateResponse; + if (size) + *size = sizeof(_sai__GetTrustedRootCertificateResponse); + ((_sai__GetTrustedRootCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTrustedRootCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__GetTrustedRootCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__GetTrustedRootCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTrustedRootCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTrustedRootCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTrustedRootCertificateResponse %p -> %p\n", q, p)); + *(_sai__GetTrustedRootCertificateResponse*)p = *(_sai__GetTrustedRootCertificateResponse*)q; +} + +void _sai__GetTrustedRootCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetTrustedRootCertificate*)this)->CertHandle, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void _sai__GetTrustedRootCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__CertificateHandleType(soap, &((_sai__GetTrustedRootCertificate*)this)->CertHandle); + /* transient soap skipped */ +} + +int _sai__GetTrustedRootCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTrustedRootCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTrustedRootCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTrustedRootCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTrustedRootCertificate(struct soap *soap, const char *tag, int id, const _sai__GetTrustedRootCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTrustedRootCertificate), type); + soap_out_sai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__GetTrustedRootCertificate*)a)->CertHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTrustedRootCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTrustedRootCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_get__sai__GetTrustedRootCertificate(struct soap *soap, _sai__GetTrustedRootCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTrustedRootCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTrustedRootCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTrustedRootCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_in__sai__GetTrustedRootCertificate(struct soap *soap, const char *tag, _sai__GetTrustedRootCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTrustedRootCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTrustedRootCertificate, sizeof(_sai__GetTrustedRootCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTrustedRootCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTrustedRootCertificate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CertHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CertHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__GetTrustedRootCertificate*)a)->CertHandle), "sai:CertificateHandleType")) + { soap_flag_CertHandle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CertHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTrustedRootCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTrustedRootCertificate, 0, sizeof(_sai__GetTrustedRootCertificate), 0, soap_copy__sai__GetTrustedRootCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTrustedRootCertificate * SOAP_FMAC6 soap_new__sai__GetTrustedRootCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTrustedRootCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTrustedRootCertificate(struct soap *soap, _sai__GetTrustedRootCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_instantiate__sai__GetTrustedRootCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTrustedRootCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTrustedRootCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTrustedRootCertificate; + if (size) + *size = sizeof(_sai__GetTrustedRootCertificate); + ((_sai__GetTrustedRootCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTrustedRootCertificate[n]; + if (size) + *size = n * sizeof(_sai__GetTrustedRootCertificate); + for (int i = 0; i < n; i++) + ((_sai__GetTrustedRootCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTrustedRootCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTrustedRootCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTrustedRootCertificate %p -> %p\n", q, p)); + *(_sai__GetTrustedRootCertificate*)p = *(_sai__GetTrustedRootCertificate*)q; +} + +void _sai__AddTrustedRootCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__AddTrustedRootCertificateResponse*)this)->CertHandle, SOAP_TYPE_sai__CertificateHandleType); + /* transient soap skipped */ +} + +void _sai__AddTrustedRootCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__AddTrustedRootCertificateResponse*)this)->StatusCode); + soap_default_sai__CertificateHandleType(soap, &((_sai__AddTrustedRootCertificateResponse*)this)->CertHandle); + /* transient soap skipped */ +} + +int _sai__AddTrustedRootCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__AddTrustedRootCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__AddTrustedRootCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__AddTrustedRootCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddTrustedRootCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__AddTrustedRootCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__AddTrustedRootCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__AddTrustedRootCertificateResponse*)a)->StatusCode), ""); + soap_out_sai__CertificateHandleType(soap, "sai:CertHandle", -1, &(((_sai__AddTrustedRootCertificateResponse*)a)->CertHandle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__AddTrustedRootCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__AddTrustedRootCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse * SOAP_FMAC4 soap_get__sai__AddTrustedRootCertificateResponse(struct soap *soap, _sai__AddTrustedRootCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__AddTrustedRootCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__AddTrustedRootCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__AddTrustedRootCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse * SOAP_FMAC4 soap_in__sai__AddTrustedRootCertificateResponse(struct soap *soap, const char *tag, _sai__AddTrustedRootCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__AddTrustedRootCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__AddTrustedRootCertificateResponse, sizeof(_sai__AddTrustedRootCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__AddTrustedRootCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__AddTrustedRootCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_CertHandle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__AddTrustedRootCertificateResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_CertHandle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__CertificateHandleType(soap, "sai:CertHandle", &(((_sai__AddTrustedRootCertificateResponse*)a)->CertHandle), "sai:CertificateHandleType")) + { soap_flag_CertHandle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_CertHandle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__AddTrustedRootCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__AddTrustedRootCertificateResponse, 0, sizeof(_sai__AddTrustedRootCertificateResponse), 0, soap_copy__sai__AddTrustedRootCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__AddTrustedRootCertificateResponse * SOAP_FMAC6 soap_new__sai__AddTrustedRootCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__AddTrustedRootCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddTrustedRootCertificateResponse(struct soap *soap, _sai__AddTrustedRootCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__AddTrustedRootCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__AddTrustedRootCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__AddTrustedRootCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__AddTrustedRootCertificateResponse; + if (size) + *size = sizeof(_sai__AddTrustedRootCertificateResponse); + ((_sai__AddTrustedRootCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__AddTrustedRootCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__AddTrustedRootCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__AddTrustedRootCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__AddTrustedRootCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddTrustedRootCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__AddTrustedRootCertificateResponse %p -> %p\n", q, p)); + *(_sai__AddTrustedRootCertificateResponse*)p = *(_sai__AddTrustedRootCertificateResponse*)q; +} + +void _sai__AddTrustedRootCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateType(soap, &((_sai__AddTrustedRootCertificate*)this)->Certificate); + /* transient soap skipped */ +} + +void _sai__AddTrustedRootCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__AddTrustedRootCertificate*)this)->Certificate = NULL; + /* transient soap skipped */ +} + +int _sai__AddTrustedRootCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__AddTrustedRootCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__AddTrustedRootCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__AddTrustedRootCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddTrustedRootCertificate(struct soap *soap, const char *tag, int id, const _sai__AddTrustedRootCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__AddTrustedRootCertificate), type); + soap_out_PointerTosai__CertificateType(soap, "sai:Certificate", -1, &(((_sai__AddTrustedRootCertificate*)a)->Certificate), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__AddTrustedRootCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__AddTrustedRootCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_get__sai__AddTrustedRootCertificate(struct soap *soap, _sai__AddTrustedRootCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__AddTrustedRootCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__AddTrustedRootCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__AddTrustedRootCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_in__sai__AddTrustedRootCertificate(struct soap *soap, const char *tag, _sai__AddTrustedRootCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__AddTrustedRootCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__AddTrustedRootCertificate, sizeof(_sai__AddTrustedRootCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__AddTrustedRootCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__AddTrustedRootCertificate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Certificate1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Certificate1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateType(soap, "sai:Certificate", &(((_sai__AddTrustedRootCertificate*)a)->Certificate), "sai:CertificateType")) + { soap_flag_Certificate1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Certificate1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__AddTrustedRootCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__AddTrustedRootCertificate, 0, sizeof(_sai__AddTrustedRootCertificate), 0, soap_copy__sai__AddTrustedRootCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__AddTrustedRootCertificate * SOAP_FMAC6 soap_new__sai__AddTrustedRootCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__AddTrustedRootCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddTrustedRootCertificate(struct soap *soap, _sai__AddTrustedRootCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_instantiate__sai__AddTrustedRootCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__AddTrustedRootCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__AddTrustedRootCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__AddTrustedRootCertificate; + if (size) + *size = sizeof(_sai__AddTrustedRootCertificate); + ((_sai__AddTrustedRootCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__AddTrustedRootCertificate[n]; + if (size) + *size = n * sizeof(_sai__AddTrustedRootCertificate); + for (int i = 0; i < n; i++) + ((_sai__AddTrustedRootCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__AddTrustedRootCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddTrustedRootCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__AddTrustedRootCertificate %p -> %p\n", q, p)); + *(_sai__AddTrustedRootCertificate*)p = *(_sai__AddTrustedRootCertificate*)q; +} + +void _sai__GetTlsOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, &((_sai__GetTlsOptionsResponse*)this)->TlsOptions); + /* transient soap skipped */ +} + +void _sai__GetTlsOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetTlsOptionsResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, &((_sai__GetTlsOptionsResponse*)this)->TlsOptions); + /* transient soap skipped */ +} + +int _sai__GetTlsOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTlsOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTlsOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTlsOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTlsOptionsResponse(struct soap *soap, const char *tag, int id, const _sai__GetTlsOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTlsOptionsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetTlsOptionsResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, "sai:TlsOptions", -1, &(((_sai__GetTlsOptionsResponse*)a)->TlsOptions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTlsOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTlsOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTlsOptionsResponse * SOAP_FMAC4 soap_get__sai__GetTlsOptionsResponse(struct soap *soap, _sai__GetTlsOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTlsOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTlsOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTlsOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTlsOptionsResponse * SOAP_FMAC4 soap_in__sai__GetTlsOptionsResponse(struct soap *soap, const char *tag, _sai__GetTlsOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTlsOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTlsOptionsResponse, sizeof(_sai__GetTlsOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTlsOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTlsOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetTlsOptionsResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, "sai:TlsOptions", &(((_sai__GetTlsOptionsResponse*)a)->TlsOptions), "sai:TlsOptionsType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || ((_sai__GetTlsOptionsResponse*)a)->TlsOptions.size() > 2)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTlsOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTlsOptionsResponse, 0, sizeof(_sai__GetTlsOptionsResponse), 0, soap_copy__sai__GetTlsOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTlsOptionsResponse * SOAP_FMAC6 soap_new__sai__GetTlsOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTlsOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTlsOptionsResponse(struct soap *soap, _sai__GetTlsOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTlsOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__GetTlsOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTlsOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTlsOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTlsOptionsResponse; + if (size) + *size = sizeof(_sai__GetTlsOptionsResponse); + ((_sai__GetTlsOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTlsOptionsResponse[n]; + if (size) + *size = n * sizeof(_sai__GetTlsOptionsResponse); + for (int i = 0; i < n; i++) + ((_sai__GetTlsOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTlsOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTlsOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTlsOptionsResponse %p -> %p\n", q, p)); + *(_sai__GetTlsOptionsResponse*)p = *(_sai__GetTlsOptionsResponse*)q; +} + +void _sai__GetTlsOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetTlsOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetTlsOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTlsOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTlsOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTlsOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTlsOptions(struct soap *soap, const char *tag, int id, const _sai__GetTlsOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTlsOptions), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTlsOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTlsOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTlsOptions * SOAP_FMAC4 soap_get__sai__GetTlsOptions(struct soap *soap, _sai__GetTlsOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTlsOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTlsOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTlsOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTlsOptions * SOAP_FMAC4 soap_in__sai__GetTlsOptions(struct soap *soap, const char *tag, _sai__GetTlsOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTlsOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTlsOptions, sizeof(_sai__GetTlsOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTlsOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTlsOptions *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTlsOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTlsOptions, 0, sizeof(_sai__GetTlsOptions), 0, soap_copy__sai__GetTlsOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTlsOptions * SOAP_FMAC6 soap_new__sai__GetTlsOptions(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTlsOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTlsOptions(struct soap *soap, _sai__GetTlsOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTlsOptions * SOAP_FMAC4 soap_instantiate__sai__GetTlsOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTlsOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTlsOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTlsOptions; + if (size) + *size = sizeof(_sai__GetTlsOptions); + ((_sai__GetTlsOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTlsOptions[n]; + if (size) + *size = n * sizeof(_sai__GetTlsOptions); + for (int i = 0; i < n; i++) + ((_sai__GetTlsOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTlsOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTlsOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTlsOptions %p -> %p\n", q, p)); + *(_sai__GetTlsOptions*)p = *(_sai__GetTlsOptions*)q; +} + +void _sai__SetTlsOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetTlsOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetTlsOptionsResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetTlsOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTlsOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTlsOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTlsOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTlsOptionsResponse(struct soap *soap, const char *tag, int id, const _sai__SetTlsOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTlsOptionsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetTlsOptionsResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTlsOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTlsOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTlsOptionsResponse * SOAP_FMAC4 soap_get__sai__SetTlsOptionsResponse(struct soap *soap, _sai__SetTlsOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTlsOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTlsOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTlsOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTlsOptionsResponse * SOAP_FMAC4 soap_in__sai__SetTlsOptionsResponse(struct soap *soap, const char *tag, _sai__SetTlsOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTlsOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTlsOptionsResponse, sizeof(_sai__SetTlsOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTlsOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTlsOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetTlsOptionsResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTlsOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTlsOptionsResponse, 0, sizeof(_sai__SetTlsOptionsResponse), 0, soap_copy__sai__SetTlsOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTlsOptionsResponse * SOAP_FMAC6 soap_new__sai__SetTlsOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTlsOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTlsOptionsResponse(struct soap *soap, _sai__SetTlsOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTlsOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__SetTlsOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTlsOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTlsOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTlsOptionsResponse; + if (size) + *size = sizeof(_sai__SetTlsOptionsResponse); + ((_sai__SetTlsOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTlsOptionsResponse[n]; + if (size) + *size = n * sizeof(_sai__SetTlsOptionsResponse); + for (int i = 0; i < n; i++) + ((_sai__SetTlsOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTlsOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTlsOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTlsOptionsResponse %p -> %p\n", q, p)); + *(_sai__SetTlsOptionsResponse*)p = *(_sai__SetTlsOptionsResponse*)q; +} + +void _sai__SetTlsOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, &((_sai__SetTlsOptions*)this)->TlsOptions); + /* transient soap skipped */ +} + +void _sai__SetTlsOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, &((_sai__SetTlsOptions*)this)->TlsOptions); + /* transient soap skipped */ +} + +int _sai__SetTlsOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTlsOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTlsOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTlsOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTlsOptions(struct soap *soap, const char *tag, int id, const _sai__SetTlsOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTlsOptions), type); + soap_out_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, "sai:TlsOptions", -1, &(((_sai__SetTlsOptions*)a)->TlsOptions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTlsOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTlsOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTlsOptions * SOAP_FMAC4 soap_get__sai__SetTlsOptions(struct soap *soap, _sai__SetTlsOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTlsOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTlsOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTlsOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTlsOptions * SOAP_FMAC4 soap_in__sai__SetTlsOptions(struct soap *soap, const char *tag, _sai__SetTlsOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTlsOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTlsOptions, sizeof(_sai__SetTlsOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTlsOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTlsOptions *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, "sai:TlsOptions", &(((_sai__SetTlsOptions*)a)->TlsOptions), "sai:TlsOptionsType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((_sai__SetTlsOptions*)a)->TlsOptions.size() > 2)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTlsOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTlsOptions, 0, sizeof(_sai__SetTlsOptions), 0, soap_copy__sai__SetTlsOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTlsOptions * SOAP_FMAC6 soap_new__sai__SetTlsOptions(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTlsOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTlsOptions(struct soap *soap, _sai__SetTlsOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTlsOptions * SOAP_FMAC4 soap_instantiate__sai__SetTlsOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTlsOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTlsOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTlsOptions; + if (size) + *size = sizeof(_sai__SetTlsOptions); + ((_sai__SetTlsOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTlsOptions[n]; + if (size) + *size = n * sizeof(_sai__SetTlsOptions); + for (int i = 0; i < n; i++) + ((_sai__SetTlsOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTlsOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTlsOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTlsOptions %p -> %p\n", q, p)); + *(_sai__SetTlsOptions*)p = *(_sai__SetTlsOptions*)q; +} + +void _sai__GetEnabledInterfacesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfsai__EnabledInterfacesType(soap, &((_sai__GetEnabledInterfacesResponse*)this)->EnabledInterfaces); + /* transient soap skipped */ +} + +void _sai__GetEnabledInterfacesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetEnabledInterfacesResponse*)this)->StatusCode); + soap_default_std__vectorTemplateOfsai__EnabledInterfacesType(soap, &((_sai__GetEnabledInterfacesResponse*)this)->EnabledInterfaces); + /* transient soap skipped */ +} + +int _sai__GetEnabledInterfacesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetEnabledInterfacesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetEnabledInterfacesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetEnabledInterfacesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetEnabledInterfacesResponse(struct soap *soap, const char *tag, int id, const _sai__GetEnabledInterfacesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetEnabledInterfacesResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetEnabledInterfacesResponse*)a)->StatusCode), ""); + soap_out_std__vectorTemplateOfsai__EnabledInterfacesType(soap, "sai:EnabledInterfaces", -1, &(((_sai__GetEnabledInterfacesResponse*)a)->EnabledInterfaces), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetEnabledInterfacesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetEnabledInterfacesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_get__sai__GetEnabledInterfacesResponse(struct soap *soap, _sai__GetEnabledInterfacesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetEnabledInterfacesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetEnabledInterfacesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetEnabledInterfacesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_in__sai__GetEnabledInterfacesResponse(struct soap *soap, const char *tag, _sai__GetEnabledInterfacesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetEnabledInterfacesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetEnabledInterfacesResponse, sizeof(_sai__GetEnabledInterfacesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetEnabledInterfacesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetEnabledInterfacesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetEnabledInterfacesResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfsai__EnabledInterfacesType(soap, "sai:EnabledInterfaces", &(((_sai__GetEnabledInterfacesResponse*)a)->EnabledInterfaces), "sai:EnabledInterfacesType")) + continue; + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetEnabledInterfacesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetEnabledInterfacesResponse, 0, sizeof(_sai__GetEnabledInterfacesResponse), 0, soap_copy__sai__GetEnabledInterfacesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetEnabledInterfacesResponse * SOAP_FMAC6 soap_new__sai__GetEnabledInterfacesResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetEnabledInterfacesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetEnabledInterfacesResponse(struct soap *soap, _sai__GetEnabledInterfacesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse * SOAP_FMAC4 soap_instantiate__sai__GetEnabledInterfacesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetEnabledInterfacesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetEnabledInterfacesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetEnabledInterfacesResponse; + if (size) + *size = sizeof(_sai__GetEnabledInterfacesResponse); + ((_sai__GetEnabledInterfacesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetEnabledInterfacesResponse[n]; + if (size) + *size = n * sizeof(_sai__GetEnabledInterfacesResponse); + for (int i = 0; i < n; i++) + ((_sai__GetEnabledInterfacesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetEnabledInterfacesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetEnabledInterfacesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetEnabledInterfacesResponse %p -> %p\n", q, p)); + *(_sai__GetEnabledInterfacesResponse*)p = *(_sai__GetEnabledInterfacesResponse*)q; +} + +void _sai__GetEnabledInterfaces::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetEnabledInterfaces::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetEnabledInterfaces::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetEnabledInterfaces); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetEnabledInterfaces::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetEnabledInterfaces(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetEnabledInterfaces(struct soap *soap, const char *tag, int id, const _sai__GetEnabledInterfaces *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetEnabledInterfaces), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetEnabledInterfaces::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetEnabledInterfaces(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetEnabledInterfaces * SOAP_FMAC4 soap_get__sai__GetEnabledInterfaces(struct soap *soap, _sai__GetEnabledInterfaces *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetEnabledInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetEnabledInterfaces::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetEnabledInterfaces(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetEnabledInterfaces * SOAP_FMAC4 soap_in__sai__GetEnabledInterfaces(struct soap *soap, const char *tag, _sai__GetEnabledInterfaces *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetEnabledInterfaces *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetEnabledInterfaces, sizeof(_sai__GetEnabledInterfaces), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetEnabledInterfaces) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetEnabledInterfaces *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetEnabledInterfaces *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetEnabledInterfaces, 0, sizeof(_sai__GetEnabledInterfaces), 0, soap_copy__sai__GetEnabledInterfaces); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetEnabledInterfaces * SOAP_FMAC6 soap_new__sai__GetEnabledInterfaces(struct soap *soap, int n) +{ return soap_instantiate__sai__GetEnabledInterfaces(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetEnabledInterfaces(struct soap *soap, _sai__GetEnabledInterfaces *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetEnabledInterfaces * SOAP_FMAC4 soap_instantiate__sai__GetEnabledInterfaces(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetEnabledInterfaces(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetEnabledInterfaces, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetEnabledInterfaces; + if (size) + *size = sizeof(_sai__GetEnabledInterfaces); + ((_sai__GetEnabledInterfaces*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetEnabledInterfaces[n]; + if (size) + *size = n * sizeof(_sai__GetEnabledInterfaces); + for (int i = 0; i < n; i++) + ((_sai__GetEnabledInterfaces*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetEnabledInterfaces*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetEnabledInterfaces(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetEnabledInterfaces %p -> %p\n", q, p)); + *(_sai__GetEnabledInterfaces*)p = *(_sai__GetEnabledInterfaces*)q; +} + +void _sai__SetEnabledInterfacesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetEnabledInterfacesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetEnabledInterfacesResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetEnabledInterfacesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetEnabledInterfacesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetEnabledInterfacesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetEnabledInterfacesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetEnabledInterfacesResponse(struct soap *soap, const char *tag, int id, const _sai__SetEnabledInterfacesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetEnabledInterfacesResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetEnabledInterfacesResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetEnabledInterfacesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetEnabledInterfacesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse * SOAP_FMAC4 soap_get__sai__SetEnabledInterfacesResponse(struct soap *soap, _sai__SetEnabledInterfacesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetEnabledInterfacesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetEnabledInterfacesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetEnabledInterfacesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse * SOAP_FMAC4 soap_in__sai__SetEnabledInterfacesResponse(struct soap *soap, const char *tag, _sai__SetEnabledInterfacesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetEnabledInterfacesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetEnabledInterfacesResponse, sizeof(_sai__SetEnabledInterfacesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetEnabledInterfacesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetEnabledInterfacesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetEnabledInterfacesResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetEnabledInterfacesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetEnabledInterfacesResponse, 0, sizeof(_sai__SetEnabledInterfacesResponse), 0, soap_copy__sai__SetEnabledInterfacesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetEnabledInterfacesResponse * SOAP_FMAC6 soap_new__sai__SetEnabledInterfacesResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetEnabledInterfacesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetEnabledInterfacesResponse(struct soap *soap, _sai__SetEnabledInterfacesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse * SOAP_FMAC4 soap_instantiate__sai__SetEnabledInterfacesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetEnabledInterfacesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetEnabledInterfacesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetEnabledInterfacesResponse; + if (size) + *size = sizeof(_sai__SetEnabledInterfacesResponse); + ((_sai__SetEnabledInterfacesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetEnabledInterfacesResponse[n]; + if (size) + *size = n * sizeof(_sai__SetEnabledInterfacesResponse); + for (int i = 0; i < n; i++) + ((_sai__SetEnabledInterfacesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetEnabledInterfacesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetEnabledInterfacesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetEnabledInterfacesResponse %p -> %p\n", q, p)); + *(_sai__SetEnabledInterfacesResponse*)p = *(_sai__SetEnabledInterfacesResponse*)q; +} + +void _sai__SetEnabledInterfaces::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfsai__EnabledInterfacesType(soap, &((_sai__SetEnabledInterfaces*)this)->EnabledInterfaces); + /* transient soap skipped */ +} + +void _sai__SetEnabledInterfaces::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfsai__EnabledInterfacesType(soap, &((_sai__SetEnabledInterfaces*)this)->EnabledInterfaces); + /* transient soap skipped */ +} + +int _sai__SetEnabledInterfaces::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetEnabledInterfaces); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetEnabledInterfaces::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetEnabledInterfaces(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetEnabledInterfaces(struct soap *soap, const char *tag, int id, const _sai__SetEnabledInterfaces *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetEnabledInterfaces), type); + soap_out_std__vectorTemplateOfsai__EnabledInterfacesType(soap, "sai:EnabledInterfaces", -1, &(((_sai__SetEnabledInterfaces*)a)->EnabledInterfaces), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetEnabledInterfaces::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetEnabledInterfaces(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetEnabledInterfaces * SOAP_FMAC4 soap_get__sai__SetEnabledInterfaces(struct soap *soap, _sai__SetEnabledInterfaces *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetEnabledInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetEnabledInterfaces::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetEnabledInterfaces(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetEnabledInterfaces * SOAP_FMAC4 soap_in__sai__SetEnabledInterfaces(struct soap *soap, const char *tag, _sai__SetEnabledInterfaces *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetEnabledInterfaces *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetEnabledInterfaces, sizeof(_sai__SetEnabledInterfaces), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetEnabledInterfaces) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetEnabledInterfaces *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfsai__EnabledInterfacesType(soap, "sai:EnabledInterfaces", &(((_sai__SetEnabledInterfaces*)a)->EnabledInterfaces), "sai:EnabledInterfacesType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetEnabledInterfaces *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetEnabledInterfaces, 0, sizeof(_sai__SetEnabledInterfaces), 0, soap_copy__sai__SetEnabledInterfaces); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetEnabledInterfaces * SOAP_FMAC6 soap_new__sai__SetEnabledInterfaces(struct soap *soap, int n) +{ return soap_instantiate__sai__SetEnabledInterfaces(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetEnabledInterfaces(struct soap *soap, _sai__SetEnabledInterfaces *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetEnabledInterfaces * SOAP_FMAC4 soap_instantiate__sai__SetEnabledInterfaces(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetEnabledInterfaces(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetEnabledInterfaces, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetEnabledInterfaces; + if (size) + *size = sizeof(_sai__SetEnabledInterfaces); + ((_sai__SetEnabledInterfaces*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetEnabledInterfaces[n]; + if (size) + *size = n * sizeof(_sai__SetEnabledInterfaces); + for (int i = 0; i < n; i++) + ((_sai__SetEnabledInterfaces*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetEnabledInterfaces*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetEnabledInterfaces(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetEnabledInterfaces %p -> %p\n", q, p)); + *(_sai__SetEnabledInterfaces*)p = *(_sai__SetEnabledInterfaces*)q; +} + +void _sai__GetKerberosOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__KerberosOptionsType(soap, &((_sai__GetKerberosOptionsResponse*)this)->KerberosOptions); + /* transient soap skipped */ +} + +void _sai__GetKerberosOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetKerberosOptionsResponse*)this)->StatusCode); + ((_sai__GetKerberosOptionsResponse*)this)->KerberosOptions = NULL; + /* transient soap skipped */ +} + +int _sai__GetKerberosOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetKerberosOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetKerberosOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetKerberosOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetKerberosOptionsResponse(struct soap *soap, const char *tag, int id, const _sai__GetKerberosOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetKerberosOptionsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetKerberosOptionsResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__KerberosOptionsType(soap, "sai:KerberosOptions", -1, &(((_sai__GetKerberosOptionsResponse*)a)->KerberosOptions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetKerberosOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetKerberosOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetKerberosOptionsResponse * SOAP_FMAC4 soap_get__sai__GetKerberosOptionsResponse(struct soap *soap, _sai__GetKerberosOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetKerberosOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetKerberosOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetKerberosOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetKerberosOptionsResponse * SOAP_FMAC4 soap_in__sai__GetKerberosOptionsResponse(struct soap *soap, const char *tag, _sai__GetKerberosOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetKerberosOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetKerberosOptionsResponse, sizeof(_sai__GetKerberosOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetKerberosOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetKerberosOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_KerberosOptions1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetKerberosOptionsResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_KerberosOptions1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__KerberosOptionsType(soap, "sai:KerberosOptions", &(((_sai__GetKerberosOptionsResponse*)a)->KerberosOptions), "sai:KerberosOptionsType")) + { soap_flag_KerberosOptions1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_KerberosOptions1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetKerberosOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetKerberosOptionsResponse, 0, sizeof(_sai__GetKerberosOptionsResponse), 0, soap_copy__sai__GetKerberosOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetKerberosOptionsResponse * SOAP_FMAC6 soap_new__sai__GetKerberosOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetKerberosOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetKerberosOptionsResponse(struct soap *soap, _sai__GetKerberosOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetKerberosOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__GetKerberosOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetKerberosOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetKerberosOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetKerberosOptionsResponse; + if (size) + *size = sizeof(_sai__GetKerberosOptionsResponse); + ((_sai__GetKerberosOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetKerberosOptionsResponse[n]; + if (size) + *size = n * sizeof(_sai__GetKerberosOptionsResponse); + for (int i = 0; i < n; i++) + ((_sai__GetKerberosOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetKerberosOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetKerberosOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetKerberosOptionsResponse %p -> %p\n", q, p)); + *(_sai__GetKerberosOptionsResponse*)p = *(_sai__GetKerberosOptionsResponse*)q; +} + +void _sai__GetKerberosOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetKerberosOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetKerberosOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetKerberosOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetKerberosOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetKerberosOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetKerberosOptions(struct soap *soap, const char *tag, int id, const _sai__GetKerberosOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetKerberosOptions), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetKerberosOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetKerberosOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetKerberosOptions * SOAP_FMAC4 soap_get__sai__GetKerberosOptions(struct soap *soap, _sai__GetKerberosOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetKerberosOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetKerberosOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetKerberosOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetKerberosOptions * SOAP_FMAC4 soap_in__sai__GetKerberosOptions(struct soap *soap, const char *tag, _sai__GetKerberosOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetKerberosOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetKerberosOptions, sizeof(_sai__GetKerberosOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetKerberosOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetKerberosOptions *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetKerberosOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetKerberosOptions, 0, sizeof(_sai__GetKerberosOptions), 0, soap_copy__sai__GetKerberosOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetKerberosOptions * SOAP_FMAC6 soap_new__sai__GetKerberosOptions(struct soap *soap, int n) +{ return soap_instantiate__sai__GetKerberosOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetKerberosOptions(struct soap *soap, _sai__GetKerberosOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetKerberosOptions * SOAP_FMAC4 soap_instantiate__sai__GetKerberosOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetKerberosOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetKerberosOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetKerberosOptions; + if (size) + *size = sizeof(_sai__GetKerberosOptions); + ((_sai__GetKerberosOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetKerberosOptions[n]; + if (size) + *size = n * sizeof(_sai__GetKerberosOptions); + for (int i = 0; i < n; i++) + ((_sai__GetKerberosOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetKerberosOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetKerberosOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetKerberosOptions %p -> %p\n", q, p)); + *(_sai__GetKerberosOptions*)p = *(_sai__GetKerberosOptions*)q; +} + +void _sai__SetKerberosOptionsResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetKerberosOptionsResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetKerberosOptionsResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetKerberosOptionsResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetKerberosOptionsResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetKerberosOptionsResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetKerberosOptionsResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetKerberosOptionsResponse(struct soap *soap, const char *tag, int id, const _sai__SetKerberosOptionsResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetKerberosOptionsResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetKerberosOptionsResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetKerberosOptionsResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetKerberosOptionsResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetKerberosOptionsResponse * SOAP_FMAC4 soap_get__sai__SetKerberosOptionsResponse(struct soap *soap, _sai__SetKerberosOptionsResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetKerberosOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetKerberosOptionsResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetKerberosOptionsResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetKerberosOptionsResponse * SOAP_FMAC4 soap_in__sai__SetKerberosOptionsResponse(struct soap *soap, const char *tag, _sai__SetKerberosOptionsResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetKerberosOptionsResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetKerberosOptionsResponse, sizeof(_sai__SetKerberosOptionsResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetKerberosOptionsResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetKerberosOptionsResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetKerberosOptionsResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetKerberosOptionsResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetKerberosOptionsResponse, 0, sizeof(_sai__SetKerberosOptionsResponse), 0, soap_copy__sai__SetKerberosOptionsResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetKerberosOptionsResponse * SOAP_FMAC6 soap_new__sai__SetKerberosOptionsResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetKerberosOptionsResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetKerberosOptionsResponse(struct soap *soap, _sai__SetKerberosOptionsResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetKerberosOptionsResponse * SOAP_FMAC4 soap_instantiate__sai__SetKerberosOptionsResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetKerberosOptionsResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetKerberosOptionsResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetKerberosOptionsResponse; + if (size) + *size = sizeof(_sai__SetKerberosOptionsResponse); + ((_sai__SetKerberosOptionsResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetKerberosOptionsResponse[n]; + if (size) + *size = n * sizeof(_sai__SetKerberosOptionsResponse); + for (int i = 0; i < n; i++) + ((_sai__SetKerberosOptionsResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetKerberosOptionsResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetKerberosOptionsResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetKerberosOptionsResponse %p -> %p\n", q, p)); + *(_sai__SetKerberosOptionsResponse*)p = *(_sai__SetKerberosOptionsResponse*)q; +} + +void _sai__SetKerberosOptions::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__KerberosOptionsType(soap, &((_sai__SetKerberosOptions*)this)->KerberosOptions); + /* transient soap skipped */ +} + +void _sai__SetKerberosOptions::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetKerberosOptions*)this)->KerberosOptions = NULL; + /* transient soap skipped */ +} + +int _sai__SetKerberosOptions::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetKerberosOptions); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetKerberosOptions::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetKerberosOptions(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetKerberosOptions(struct soap *soap, const char *tag, int id, const _sai__SetKerberosOptions *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetKerberosOptions), type); + soap_out_PointerTosai__KerberosOptionsType(soap, "sai:KerberosOptions", -1, &(((_sai__SetKerberosOptions*)a)->KerberosOptions), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetKerberosOptions::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetKerberosOptions(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetKerberosOptions * SOAP_FMAC4 soap_get__sai__SetKerberosOptions(struct soap *soap, _sai__SetKerberosOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetKerberosOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetKerberosOptions::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetKerberosOptions(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetKerberosOptions * SOAP_FMAC4 soap_in__sai__SetKerberosOptions(struct soap *soap, const char *tag, _sai__SetKerberosOptions *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetKerberosOptions *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetKerberosOptions, sizeof(_sai__SetKerberosOptions), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetKerberosOptions) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetKerberosOptions *)a->soap_in(soap, tag, type); + } + } + short soap_flag_KerberosOptions1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_KerberosOptions1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__KerberosOptionsType(soap, "sai:KerberosOptions", &(((_sai__SetKerberosOptions*)a)->KerberosOptions), "sai:KerberosOptionsType")) + { soap_flag_KerberosOptions1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetKerberosOptions *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetKerberosOptions, 0, sizeof(_sai__SetKerberosOptions), 0, soap_copy__sai__SetKerberosOptions); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetKerberosOptions * SOAP_FMAC6 soap_new__sai__SetKerberosOptions(struct soap *soap, int n) +{ return soap_instantiate__sai__SetKerberosOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetKerberosOptions(struct soap *soap, _sai__SetKerberosOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetKerberosOptions * SOAP_FMAC4 soap_instantiate__sai__SetKerberosOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetKerberosOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetKerberosOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetKerberosOptions; + if (size) + *size = sizeof(_sai__SetKerberosOptions); + ((_sai__SetKerberosOptions*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetKerberosOptions[n]; + if (size) + *size = n * sizeof(_sai__SetKerberosOptions); + for (int i = 0; i < n; i++) + ((_sai__SetKerberosOptions*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetKerberosOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetKerberosOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetKerberosOptions %p -> %p\n", q, p)); + *(_sai__SetKerberosOptions*)p = *(_sai__SetKerberosOptions*)q; +} + +void _sai__GetDigestRealmResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetDigestRealmResponse*)this)->DigestRealm, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_sai__GetDigestRealmResponse*)this)->DigestRealm); + /* transient soap skipped */ +} + +void _sai__GetDigestRealmResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetDigestRealmResponse*)this)->StatusCode); + soap_default_std__string(soap, &((_sai__GetDigestRealmResponse*)this)->DigestRealm); + /* transient soap skipped */ +} + +int _sai__GetDigestRealmResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetDigestRealmResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetDigestRealmResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetDigestRealmResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetDigestRealmResponse(struct soap *soap, const char *tag, int id, const _sai__GetDigestRealmResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetDigestRealmResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetDigestRealmResponse*)a)->StatusCode), ""); + soap_out_std__string(soap, "sai:DigestRealm", -1, &(((_sai__GetDigestRealmResponse*)a)->DigestRealm), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetDigestRealmResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetDigestRealmResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetDigestRealmResponse * SOAP_FMAC4 soap_get__sai__GetDigestRealmResponse(struct soap *soap, _sai__GetDigestRealmResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetDigestRealmResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetDigestRealmResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetDigestRealmResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetDigestRealmResponse * SOAP_FMAC4 soap_in__sai__GetDigestRealmResponse(struct soap *soap, const char *tag, _sai__GetDigestRealmResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetDigestRealmResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetDigestRealmResponse, sizeof(_sai__GetDigestRealmResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetDigestRealmResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetDigestRealmResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_DigestRealm1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetDigestRealmResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_DigestRealm1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "sai:DigestRealm", &(((_sai__GetDigestRealmResponse*)a)->DigestRealm), "xsd:string")) + { soap_flag_DigestRealm1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_DigestRealm1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetDigestRealmResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetDigestRealmResponse, 0, sizeof(_sai__GetDigestRealmResponse), 0, soap_copy__sai__GetDigestRealmResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetDigestRealmResponse * SOAP_FMAC6 soap_new__sai__GetDigestRealmResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetDigestRealmResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetDigestRealmResponse(struct soap *soap, _sai__GetDigestRealmResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetDigestRealmResponse * SOAP_FMAC4 soap_instantiate__sai__GetDigestRealmResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetDigestRealmResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetDigestRealmResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetDigestRealmResponse; + if (size) + *size = sizeof(_sai__GetDigestRealmResponse); + ((_sai__GetDigestRealmResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetDigestRealmResponse[n]; + if (size) + *size = n * sizeof(_sai__GetDigestRealmResponse); + for (int i = 0; i < n; i++) + ((_sai__GetDigestRealmResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetDigestRealmResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetDigestRealmResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetDigestRealmResponse %p -> %p\n", q, p)); + *(_sai__GetDigestRealmResponse*)p = *(_sai__GetDigestRealmResponse*)q; +} + +void _sai__GetDigestRealm::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetDigestRealm::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetDigestRealm::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetDigestRealm); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetDigestRealm::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetDigestRealm(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetDigestRealm(struct soap *soap, const char *tag, int id, const _sai__GetDigestRealm *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetDigestRealm), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetDigestRealm::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetDigestRealm(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetDigestRealm * SOAP_FMAC4 soap_get__sai__GetDigestRealm(struct soap *soap, _sai__GetDigestRealm *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetDigestRealm(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetDigestRealm::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetDigestRealm(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetDigestRealm * SOAP_FMAC4 soap_in__sai__GetDigestRealm(struct soap *soap, const char *tag, _sai__GetDigestRealm *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetDigestRealm *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetDigestRealm, sizeof(_sai__GetDigestRealm), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetDigestRealm) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetDigestRealm *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetDigestRealm *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetDigestRealm, 0, sizeof(_sai__GetDigestRealm), 0, soap_copy__sai__GetDigestRealm); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetDigestRealm * SOAP_FMAC6 soap_new__sai__GetDigestRealm(struct soap *soap, int n) +{ return soap_instantiate__sai__GetDigestRealm(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetDigestRealm(struct soap *soap, _sai__GetDigestRealm *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetDigestRealm * SOAP_FMAC4 soap_instantiate__sai__GetDigestRealm(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetDigestRealm(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetDigestRealm, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetDigestRealm; + if (size) + *size = sizeof(_sai__GetDigestRealm); + ((_sai__GetDigestRealm*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetDigestRealm[n]; + if (size) + *size = n * sizeof(_sai__GetDigestRealm); + for (int i = 0; i < n; i++) + ((_sai__GetDigestRealm*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetDigestRealm*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetDigestRealm(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetDigestRealm %p -> %p\n", q, p)); + *(_sai__GetDigestRealm*)p = *(_sai__GetDigestRealm*)q; +} + +void _sai__SetAdminAclEntryExResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetAdminAclEntryExResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetAdminAclEntryExResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetAdminAclEntryExResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetAdminAclEntryExResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetAdminAclEntryExResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetAdminAclEntryExResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAdminAclEntryExResponse(struct soap *soap, const char *tag, int id, const _sai__SetAdminAclEntryExResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetAdminAclEntryExResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetAdminAclEntryExResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetAdminAclEntryExResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetAdminAclEntryExResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse * SOAP_FMAC4 soap_get__sai__SetAdminAclEntryExResponse(struct soap *soap, _sai__SetAdminAclEntryExResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetAdminAclEntryExResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetAdminAclEntryExResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetAdminAclEntryExResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse * SOAP_FMAC4 soap_in__sai__SetAdminAclEntryExResponse(struct soap *soap, const char *tag, _sai__SetAdminAclEntryExResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetAdminAclEntryExResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetAdminAclEntryExResponse, sizeof(_sai__SetAdminAclEntryExResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetAdminAclEntryExResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetAdminAclEntryExResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetAdminAclEntryExResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetAdminAclEntryExResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetAdminAclEntryExResponse, 0, sizeof(_sai__SetAdminAclEntryExResponse), 0, soap_copy__sai__SetAdminAclEntryExResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetAdminAclEntryExResponse * SOAP_FMAC6 soap_new__sai__SetAdminAclEntryExResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetAdminAclEntryExResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAdminAclEntryExResponse(struct soap *soap, _sai__SetAdminAclEntryExResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse * SOAP_FMAC4 soap_instantiate__sai__SetAdminAclEntryExResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetAdminAclEntryExResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetAdminAclEntryExResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetAdminAclEntryExResponse; + if (size) + *size = sizeof(_sai__SetAdminAclEntryExResponse); + ((_sai__SetAdminAclEntryExResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetAdminAclEntryExResponse[n]; + if (size) + *size = n * sizeof(_sai__SetAdminAclEntryExResponse); + for (int i = 0; i < n; i++) + ((_sai__SetAdminAclEntryExResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetAdminAclEntryExResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAdminAclEntryExResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetAdminAclEntryExResponse %p -> %p\n", q, p)); + *(_sai__SetAdminAclEntryExResponse*)p = *(_sai__SetAdminAclEntryExResponse*)q; +} + +void _sai__SetAdminAclEntryEx::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__AdminAclEntryExType(soap, &((_sai__SetAdminAclEntryEx*)this)->EntryEx); + /* transient soap skipped */ +} + +void _sai__SetAdminAclEntryEx::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetAdminAclEntryEx*)this)->EntryEx = NULL; + /* transient soap skipped */ +} + +int _sai__SetAdminAclEntryEx::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetAdminAclEntryEx); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetAdminAclEntryEx::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetAdminAclEntryEx(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAdminAclEntryEx(struct soap *soap, const char *tag, int id, const _sai__SetAdminAclEntryEx *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetAdminAclEntryEx), type); + soap_out_PointerTosai__AdminAclEntryExType(soap, "sai:EntryEx", -1, &(((_sai__SetAdminAclEntryEx*)a)->EntryEx), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetAdminAclEntryEx::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetAdminAclEntryEx(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_get__sai__SetAdminAclEntryEx(struct soap *soap, _sai__SetAdminAclEntryEx *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetAdminAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetAdminAclEntryEx::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetAdminAclEntryEx(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_in__sai__SetAdminAclEntryEx(struct soap *soap, const char *tag, _sai__SetAdminAclEntryEx *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetAdminAclEntryEx *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetAdminAclEntryEx, sizeof(_sai__SetAdminAclEntryEx), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetAdminAclEntryEx) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetAdminAclEntryEx *)a->soap_in(soap, tag, type); + } + } + short soap_flag_EntryEx1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_EntryEx1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__AdminAclEntryExType(soap, "sai:EntryEx", &(((_sai__SetAdminAclEntryEx*)a)->EntryEx), "sai:AdminAclEntryExType")) + { soap_flag_EntryEx1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_EntryEx1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetAdminAclEntryEx *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetAdminAclEntryEx, 0, sizeof(_sai__SetAdminAclEntryEx), 0, soap_copy__sai__SetAdminAclEntryEx); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetAdminAclEntryEx * SOAP_FMAC6 soap_new__sai__SetAdminAclEntryEx(struct soap *soap, int n) +{ return soap_instantiate__sai__SetAdminAclEntryEx(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAdminAclEntryEx(struct soap *soap, _sai__SetAdminAclEntryEx *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_instantiate__sai__SetAdminAclEntryEx(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetAdminAclEntryEx(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetAdminAclEntryEx, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetAdminAclEntryEx; + if (size) + *size = sizeof(_sai__SetAdminAclEntryEx); + ((_sai__SetAdminAclEntryEx*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetAdminAclEntryEx[n]; + if (size) + *size = n * sizeof(_sai__SetAdminAclEntryEx); + for (int i = 0; i < n; i++) + ((_sai__SetAdminAclEntryEx*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetAdminAclEntryEx*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAdminAclEntryEx(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetAdminAclEntryEx %p -> %p\n", q, p)); + *(_sai__SetAdminAclEntryEx*)p = *(_sai__SetAdminAclEntryEx*)q; +} + +void _sai__UpdateUserAclEntryExResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__UpdateUserAclEntryExResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__UpdateUserAclEntryExResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__UpdateUserAclEntryExResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__UpdateUserAclEntryExResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__UpdateUserAclEntryExResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__UpdateUserAclEntryExResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateUserAclEntryExResponse(struct soap *soap, const char *tag, int id, const _sai__UpdateUserAclEntryExResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__UpdateUserAclEntryExResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__UpdateUserAclEntryExResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__UpdateUserAclEntryExResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__UpdateUserAclEntryExResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse * SOAP_FMAC4 soap_get__sai__UpdateUserAclEntryExResponse(struct soap *soap, _sai__UpdateUserAclEntryExResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__UpdateUserAclEntryExResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__UpdateUserAclEntryExResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__UpdateUserAclEntryExResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse * SOAP_FMAC4 soap_in__sai__UpdateUserAclEntryExResponse(struct soap *soap, const char *tag, _sai__UpdateUserAclEntryExResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__UpdateUserAclEntryExResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__UpdateUserAclEntryExResponse, sizeof(_sai__UpdateUserAclEntryExResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__UpdateUserAclEntryExResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__UpdateUserAclEntryExResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__UpdateUserAclEntryExResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__UpdateUserAclEntryExResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__UpdateUserAclEntryExResponse, 0, sizeof(_sai__UpdateUserAclEntryExResponse), 0, soap_copy__sai__UpdateUserAclEntryExResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__UpdateUserAclEntryExResponse * SOAP_FMAC6 soap_new__sai__UpdateUserAclEntryExResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__UpdateUserAclEntryExResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateUserAclEntryExResponse(struct soap *soap, _sai__UpdateUserAclEntryExResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse * SOAP_FMAC4 soap_instantiate__sai__UpdateUserAclEntryExResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__UpdateUserAclEntryExResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__UpdateUserAclEntryExResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__UpdateUserAclEntryExResponse; + if (size) + *size = sizeof(_sai__UpdateUserAclEntryExResponse); + ((_sai__UpdateUserAclEntryExResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__UpdateUserAclEntryExResponse[n]; + if (size) + *size = n * sizeof(_sai__UpdateUserAclEntryExResponse); + for (int i = 0; i < n; i++) + ((_sai__UpdateUserAclEntryExResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__UpdateUserAclEntryExResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateUserAclEntryExResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__UpdateUserAclEntryExResponse %p -> %p\n", q, p)); + *(_sai__UpdateUserAclEntryExResponse*)p = *(_sai__UpdateUserAclEntryExResponse*)q; +} + +void _sai__UpdateUserAclEntryEx::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__UserAclEntryExType(soap, &((_sai__UpdateUserAclEntryEx*)this)->EntryEx); + /* transient soap skipped */ +} + +void _sai__UpdateUserAclEntryEx::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__UserAclEntryHandleType(soap, &((_sai__UpdateUserAclEntryEx*)this)->Handle); + ((_sai__UpdateUserAclEntryEx*)this)->EntryEx = NULL; + /* transient soap skipped */ +} + +int _sai__UpdateUserAclEntryEx::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__UpdateUserAclEntryEx); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__UpdateUserAclEntryEx::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__UpdateUserAclEntryEx(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateUserAclEntryEx(struct soap *soap, const char *tag, int id, const _sai__UpdateUserAclEntryEx *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__UpdateUserAclEntryEx), type); + soap_out_sai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((_sai__UpdateUserAclEntryEx*)a)->Handle), ""); + soap_out_PointerTosai__UserAclEntryExType(soap, "sai:EntryEx", -1, &(((_sai__UpdateUserAclEntryEx*)a)->EntryEx), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__UpdateUserAclEntryEx::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__UpdateUserAclEntryEx(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_get__sai__UpdateUserAclEntryEx(struct soap *soap, _sai__UpdateUserAclEntryEx *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__UpdateUserAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__UpdateUserAclEntryEx::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__UpdateUserAclEntryEx(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_in__sai__UpdateUserAclEntryEx(struct soap *soap, const char *tag, _sai__UpdateUserAclEntryEx *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__UpdateUserAclEntryEx *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__UpdateUserAclEntryEx, sizeof(_sai__UpdateUserAclEntryEx), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__UpdateUserAclEntryEx) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__UpdateUserAclEntryEx *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1, soap_flag_EntryEx1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclEntryHandleType(soap, "sai:Handle", &(((_sai__UpdateUserAclEntryEx*)a)->Handle), "sai:UserAclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + if (soap_flag_EntryEx1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UserAclEntryExType(soap, "sai:EntryEx", &(((_sai__UpdateUserAclEntryEx*)a)->EntryEx), "sai:UserAclEntryExType")) + { soap_flag_EntryEx1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0 || soap_flag_EntryEx1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__UpdateUserAclEntryEx *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__UpdateUserAclEntryEx, 0, sizeof(_sai__UpdateUserAclEntryEx), 0, soap_copy__sai__UpdateUserAclEntryEx); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__UpdateUserAclEntryEx * SOAP_FMAC6 soap_new__sai__UpdateUserAclEntryEx(struct soap *soap, int n) +{ return soap_instantiate__sai__UpdateUserAclEntryEx(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateUserAclEntryEx(struct soap *soap, _sai__UpdateUserAclEntryEx *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_instantiate__sai__UpdateUserAclEntryEx(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__UpdateUserAclEntryEx(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__UpdateUserAclEntryEx, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__UpdateUserAclEntryEx; + if (size) + *size = sizeof(_sai__UpdateUserAclEntryEx); + ((_sai__UpdateUserAclEntryEx*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__UpdateUserAclEntryEx[n]; + if (size) + *size = n * sizeof(_sai__UpdateUserAclEntryEx); + for (int i = 0; i < n; i++) + ((_sai__UpdateUserAclEntryEx*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__UpdateUserAclEntryEx*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateUserAclEntryEx(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__UpdateUserAclEntryEx %p -> %p\n", q, p)); + *(_sai__UpdateUserAclEntryEx*)p = *(_sai__UpdateUserAclEntryEx*)q; +} + +void _sai__GetUserAclEntryExResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__UserAclEntryExType(soap, &((_sai__GetUserAclEntryExResponse*)this)->EntryEx); + /* transient soap skipped */ +} + +void _sai__GetUserAclEntryExResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetUserAclEntryExResponse*)this)->StatusCode); + ((_sai__GetUserAclEntryExResponse*)this)->EntryEx = NULL; + /* transient soap skipped */ +} + +int _sai__GetUserAclEntryExResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetUserAclEntryExResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetUserAclEntryExResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetUserAclEntryExResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetUserAclEntryExResponse(struct soap *soap, const char *tag, int id, const _sai__GetUserAclEntryExResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetUserAclEntryExResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetUserAclEntryExResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__UserAclEntryExType(soap, "sai:EntryEx", -1, &(((_sai__GetUserAclEntryExResponse*)a)->EntryEx), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetUserAclEntryExResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetUserAclEntryExResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntryExResponse * SOAP_FMAC4 soap_get__sai__GetUserAclEntryExResponse(struct soap *soap, _sai__GetUserAclEntryExResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetUserAclEntryExResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetUserAclEntryExResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetUserAclEntryExResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntryExResponse * SOAP_FMAC4 soap_in__sai__GetUserAclEntryExResponse(struct soap *soap, const char *tag, _sai__GetUserAclEntryExResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetUserAclEntryExResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetUserAclEntryExResponse, sizeof(_sai__GetUserAclEntryExResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetUserAclEntryExResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetUserAclEntryExResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_EntryEx1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetUserAclEntryExResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_EntryEx1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UserAclEntryExType(soap, "sai:EntryEx", &(((_sai__GetUserAclEntryExResponse*)a)->EntryEx), "sai:UserAclEntryExType")) + { soap_flag_EntryEx1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_EntryEx1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetUserAclEntryExResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetUserAclEntryExResponse, 0, sizeof(_sai__GetUserAclEntryExResponse), 0, soap_copy__sai__GetUserAclEntryExResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetUserAclEntryExResponse * SOAP_FMAC6 soap_new__sai__GetUserAclEntryExResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetUserAclEntryExResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetUserAclEntryExResponse(struct soap *soap, _sai__GetUserAclEntryExResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetUserAclEntryExResponse * SOAP_FMAC4 soap_instantiate__sai__GetUserAclEntryExResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetUserAclEntryExResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetUserAclEntryExResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetUserAclEntryExResponse; + if (size) + *size = sizeof(_sai__GetUserAclEntryExResponse); + ((_sai__GetUserAclEntryExResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetUserAclEntryExResponse[n]; + if (size) + *size = n * sizeof(_sai__GetUserAclEntryExResponse); + for (int i = 0; i < n; i++) + ((_sai__GetUserAclEntryExResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetUserAclEntryExResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetUserAclEntryExResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetUserAclEntryExResponse %p -> %p\n", q, p)); + *(_sai__GetUserAclEntryExResponse*)p = *(_sai__GetUserAclEntryExResponse*)q; +} + +void _sai__GetUserAclEntryEx::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetUserAclEntryEx::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__UserAclEntryHandleType(soap, &((_sai__GetUserAclEntryEx*)this)->Handle); + /* transient soap skipped */ +} + +int _sai__GetUserAclEntryEx::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetUserAclEntryEx); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetUserAclEntryEx::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetUserAclEntryEx(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetUserAclEntryEx(struct soap *soap, const char *tag, int id, const _sai__GetUserAclEntryEx *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetUserAclEntryEx), type); + soap_out_sai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((_sai__GetUserAclEntryEx*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetUserAclEntryEx::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetUserAclEntryEx(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntryEx * SOAP_FMAC4 soap_get__sai__GetUserAclEntryEx(struct soap *soap, _sai__GetUserAclEntryEx *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetUserAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetUserAclEntryEx::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetUserAclEntryEx(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntryEx * SOAP_FMAC4 soap_in__sai__GetUserAclEntryEx(struct soap *soap, const char *tag, _sai__GetUserAclEntryEx *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetUserAclEntryEx *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetUserAclEntryEx, sizeof(_sai__GetUserAclEntryEx), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetUserAclEntryEx) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetUserAclEntryEx *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclEntryHandleType(soap, "sai:Handle", &(((_sai__GetUserAclEntryEx*)a)->Handle), "sai:UserAclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetUserAclEntryEx *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetUserAclEntryEx, 0, sizeof(_sai__GetUserAclEntryEx), 0, soap_copy__sai__GetUserAclEntryEx); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetUserAclEntryEx * SOAP_FMAC6 soap_new__sai__GetUserAclEntryEx(struct soap *soap, int n) +{ return soap_instantiate__sai__GetUserAclEntryEx(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetUserAclEntryEx(struct soap *soap, _sai__GetUserAclEntryEx *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetUserAclEntryEx * SOAP_FMAC4 soap_instantiate__sai__GetUserAclEntryEx(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetUserAclEntryEx(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetUserAclEntryEx, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetUserAclEntryEx; + if (size) + *size = sizeof(_sai__GetUserAclEntryEx); + ((_sai__GetUserAclEntryEx*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetUserAclEntryEx[n]; + if (size) + *size = n * sizeof(_sai__GetUserAclEntryEx); + for (int i = 0; i < n; i++) + ((_sai__GetUserAclEntryEx*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetUserAclEntryEx*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetUserAclEntryEx(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetUserAclEntryEx %p -> %p\n", q, p)); + *(_sai__GetUserAclEntryEx*)p = *(_sai__GetUserAclEntryEx*)q; +} + +void _sai__AddUserAclEntryExResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__AddUserAclEntryExResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__AddUserAclEntryExResponse*)this)->StatusCode); + soap_default_sai__UserAclEntryHandleType(soap, &((_sai__AddUserAclEntryExResponse*)this)->Handle); + /* transient soap skipped */ +} + +int _sai__AddUserAclEntryExResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__AddUserAclEntryExResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__AddUserAclEntryExResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__AddUserAclEntryExResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddUserAclEntryExResponse(struct soap *soap, const char *tag, int id, const _sai__AddUserAclEntryExResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__AddUserAclEntryExResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__AddUserAclEntryExResponse*)a)->StatusCode), ""); + soap_out_sai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((_sai__AddUserAclEntryExResponse*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__AddUserAclEntryExResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__AddUserAclEntryExResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntryExResponse * SOAP_FMAC4 soap_get__sai__AddUserAclEntryExResponse(struct soap *soap, _sai__AddUserAclEntryExResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__AddUserAclEntryExResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__AddUserAclEntryExResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__AddUserAclEntryExResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntryExResponse * SOAP_FMAC4 soap_in__sai__AddUserAclEntryExResponse(struct soap *soap, const char *tag, _sai__AddUserAclEntryExResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__AddUserAclEntryExResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__AddUserAclEntryExResponse, sizeof(_sai__AddUserAclEntryExResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__AddUserAclEntryExResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__AddUserAclEntryExResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__AddUserAclEntryExResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclEntryHandleType(soap, "sai:Handle", &(((_sai__AddUserAclEntryExResponse*)a)->Handle), "sai:UserAclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__AddUserAclEntryExResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__AddUserAclEntryExResponse, 0, sizeof(_sai__AddUserAclEntryExResponse), 0, soap_copy__sai__AddUserAclEntryExResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__AddUserAclEntryExResponse * SOAP_FMAC6 soap_new__sai__AddUserAclEntryExResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__AddUserAclEntryExResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddUserAclEntryExResponse(struct soap *soap, _sai__AddUserAclEntryExResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__AddUserAclEntryExResponse * SOAP_FMAC4 soap_instantiate__sai__AddUserAclEntryExResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__AddUserAclEntryExResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__AddUserAclEntryExResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__AddUserAclEntryExResponse; + if (size) + *size = sizeof(_sai__AddUserAclEntryExResponse); + ((_sai__AddUserAclEntryExResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__AddUserAclEntryExResponse[n]; + if (size) + *size = n * sizeof(_sai__AddUserAclEntryExResponse); + for (int i = 0; i < n; i++) + ((_sai__AddUserAclEntryExResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__AddUserAclEntryExResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddUserAclEntryExResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__AddUserAclEntryExResponse %p -> %p\n", q, p)); + *(_sai__AddUserAclEntryExResponse*)p = *(_sai__AddUserAclEntryExResponse*)q; +} + +void _sai__AddUserAclEntryEx::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__UserAclEntryExType(soap, &((_sai__AddUserAclEntryEx*)this)->EntryEx); + /* transient soap skipped */ +} + +void _sai__AddUserAclEntryEx::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__AddUserAclEntryEx*)this)->EntryEx = NULL; + /* transient soap skipped */ +} + +int _sai__AddUserAclEntryEx::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__AddUserAclEntryEx); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__AddUserAclEntryEx::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__AddUserAclEntryEx(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddUserAclEntryEx(struct soap *soap, const char *tag, int id, const _sai__AddUserAclEntryEx *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__AddUserAclEntryEx), type); + soap_out_PointerTosai__UserAclEntryExType(soap, "sai:EntryEx", -1, &(((_sai__AddUserAclEntryEx*)a)->EntryEx), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__AddUserAclEntryEx::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__AddUserAclEntryEx(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntryEx * SOAP_FMAC4 soap_get__sai__AddUserAclEntryEx(struct soap *soap, _sai__AddUserAclEntryEx *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__AddUserAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__AddUserAclEntryEx::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__AddUserAclEntryEx(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntryEx * SOAP_FMAC4 soap_in__sai__AddUserAclEntryEx(struct soap *soap, const char *tag, _sai__AddUserAclEntryEx *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__AddUserAclEntryEx *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__AddUserAclEntryEx, sizeof(_sai__AddUserAclEntryEx), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__AddUserAclEntryEx) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__AddUserAclEntryEx *)a->soap_in(soap, tag, type); + } + } + short soap_flag_EntryEx1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_EntryEx1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UserAclEntryExType(soap, "sai:EntryEx", &(((_sai__AddUserAclEntryEx*)a)->EntryEx), "sai:UserAclEntryExType")) + { soap_flag_EntryEx1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_EntryEx1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__AddUserAclEntryEx *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__AddUserAclEntryEx, 0, sizeof(_sai__AddUserAclEntryEx), 0, soap_copy__sai__AddUserAclEntryEx); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__AddUserAclEntryEx * SOAP_FMAC6 soap_new__sai__AddUserAclEntryEx(struct soap *soap, int n) +{ return soap_instantiate__sai__AddUserAclEntryEx(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddUserAclEntryEx(struct soap *soap, _sai__AddUserAclEntryEx *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__AddUserAclEntryEx * SOAP_FMAC4 soap_instantiate__sai__AddUserAclEntryEx(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__AddUserAclEntryEx(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__AddUserAclEntryEx, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__AddUserAclEntryEx; + if (size) + *size = sizeof(_sai__AddUserAclEntryEx); + ((_sai__AddUserAclEntryEx*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__AddUserAclEntryEx[n]; + if (size) + *size = n * sizeof(_sai__AddUserAclEntryEx); + for (int i = 0; i < n; i++) + ((_sai__AddUserAclEntryEx*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__AddUserAclEntryEx*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddUserAclEntryEx(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__AddUserAclEntryEx %p -> %p\n", q, p)); + *(_sai__AddUserAclEntryEx*)p = *(_sai__AddUserAclEntryEx*)q; +} + +void _sai__GetCoreVersionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__GetCoreVersionResponse*)this)->Version, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_sai__GetCoreVersionResponse*)this)->Version); + /* transient soap skipped */ +} + +void _sai__GetCoreVersionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetCoreVersionResponse*)this)->StatusCode); + soap_default_std__string(soap, &((_sai__GetCoreVersionResponse*)this)->Version); + /* transient soap skipped */ +} + +int _sai__GetCoreVersionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetCoreVersionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetCoreVersionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetCoreVersionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCoreVersionResponse(struct soap *soap, const char *tag, int id, const _sai__GetCoreVersionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetCoreVersionResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetCoreVersionResponse*)a)->StatusCode), ""); + soap_out_std__string(soap, "sai:Version", -1, &(((_sai__GetCoreVersionResponse*)a)->Version), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetCoreVersionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetCoreVersionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetCoreVersionResponse * SOAP_FMAC4 soap_get__sai__GetCoreVersionResponse(struct soap *soap, _sai__GetCoreVersionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetCoreVersionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetCoreVersionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetCoreVersionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetCoreVersionResponse * SOAP_FMAC4 soap_in__sai__GetCoreVersionResponse(struct soap *soap, const char *tag, _sai__GetCoreVersionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetCoreVersionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetCoreVersionResponse, sizeof(_sai__GetCoreVersionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetCoreVersionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetCoreVersionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Version1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetCoreVersionResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Version1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "sai:Version", &(((_sai__GetCoreVersionResponse*)a)->Version), "xsd:string")) + { soap_flag_Version1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Version1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetCoreVersionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetCoreVersionResponse, 0, sizeof(_sai__GetCoreVersionResponse), 0, soap_copy__sai__GetCoreVersionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetCoreVersionResponse * SOAP_FMAC6 soap_new__sai__GetCoreVersionResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetCoreVersionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCoreVersionResponse(struct soap *soap, _sai__GetCoreVersionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetCoreVersionResponse * SOAP_FMAC4 soap_instantiate__sai__GetCoreVersionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetCoreVersionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetCoreVersionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetCoreVersionResponse; + if (size) + *size = sizeof(_sai__GetCoreVersionResponse); + ((_sai__GetCoreVersionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetCoreVersionResponse[n]; + if (size) + *size = n * sizeof(_sai__GetCoreVersionResponse); + for (int i = 0; i < n; i++) + ((_sai__GetCoreVersionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetCoreVersionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCoreVersionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetCoreVersionResponse %p -> %p\n", q, p)); + *(_sai__GetCoreVersionResponse*)p = *(_sai__GetCoreVersionResponse*)q; +} + +void _sai__GetCoreVersion::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetCoreVersion::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetCoreVersion::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetCoreVersion); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetCoreVersion::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetCoreVersion(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetCoreVersion(struct soap *soap, const char *tag, int id, const _sai__GetCoreVersion *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetCoreVersion), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetCoreVersion::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetCoreVersion(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetCoreVersion * SOAP_FMAC4 soap_get__sai__GetCoreVersion(struct soap *soap, _sai__GetCoreVersion *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetCoreVersion(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetCoreVersion::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetCoreVersion(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetCoreVersion * SOAP_FMAC4 soap_in__sai__GetCoreVersion(struct soap *soap, const char *tag, _sai__GetCoreVersion *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetCoreVersion *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetCoreVersion, sizeof(_sai__GetCoreVersion), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetCoreVersion) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetCoreVersion *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetCoreVersion *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetCoreVersion, 0, sizeof(_sai__GetCoreVersion), 0, soap_copy__sai__GetCoreVersion); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetCoreVersion * SOAP_FMAC6 soap_new__sai__GetCoreVersion(struct soap *soap, int n) +{ return soap_instantiate__sai__GetCoreVersion(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetCoreVersion(struct soap *soap, _sai__GetCoreVersion *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetCoreVersion * SOAP_FMAC4 soap_instantiate__sai__GetCoreVersion(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetCoreVersion(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetCoreVersion, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetCoreVersion; + if (size) + *size = sizeof(_sai__GetCoreVersion); + ((_sai__GetCoreVersion*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetCoreVersion[n]; + if (size) + *size = n * sizeof(_sai__GetCoreVersion); + for (int i = 0; i < n; i++) + ((_sai__GetCoreVersion*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetCoreVersion*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetCoreVersion(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetCoreVersion %p -> %p\n", q, p)); + *(_sai__GetCoreVersion*)p = *(_sai__GetCoreVersion*)q; +} + +void _sai__ResetFlashWearOutProtectionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__ResetFlashWearOutProtectionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__ResetFlashWearOutProtectionResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__ResetFlashWearOutProtectionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__ResetFlashWearOutProtectionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__ResetFlashWearOutProtectionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__ResetFlashWearOutProtectionResponse(struct soap *soap, const char *tag, int id, const _sai__ResetFlashWearOutProtectionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__ResetFlashWearOutProtectionResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__ResetFlashWearOutProtectionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__ResetFlashWearOutProtectionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse * SOAP_FMAC4 soap_get__sai__ResetFlashWearOutProtectionResponse(struct soap *soap, _sai__ResetFlashWearOutProtectionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__ResetFlashWearOutProtectionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__ResetFlashWearOutProtectionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__ResetFlashWearOutProtectionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse * SOAP_FMAC4 soap_in__sai__ResetFlashWearOutProtectionResponse(struct soap *soap, const char *tag, _sai__ResetFlashWearOutProtectionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__ResetFlashWearOutProtectionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse, sizeof(_sai__ResetFlashWearOutProtectionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__ResetFlashWearOutProtectionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__ResetFlashWearOutProtectionResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__ResetFlashWearOutProtectionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse, 0, sizeof(_sai__ResetFlashWearOutProtectionResponse), 0, soap_copy__sai__ResetFlashWearOutProtectionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__ResetFlashWearOutProtectionResponse * SOAP_FMAC6 soap_new__sai__ResetFlashWearOutProtectionResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__ResetFlashWearOutProtectionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__ResetFlashWearOutProtectionResponse(struct soap *soap, _sai__ResetFlashWearOutProtectionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse * SOAP_FMAC4 soap_instantiate__sai__ResetFlashWearOutProtectionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__ResetFlashWearOutProtectionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__ResetFlashWearOutProtectionResponse; + if (size) + *size = sizeof(_sai__ResetFlashWearOutProtectionResponse); + ((_sai__ResetFlashWearOutProtectionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__ResetFlashWearOutProtectionResponse[n]; + if (size) + *size = n * sizeof(_sai__ResetFlashWearOutProtectionResponse); + for (int i = 0; i < n; i++) + ((_sai__ResetFlashWearOutProtectionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__ResetFlashWearOutProtectionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__ResetFlashWearOutProtectionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__ResetFlashWearOutProtectionResponse %p -> %p\n", q, p)); + *(_sai__ResetFlashWearOutProtectionResponse*)p = *(_sai__ResetFlashWearOutProtectionResponse*)q; +} + +void _sai__ResetFlashWearOutProtection::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__ResetFlashWearOutProtection::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__ResetFlashWearOutProtection::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__ResetFlashWearOutProtection); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__ResetFlashWearOutProtection::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__ResetFlashWearOutProtection(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__ResetFlashWearOutProtection(struct soap *soap, const char *tag, int id, const _sai__ResetFlashWearOutProtection *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__ResetFlashWearOutProtection), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__ResetFlashWearOutProtection::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__ResetFlashWearOutProtection(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_get__sai__ResetFlashWearOutProtection(struct soap *soap, _sai__ResetFlashWearOutProtection *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__ResetFlashWearOutProtection(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__ResetFlashWearOutProtection::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__ResetFlashWearOutProtection(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_in__sai__ResetFlashWearOutProtection(struct soap *soap, const char *tag, _sai__ResetFlashWearOutProtection *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__ResetFlashWearOutProtection *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__ResetFlashWearOutProtection, sizeof(_sai__ResetFlashWearOutProtection), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__ResetFlashWearOutProtection) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__ResetFlashWearOutProtection *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__ResetFlashWearOutProtection *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__ResetFlashWearOutProtection, 0, sizeof(_sai__ResetFlashWearOutProtection), 0, soap_copy__sai__ResetFlashWearOutProtection); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__ResetFlashWearOutProtection * SOAP_FMAC6 soap_new__sai__ResetFlashWearOutProtection(struct soap *soap, int n) +{ return soap_instantiate__sai__ResetFlashWearOutProtection(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__ResetFlashWearOutProtection(struct soap *soap, _sai__ResetFlashWearOutProtection *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_instantiate__sai__ResetFlashWearOutProtection(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__ResetFlashWearOutProtection(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__ResetFlashWearOutProtection, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__ResetFlashWearOutProtection; + if (size) + *size = sizeof(_sai__ResetFlashWearOutProtection); + ((_sai__ResetFlashWearOutProtection*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__ResetFlashWearOutProtection[n]; + if (size) + *size = n * sizeof(_sai__ResetFlashWearOutProtection); + for (int i = 0; i < n; i++) + ((_sai__ResetFlashWearOutProtection*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__ResetFlashWearOutProtection*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__ResetFlashWearOutProtection(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__ResetFlashWearOutProtection %p -> %p\n", q, p)); + *(_sai__ResetFlashWearOutProtection*)p = *(_sai__ResetFlashWearOutProtection*)q; +} + +void _sai__CommitChangesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__CommitChangesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__CommitChangesResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__CommitChangesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CommitChangesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CommitChangesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CommitChangesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CommitChangesResponse(struct soap *soap, const char *tag, int id, const _sai__CommitChangesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CommitChangesResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__CommitChangesResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CommitChangesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CommitChangesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CommitChangesResponse * SOAP_FMAC4 soap_get__sai__CommitChangesResponse(struct soap *soap, _sai__CommitChangesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CommitChangesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CommitChangesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CommitChangesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CommitChangesResponse * SOAP_FMAC4 soap_in__sai__CommitChangesResponse(struct soap *soap, const char *tag, _sai__CommitChangesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CommitChangesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CommitChangesResponse, sizeof(_sai__CommitChangesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CommitChangesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CommitChangesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__CommitChangesResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CommitChangesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CommitChangesResponse, 0, sizeof(_sai__CommitChangesResponse), 0, soap_copy__sai__CommitChangesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CommitChangesResponse * SOAP_FMAC6 soap_new__sai__CommitChangesResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__CommitChangesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CommitChangesResponse(struct soap *soap, _sai__CommitChangesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CommitChangesResponse * SOAP_FMAC4 soap_instantiate__sai__CommitChangesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CommitChangesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CommitChangesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CommitChangesResponse; + if (size) + *size = sizeof(_sai__CommitChangesResponse); + ((_sai__CommitChangesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CommitChangesResponse[n]; + if (size) + *size = n * sizeof(_sai__CommitChangesResponse); + for (int i = 0; i < n; i++) + ((_sai__CommitChangesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CommitChangesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CommitChangesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CommitChangesResponse %p -> %p\n", q, p)); + *(_sai__CommitChangesResponse*)p = *(_sai__CommitChangesResponse*)q; +} + +void _sai__CommitChanges::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__CommitChanges::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__CommitChanges::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__CommitChanges); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__CommitChanges::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__CommitChanges(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__CommitChanges(struct soap *soap, const char *tag, int id, const _sai__CommitChanges *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__CommitChanges), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__CommitChanges::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__CommitChanges(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__CommitChanges * SOAP_FMAC4 soap_get__sai__CommitChanges(struct soap *soap, _sai__CommitChanges *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__CommitChanges(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__CommitChanges::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__CommitChanges(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__CommitChanges * SOAP_FMAC4 soap_in__sai__CommitChanges(struct soap *soap, const char *tag, _sai__CommitChanges *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__CommitChanges *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__CommitChanges, sizeof(_sai__CommitChanges), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__CommitChanges) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__CommitChanges *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__CommitChanges *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__CommitChanges, 0, sizeof(_sai__CommitChanges), 0, soap_copy__sai__CommitChanges); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__CommitChanges * SOAP_FMAC6 soap_new__sai__CommitChanges(struct soap *soap, int n) +{ return soap_instantiate__sai__CommitChanges(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__CommitChanges(struct soap *soap, _sai__CommitChanges *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__CommitChanges * SOAP_FMAC4 soap_instantiate__sai__CommitChanges(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__CommitChanges(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__CommitChanges, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__CommitChanges; + if (size) + *size = sizeof(_sai__CommitChanges); + ((_sai__CommitChanges*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__CommitChanges[n]; + if (size) + *size = n * sizeof(_sai__CommitChanges); + for (int i = 0; i < n; i++) + ((_sai__CommitChanges*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__CommitChanges*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__CommitChanges(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__CommitChanges %p -> %p\n", q, p)); + *(_sai__CommitChanges*)p = *(_sai__CommitChanges*)q; +} + +void _sai__UnprovisionResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__UnprovisionResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__UnprovisionResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__UnprovisionResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__UnprovisionResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__UnprovisionResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__UnprovisionResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UnprovisionResponse(struct soap *soap, const char *tag, int id, const _sai__UnprovisionResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__UnprovisionResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__UnprovisionResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__UnprovisionResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__UnprovisionResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__UnprovisionResponse * SOAP_FMAC4 soap_get__sai__UnprovisionResponse(struct soap *soap, _sai__UnprovisionResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__UnprovisionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__UnprovisionResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__UnprovisionResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__UnprovisionResponse * SOAP_FMAC4 soap_in__sai__UnprovisionResponse(struct soap *soap, const char *tag, _sai__UnprovisionResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__UnprovisionResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__UnprovisionResponse, sizeof(_sai__UnprovisionResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__UnprovisionResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__UnprovisionResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__UnprovisionResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__UnprovisionResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__UnprovisionResponse, 0, sizeof(_sai__UnprovisionResponse), 0, soap_copy__sai__UnprovisionResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__UnprovisionResponse * SOAP_FMAC6 soap_new__sai__UnprovisionResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__UnprovisionResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UnprovisionResponse(struct soap *soap, _sai__UnprovisionResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__UnprovisionResponse * SOAP_FMAC4 soap_instantiate__sai__UnprovisionResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__UnprovisionResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__UnprovisionResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__UnprovisionResponse; + if (size) + *size = sizeof(_sai__UnprovisionResponse); + ((_sai__UnprovisionResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__UnprovisionResponse[n]; + if (size) + *size = n * sizeof(_sai__UnprovisionResponse); + for (int i = 0; i < n; i++) + ((_sai__UnprovisionResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__UnprovisionResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UnprovisionResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__UnprovisionResponse %p -> %p\n", q, p)); + *(_sai__UnprovisionResponse*)p = *(_sai__UnprovisionResponse*)q; +} + +void _sai__Unprovision::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__Unprovision::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__ProvisioningModeType(soap, &((_sai__Unprovision*)this)->ProvisioningMode); + /* transient soap skipped */ +} + +int _sai__Unprovision::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__Unprovision); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__Unprovision::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__Unprovision(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__Unprovision(struct soap *soap, const char *tag, int id, const _sai__Unprovision *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__Unprovision), type); + soap_out_sai__ProvisioningModeType(soap, "sai:ProvisioningMode", -1, &(((_sai__Unprovision*)a)->ProvisioningMode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__Unprovision::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__Unprovision(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__Unprovision * SOAP_FMAC4 soap_get__sai__Unprovision(struct soap *soap, _sai__Unprovision *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__Unprovision(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__Unprovision::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__Unprovision(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__Unprovision * SOAP_FMAC4 soap_in__sai__Unprovision(struct soap *soap, const char *tag, _sai__Unprovision *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__Unprovision *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__Unprovision, sizeof(_sai__Unprovision), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__Unprovision) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__Unprovision *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ProvisioningMode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ProvisioningMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__ProvisioningModeType(soap, "sai:ProvisioningMode", &(((_sai__Unprovision*)a)->ProvisioningMode), "sai:ProvisioningModeType")) + { soap_flag_ProvisioningMode1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ProvisioningMode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__Unprovision *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__Unprovision, 0, sizeof(_sai__Unprovision), 0, soap_copy__sai__Unprovision); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__Unprovision * SOAP_FMAC6 soap_new__sai__Unprovision(struct soap *soap, int n) +{ return soap_instantiate__sai__Unprovision(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__Unprovision(struct soap *soap, _sai__Unprovision *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__Unprovision * SOAP_FMAC4 soap_instantiate__sai__Unprovision(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__Unprovision(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__Unprovision, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__Unprovision; + if (size) + *size = sizeof(_sai__Unprovision); + ((_sai__Unprovision*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__Unprovision[n]; + if (size) + *size = n * sizeof(_sai__Unprovision); + for (int i = 0; i < n; i++) + ((_sai__Unprovision*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__Unprovision*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__Unprovision(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__Unprovision %p -> %p\n", q, p)); + *(_sai__Unprovision*)p = *(_sai__Unprovision*)q; +} + +void _sai__SetProvisioningModeResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetProvisioningModeResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetProvisioningModeResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetProvisioningModeResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetProvisioningModeResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetProvisioningModeResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetProvisioningModeResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetProvisioningModeResponse(struct soap *soap, const char *tag, int id, const _sai__SetProvisioningModeResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetProvisioningModeResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetProvisioningModeResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetProvisioningModeResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetProvisioningModeResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetProvisioningModeResponse * SOAP_FMAC4 soap_get__sai__SetProvisioningModeResponse(struct soap *soap, _sai__SetProvisioningModeResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetProvisioningModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetProvisioningModeResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetProvisioningModeResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetProvisioningModeResponse * SOAP_FMAC4 soap_in__sai__SetProvisioningModeResponse(struct soap *soap, const char *tag, _sai__SetProvisioningModeResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetProvisioningModeResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetProvisioningModeResponse, sizeof(_sai__SetProvisioningModeResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetProvisioningModeResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetProvisioningModeResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetProvisioningModeResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetProvisioningModeResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetProvisioningModeResponse, 0, sizeof(_sai__SetProvisioningModeResponse), 0, soap_copy__sai__SetProvisioningModeResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetProvisioningModeResponse * SOAP_FMAC6 soap_new__sai__SetProvisioningModeResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetProvisioningModeResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetProvisioningModeResponse(struct soap *soap, _sai__SetProvisioningModeResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetProvisioningModeResponse * SOAP_FMAC4 soap_instantiate__sai__SetProvisioningModeResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetProvisioningModeResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetProvisioningModeResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetProvisioningModeResponse; + if (size) + *size = sizeof(_sai__SetProvisioningModeResponse); + ((_sai__SetProvisioningModeResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetProvisioningModeResponse[n]; + if (size) + *size = n * sizeof(_sai__SetProvisioningModeResponse); + for (int i = 0; i < n; i++) + ((_sai__SetProvisioningModeResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetProvisioningModeResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetProvisioningModeResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetProvisioningModeResponse %p -> %p\n", q, p)); + *(_sai__SetProvisioningModeResponse*)p = *(_sai__SetProvisioningModeResponse*)q; +} + +void _sai__SetProvisioningMode::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetProvisioningMode::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__ProvisioningModeType(soap, &((_sai__SetProvisioningMode*)this)->ProvisioningMode); + /* transient soap skipped */ +} + +int _sai__SetProvisioningMode::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetProvisioningMode); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetProvisioningMode::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetProvisioningMode(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetProvisioningMode(struct soap *soap, const char *tag, int id, const _sai__SetProvisioningMode *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetProvisioningMode), type); + soap_out_sai__ProvisioningModeType(soap, "sai:ProvisioningMode", -1, &(((_sai__SetProvisioningMode*)a)->ProvisioningMode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetProvisioningMode::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetProvisioningMode(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetProvisioningMode * SOAP_FMAC4 soap_get__sai__SetProvisioningMode(struct soap *soap, _sai__SetProvisioningMode *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetProvisioningMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetProvisioningMode::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetProvisioningMode(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetProvisioningMode * SOAP_FMAC4 soap_in__sai__SetProvisioningMode(struct soap *soap, const char *tag, _sai__SetProvisioningMode *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetProvisioningMode *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetProvisioningMode, sizeof(_sai__SetProvisioningMode), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetProvisioningMode) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetProvisioningMode *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ProvisioningMode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ProvisioningMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__ProvisioningModeType(soap, "sai:ProvisioningMode", &(((_sai__SetProvisioningMode*)a)->ProvisioningMode), "sai:ProvisioningModeType")) + { soap_flag_ProvisioningMode1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ProvisioningMode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetProvisioningMode *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetProvisioningMode, 0, sizeof(_sai__SetProvisioningMode), 0, soap_copy__sai__SetProvisioningMode); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetProvisioningMode * SOAP_FMAC6 soap_new__sai__SetProvisioningMode(struct soap *soap, int n) +{ return soap_instantiate__sai__SetProvisioningMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetProvisioningMode(struct soap *soap, _sai__SetProvisioningMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetProvisioningMode * SOAP_FMAC4 soap_instantiate__sai__SetProvisioningMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetProvisioningMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetProvisioningMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetProvisioningMode; + if (size) + *size = sizeof(_sai__SetProvisioningMode); + ((_sai__SetProvisioningMode*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetProvisioningMode[n]; + if (size) + *size = n * sizeof(_sai__SetProvisioningMode); + for (int i = 0; i < n; i++) + ((_sai__SetProvisioningMode*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetProvisioningMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetProvisioningMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetProvisioningMode %p -> %p\n", q, p)); + *(_sai__SetProvisioningMode*)p = *(_sai__SetProvisioningMode*)q; +} + +void _sai__GetProvisioningModeResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetProvisioningModeResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetProvisioningModeResponse*)this)->StatusCode); + soap_default_sai__ProvisioningModeType(soap, &((_sai__GetProvisioningModeResponse*)this)->ProvisioningMode); + /* transient soap skipped */ +} + +int _sai__GetProvisioningModeResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetProvisioningModeResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetProvisioningModeResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetProvisioningModeResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningModeResponse(struct soap *soap, const char *tag, int id, const _sai__GetProvisioningModeResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetProvisioningModeResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetProvisioningModeResponse*)a)->StatusCode), ""); + soap_out_sai__ProvisioningModeType(soap, "sai:ProvisioningMode", -1, &(((_sai__GetProvisioningModeResponse*)a)->ProvisioningMode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetProvisioningModeResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetProvisioningModeResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetProvisioningModeResponse * SOAP_FMAC4 soap_get__sai__GetProvisioningModeResponse(struct soap *soap, _sai__GetProvisioningModeResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetProvisioningModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetProvisioningModeResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetProvisioningModeResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetProvisioningModeResponse * SOAP_FMAC4 soap_in__sai__GetProvisioningModeResponse(struct soap *soap, const char *tag, _sai__GetProvisioningModeResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetProvisioningModeResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetProvisioningModeResponse, sizeof(_sai__GetProvisioningModeResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetProvisioningModeResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetProvisioningModeResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_ProvisioningMode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetProvisioningModeResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_ProvisioningMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__ProvisioningModeType(soap, "sai:ProvisioningMode", &(((_sai__GetProvisioningModeResponse*)a)->ProvisioningMode), "sai:ProvisioningModeType")) + { soap_flag_ProvisioningMode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_ProvisioningMode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetProvisioningModeResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetProvisioningModeResponse, 0, sizeof(_sai__GetProvisioningModeResponse), 0, soap_copy__sai__GetProvisioningModeResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetProvisioningModeResponse * SOAP_FMAC6 soap_new__sai__GetProvisioningModeResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetProvisioningModeResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningModeResponse(struct soap *soap, _sai__GetProvisioningModeResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetProvisioningModeResponse * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningModeResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetProvisioningModeResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetProvisioningModeResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetProvisioningModeResponse; + if (size) + *size = sizeof(_sai__GetProvisioningModeResponse); + ((_sai__GetProvisioningModeResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetProvisioningModeResponse[n]; + if (size) + *size = n * sizeof(_sai__GetProvisioningModeResponse); + for (int i = 0; i < n; i++) + ((_sai__GetProvisioningModeResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetProvisioningModeResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningModeResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetProvisioningModeResponse %p -> %p\n", q, p)); + *(_sai__GetProvisioningModeResponse*)p = *(_sai__GetProvisioningModeResponse*)q; +} + +void _sai__GetProvisioningMode::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetProvisioningMode::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetProvisioningMode::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetProvisioningMode); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetProvisioningMode::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetProvisioningMode(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetProvisioningMode(struct soap *soap, const char *tag, int id, const _sai__GetProvisioningMode *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetProvisioningMode), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetProvisioningMode::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetProvisioningMode(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetProvisioningMode * SOAP_FMAC4 soap_get__sai__GetProvisioningMode(struct soap *soap, _sai__GetProvisioningMode *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetProvisioningMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetProvisioningMode::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetProvisioningMode(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetProvisioningMode * SOAP_FMAC4 soap_in__sai__GetProvisioningMode(struct soap *soap, const char *tag, _sai__GetProvisioningMode *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetProvisioningMode *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetProvisioningMode, sizeof(_sai__GetProvisioningMode), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetProvisioningMode) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetProvisioningMode *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetProvisioningMode *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetProvisioningMode, 0, sizeof(_sai__GetProvisioningMode), 0, soap_copy__sai__GetProvisioningMode); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetProvisioningMode * SOAP_FMAC6 soap_new__sai__GetProvisioningMode(struct soap *soap, int n) +{ return soap_instantiate__sai__GetProvisioningMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetProvisioningMode(struct soap *soap, _sai__GetProvisioningMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetProvisioningMode * SOAP_FMAC4 soap_instantiate__sai__GetProvisioningMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetProvisioningMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetProvisioningMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetProvisioningMode; + if (size) + *size = sizeof(_sai__GetProvisioningMode); + ((_sai__GetProvisioningMode*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetProvisioningMode[n]; + if (size) + *size = n * sizeof(_sai__GetProvisioningMode); + for (int i = 0; i < n; i++) + ((_sai__GetProvisioningMode*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetProvisioningMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetProvisioningMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetProvisioningMode %p -> %p\n", q, p)); + *(_sai__GetProvisioningMode*)p = *(_sai__GetProvisioningMode*)q; +} + +void _sai__UpdateCoreFromUrlResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__UpdateCoreFromUrlResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__UpdateCoreFromUrlResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__UpdateCoreFromUrlResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__UpdateCoreFromUrlResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__UpdateCoreFromUrlResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__UpdateCoreFromUrlResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateCoreFromUrlResponse(struct soap *soap, const char *tag, int id, const _sai__UpdateCoreFromUrlResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__UpdateCoreFromUrlResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__UpdateCoreFromUrlResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__UpdateCoreFromUrlResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__UpdateCoreFromUrlResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse * SOAP_FMAC4 soap_get__sai__UpdateCoreFromUrlResponse(struct soap *soap, _sai__UpdateCoreFromUrlResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__UpdateCoreFromUrlResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__UpdateCoreFromUrlResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__UpdateCoreFromUrlResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse * SOAP_FMAC4 soap_in__sai__UpdateCoreFromUrlResponse(struct soap *soap, const char *tag, _sai__UpdateCoreFromUrlResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__UpdateCoreFromUrlResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__UpdateCoreFromUrlResponse, sizeof(_sai__UpdateCoreFromUrlResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__UpdateCoreFromUrlResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__UpdateCoreFromUrlResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__UpdateCoreFromUrlResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__UpdateCoreFromUrlResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__UpdateCoreFromUrlResponse, 0, sizeof(_sai__UpdateCoreFromUrlResponse), 0, soap_copy__sai__UpdateCoreFromUrlResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__UpdateCoreFromUrlResponse * SOAP_FMAC6 soap_new__sai__UpdateCoreFromUrlResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__UpdateCoreFromUrlResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateCoreFromUrlResponse(struct soap *soap, _sai__UpdateCoreFromUrlResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse * SOAP_FMAC4 soap_instantiate__sai__UpdateCoreFromUrlResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__UpdateCoreFromUrlResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__UpdateCoreFromUrlResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__UpdateCoreFromUrlResponse; + if (size) + *size = sizeof(_sai__UpdateCoreFromUrlResponse); + ((_sai__UpdateCoreFromUrlResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__UpdateCoreFromUrlResponse[n]; + if (size) + *size = n * sizeof(_sai__UpdateCoreFromUrlResponse); + for (int i = 0; i < n; i++) + ((_sai__UpdateCoreFromUrlResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__UpdateCoreFromUrlResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateCoreFromUrlResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__UpdateCoreFromUrlResponse %p -> %p\n", q, p)); + *(_sai__UpdateCoreFromUrlResponse*)p = *(_sai__UpdateCoreFromUrlResponse*)q; +} + +void _sai__UpdateCoreFromUrl::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTostd__string(soap, &((_sai__UpdateCoreFromUrl*)this)->tftpServerName); + soap_embedded(soap, &((_sai__UpdateCoreFromUrl*)this)->tftpServerPort, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((_sai__UpdateCoreFromUrl*)this)->MagicPacketPort, SOAP_TYPE_unsignedShort); + soap_embedded(soap, &((_sai__UpdateCoreFromUrl*)this)->packagePath, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((_sai__UpdateCoreFromUrl*)this)->packagePath); + soap_serialize_PointerTosai__AmtVersion(soap, &((_sai__UpdateCoreFromUrl*)this)->AmtAppVersion); + soap_serialize_PointerTosai__AmtVersion(soap, &((_sai__UpdateCoreFromUrl*)this)->UpdateAppVersion); + soap_serialize_PointerTosai__UpdateCoreUrlKeyType(soap, &((_sai__UpdateCoreFromUrl*)this)->Key); + /* transient soap skipped */ +} + +void _sai__UpdateCoreFromUrl::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__IPv4AddressType(soap, &((_sai__UpdateCoreFromUrl*)this)->tftpServerIp); + ((_sai__UpdateCoreFromUrl*)this)->tftpServerName = NULL; + soap_default_unsignedShort(soap, &((_sai__UpdateCoreFromUrl*)this)->tftpServerPort); + soap_default_unsignedShort(soap, &((_sai__UpdateCoreFromUrl*)this)->MagicPacketPort); + soap_default_std__string(soap, &((_sai__UpdateCoreFromUrl*)this)->packagePath); + ((_sai__UpdateCoreFromUrl*)this)->AmtAppVersion = NULL; + ((_sai__UpdateCoreFromUrl*)this)->UpdateAppVersion = NULL; + soap_default_sai__IPv4AddressType(soap, &((_sai__UpdateCoreFromUrl*)this)->MgmtConsoleAddr); + ((_sai__UpdateCoreFromUrl*)this)->Key = NULL; + /* transient soap skipped */ +} + +int _sai__UpdateCoreFromUrl::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__UpdateCoreFromUrl); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__UpdateCoreFromUrl::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__UpdateCoreFromUrl(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateCoreFromUrl(struct soap *soap, const char *tag, int id, const _sai__UpdateCoreFromUrl *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__UpdateCoreFromUrl), type); + soap_out_sai__IPv4AddressType(soap, "sai:tftpServerIp", -1, &(((_sai__UpdateCoreFromUrl*)a)->tftpServerIp), ""); + soap_out_PointerTostd__string(soap, "sai:tftpServerName", -1, &(((_sai__UpdateCoreFromUrl*)a)->tftpServerName), ""); + soap_out_unsignedShort(soap, "sai:tftpServerPort", -1, &(((_sai__UpdateCoreFromUrl*)a)->tftpServerPort), ""); + soap_out_unsignedShort(soap, "sai:MagicPacketPort", -1, &(((_sai__UpdateCoreFromUrl*)a)->MagicPacketPort), ""); + soap_out_std__string(soap, "sai:packagePath", -1, &(((_sai__UpdateCoreFromUrl*)a)->packagePath), ""); + soap_out_PointerTosai__AmtVersion(soap, "sai:AmtAppVersion", -1, &(((_sai__UpdateCoreFromUrl*)a)->AmtAppVersion), ""); + soap_out_PointerTosai__AmtVersion(soap, "sai:UpdateAppVersion", -1, &(((_sai__UpdateCoreFromUrl*)a)->UpdateAppVersion), ""); + soap_out_sai__IPv4AddressType(soap, "sai:MgmtConsoleAddr", -1, &(((_sai__UpdateCoreFromUrl*)a)->MgmtConsoleAddr), ""); + soap_out_PointerTosai__UpdateCoreUrlKeyType(soap, "sai:Key", -1, &(((_sai__UpdateCoreFromUrl*)a)->Key), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__UpdateCoreFromUrl::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__UpdateCoreFromUrl(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_get__sai__UpdateCoreFromUrl(struct soap *soap, _sai__UpdateCoreFromUrl *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__UpdateCoreFromUrl(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__UpdateCoreFromUrl::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__UpdateCoreFromUrl(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_in__sai__UpdateCoreFromUrl(struct soap *soap, const char *tag, _sai__UpdateCoreFromUrl *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__UpdateCoreFromUrl *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__UpdateCoreFromUrl, sizeof(_sai__UpdateCoreFromUrl), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__UpdateCoreFromUrl) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__UpdateCoreFromUrl *)a->soap_in(soap, tag, type); + } + } + short soap_flag_tftpServerIp1 = 1, soap_flag_tftpServerName1 = 1, soap_flag_tftpServerPort1 = 1, soap_flag_MagicPacketPort1 = 1, soap_flag_packagePath1 = 1, soap_flag_AmtAppVersion1 = 1, soap_flag_UpdateAppVersion1 = 1, soap_flag_MgmtConsoleAddr1 = 1, soap_flag_Key1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_tftpServerIp1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__IPv4AddressType(soap, "sai:tftpServerIp", &(((_sai__UpdateCoreFromUrl*)a)->tftpServerIp), "sai:IPv4AddressType")) + { soap_flag_tftpServerIp1--; + continue; + } + if (soap_flag_tftpServerName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "sai:tftpServerName", &(((_sai__UpdateCoreFromUrl*)a)->tftpServerName), "xsd:string")) + { soap_flag_tftpServerName1--; + continue; + } + if (soap_flag_tftpServerPort1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "sai:tftpServerPort", &(((_sai__UpdateCoreFromUrl*)a)->tftpServerPort), "xsd:unsignedShort")) + { soap_flag_tftpServerPort1--; + continue; + } + if (soap_flag_MagicPacketPort1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "sai:MagicPacketPort", &(((_sai__UpdateCoreFromUrl*)a)->MagicPacketPort), "xsd:unsignedShort")) + { soap_flag_MagicPacketPort1--; + continue; + } + if (soap_flag_packagePath1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "sai:packagePath", &(((_sai__UpdateCoreFromUrl*)a)->packagePath), "xsd:string")) + { soap_flag_packagePath1--; + continue; + } + if (soap_flag_AmtAppVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__AmtVersion(soap, "sai:AmtAppVersion", &(((_sai__UpdateCoreFromUrl*)a)->AmtAppVersion), "sai:AmtVersion")) + { soap_flag_AmtAppVersion1--; + continue; + } + if (soap_flag_UpdateAppVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__AmtVersion(soap, "sai:UpdateAppVersion", &(((_sai__UpdateCoreFromUrl*)a)->UpdateAppVersion), "sai:AmtVersion")) + { soap_flag_UpdateAppVersion1--; + continue; + } + if (soap_flag_MgmtConsoleAddr1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__IPv4AddressType(soap, "sai:MgmtConsoleAddr", &(((_sai__UpdateCoreFromUrl*)a)->MgmtConsoleAddr), "sai:IPv4AddressType")) + { soap_flag_MgmtConsoleAddr1--; + continue; + } + if (soap_flag_Key1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UpdateCoreUrlKeyType(soap, "sai:Key", &(((_sai__UpdateCoreFromUrl*)a)->Key), "sai:UpdateCoreUrlKeyType")) + { soap_flag_Key1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_tftpServerIp1 > 0 || soap_flag_tftpServerPort1 > 0 || soap_flag_MagicPacketPort1 > 0 || soap_flag_packagePath1 > 0 || soap_flag_AmtAppVersion1 > 0 || soap_flag_UpdateAppVersion1 > 0 || soap_flag_MgmtConsoleAddr1 > 0 || soap_flag_Key1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__UpdateCoreFromUrl *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__UpdateCoreFromUrl, 0, sizeof(_sai__UpdateCoreFromUrl), 0, soap_copy__sai__UpdateCoreFromUrl); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__UpdateCoreFromUrl * SOAP_FMAC6 soap_new__sai__UpdateCoreFromUrl(struct soap *soap, int n) +{ return soap_instantiate__sai__UpdateCoreFromUrl(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateCoreFromUrl(struct soap *soap, _sai__UpdateCoreFromUrl *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_instantiate__sai__UpdateCoreFromUrl(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__UpdateCoreFromUrl(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__UpdateCoreFromUrl, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__UpdateCoreFromUrl; + if (size) + *size = sizeof(_sai__UpdateCoreFromUrl); + ((_sai__UpdateCoreFromUrl*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__UpdateCoreFromUrl[n]; + if (size) + *size = n * sizeof(_sai__UpdateCoreFromUrl); + for (int i = 0; i < n; i++) + ((_sai__UpdateCoreFromUrl*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__UpdateCoreFromUrl*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateCoreFromUrl(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__UpdateCoreFromUrl %p -> %p\n", q, p)); + *(_sai__UpdateCoreFromUrl*)p = *(_sai__UpdateCoreFromUrl*)q; +} + +void _sai__GetTLSCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateChainType(soap, &((_sai__GetTLSCertificateResponse*)this)->CertificateChain); + /* transient soap skipped */ +} + +void _sai__GetTLSCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetTLSCertificateResponse*)this)->StatusCode); + ((_sai__GetTLSCertificateResponse*)this)->CertificateChain = NULL; + /* transient soap skipped */ +} + +int _sai__GetTLSCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTLSCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTLSCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTLSCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTLSCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__GetTLSCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTLSCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetTLSCertificateResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__CertificateChainType(soap, "sai:CertificateChain", -1, &(((_sai__GetTLSCertificateResponse*)a)->CertificateChain), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTLSCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTLSCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTLSCertificateResponse * SOAP_FMAC4 soap_get__sai__GetTLSCertificateResponse(struct soap *soap, _sai__GetTLSCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTLSCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTLSCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTLSCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTLSCertificateResponse * SOAP_FMAC4 soap_in__sai__GetTLSCertificateResponse(struct soap *soap, const char *tag, _sai__GetTLSCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTLSCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTLSCertificateResponse, sizeof(_sai__GetTLSCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTLSCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTLSCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_CertificateChain1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetTLSCertificateResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_CertificateChain1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateChainType(soap, "sai:CertificateChain", &(((_sai__GetTLSCertificateResponse*)a)->CertificateChain), "sai:CertificateChainType")) + { soap_flag_CertificateChain1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_CertificateChain1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTLSCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTLSCertificateResponse, 0, sizeof(_sai__GetTLSCertificateResponse), 0, soap_copy__sai__GetTLSCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTLSCertificateResponse * SOAP_FMAC6 soap_new__sai__GetTLSCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTLSCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTLSCertificateResponse(struct soap *soap, _sai__GetTLSCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTLSCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__GetTLSCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTLSCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTLSCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTLSCertificateResponse; + if (size) + *size = sizeof(_sai__GetTLSCertificateResponse); + ((_sai__GetTLSCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTLSCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__GetTLSCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__GetTLSCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTLSCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTLSCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTLSCertificateResponse %p -> %p\n", q, p)); + *(_sai__GetTLSCertificateResponse*)p = *(_sai__GetTLSCertificateResponse*)q; +} + +void _sai__GetTLSCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetTLSCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetTLSCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetTLSCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetTLSCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetTLSCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetTLSCertificate(struct soap *soap, const char *tag, int id, const _sai__GetTLSCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetTLSCertificate), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetTLSCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetTLSCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetTLSCertificate * SOAP_FMAC4 soap_get__sai__GetTLSCertificate(struct soap *soap, _sai__GetTLSCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetTLSCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetTLSCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetTLSCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetTLSCertificate * SOAP_FMAC4 soap_in__sai__GetTLSCertificate(struct soap *soap, const char *tag, _sai__GetTLSCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetTLSCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetTLSCertificate, sizeof(_sai__GetTLSCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetTLSCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetTLSCertificate *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetTLSCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetTLSCertificate, 0, sizeof(_sai__GetTLSCertificate), 0, soap_copy__sai__GetTLSCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetTLSCertificate * SOAP_FMAC6 soap_new__sai__GetTLSCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__GetTLSCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetTLSCertificate(struct soap *soap, _sai__GetTLSCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetTLSCertificate * SOAP_FMAC4 soap_instantiate__sai__GetTLSCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetTLSCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetTLSCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetTLSCertificate; + if (size) + *size = sizeof(_sai__GetTLSCertificate); + ((_sai__GetTLSCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetTLSCertificate[n]; + if (size) + *size = n * sizeof(_sai__GetTLSCertificate); + for (int i = 0; i < n; i++) + ((_sai__GetTLSCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetTLSCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetTLSCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetTLSCertificate %p -> %p\n", q, p)); + *(_sai__GetTLSCertificate*)p = *(_sai__GetTLSCertificate*)q; +} + +void _sai__SetTLSCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetTLSCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetTLSCertificateResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetTLSCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTLSCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTLSCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTLSCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__SetTLSCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTLSCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetTLSCertificateResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTLSCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTLSCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTLSCertificateResponse * SOAP_FMAC4 soap_get__sai__SetTLSCertificateResponse(struct soap *soap, _sai__SetTLSCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTLSCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTLSCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTLSCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTLSCertificateResponse * SOAP_FMAC4 soap_in__sai__SetTLSCertificateResponse(struct soap *soap, const char *tag, _sai__SetTLSCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTLSCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTLSCertificateResponse, sizeof(_sai__SetTLSCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTLSCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTLSCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetTLSCertificateResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTLSCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTLSCertificateResponse, 0, sizeof(_sai__SetTLSCertificateResponse), 0, soap_copy__sai__SetTLSCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTLSCertificateResponse * SOAP_FMAC6 soap_new__sai__SetTLSCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTLSCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSCertificateResponse(struct soap *soap, _sai__SetTLSCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTLSCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__SetTLSCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTLSCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTLSCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTLSCertificateResponse; + if (size) + *size = sizeof(_sai__SetTLSCertificateResponse); + ((_sai__SetTLSCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTLSCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__SetTLSCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__SetTLSCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTLSCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTLSCertificateResponse %p -> %p\n", q, p)); + *(_sai__SetTLSCertificateResponse*)p = *(_sai__SetTLSCertificateResponse*)q; +} + +void _sai__SetTLSCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__CertificateChainType(soap, &((_sai__SetTLSCertificate*)this)->CertificateChain); + /* transient soap skipped */ +} + +void _sai__SetTLSCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetTLSCertificate*)this)->CertificateChain = NULL; + /* transient soap skipped */ +} + +int _sai__SetTLSCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTLSCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTLSCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTLSCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSCertificate(struct soap *soap, const char *tag, int id, const _sai__SetTLSCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTLSCertificate), type); + soap_out_PointerTosai__CertificateChainType(soap, "sai:CertificateChain", -1, &(((_sai__SetTLSCertificate*)a)->CertificateChain), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTLSCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTLSCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTLSCertificate * SOAP_FMAC4 soap_get__sai__SetTLSCertificate(struct soap *soap, _sai__SetTLSCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTLSCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTLSCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTLSCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTLSCertificate * SOAP_FMAC4 soap_in__sai__SetTLSCertificate(struct soap *soap, const char *tag, _sai__SetTLSCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTLSCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTLSCertificate, sizeof(_sai__SetTLSCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTLSCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTLSCertificate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CertificateChain1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CertificateChain1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateChainType(soap, "sai:CertificateChain", &(((_sai__SetTLSCertificate*)a)->CertificateChain), "sai:CertificateChainType")) + { soap_flag_CertificateChain1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CertificateChain1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTLSCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTLSCertificate, 0, sizeof(_sai__SetTLSCertificate), 0, soap_copy__sai__SetTLSCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTLSCertificate * SOAP_FMAC6 soap_new__sai__SetTLSCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTLSCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSCertificate(struct soap *soap, _sai__SetTLSCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTLSCertificate * SOAP_FMAC4 soap_instantiate__sai__SetTLSCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTLSCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTLSCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTLSCertificate; + if (size) + *size = sizeof(_sai__SetTLSCertificate); + ((_sai__SetTLSCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTLSCertificate[n]; + if (size) + *size = n * sizeof(_sai__SetTLSCertificate); + for (int i = 0; i < n; i++) + ((_sai__SetTLSCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTLSCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTLSCertificate %p -> %p\n", q, p)); + *(_sai__SetTLSCertificate*)p = *(_sai__SetTLSCertificate*)q; +} + +void _sai__SetRngKeyResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetRngKeyResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetRngKeyResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetRngKeyResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetRngKeyResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetRngKeyResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetRngKeyResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetRngKeyResponse(struct soap *soap, const char *tag, int id, const _sai__SetRngKeyResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetRngKeyResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetRngKeyResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetRngKeyResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetRngKeyResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetRngKeyResponse * SOAP_FMAC4 soap_get__sai__SetRngKeyResponse(struct soap *soap, _sai__SetRngKeyResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetRngKeyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetRngKeyResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetRngKeyResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetRngKeyResponse * SOAP_FMAC4 soap_in__sai__SetRngKeyResponse(struct soap *soap, const char *tag, _sai__SetRngKeyResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetRngKeyResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetRngKeyResponse, sizeof(_sai__SetRngKeyResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetRngKeyResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetRngKeyResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetRngKeyResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetRngKeyResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetRngKeyResponse, 0, sizeof(_sai__SetRngKeyResponse), 0, soap_copy__sai__SetRngKeyResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetRngKeyResponse * SOAP_FMAC6 soap_new__sai__SetRngKeyResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetRngKeyResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetRngKeyResponse(struct soap *soap, _sai__SetRngKeyResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetRngKeyResponse * SOAP_FMAC4 soap_instantiate__sai__SetRngKeyResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetRngKeyResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetRngKeyResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetRngKeyResponse; + if (size) + *size = sizeof(_sai__SetRngKeyResponse); + ((_sai__SetRngKeyResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetRngKeyResponse[n]; + if (size) + *size = n * sizeof(_sai__SetRngKeyResponse); + for (int i = 0; i < n; i++) + ((_sai__SetRngKeyResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetRngKeyResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetRngKeyResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetRngKeyResponse %p -> %p\n", q, p)); + *(_sai__SetRngKeyResponse*)p = *(_sai__SetRngKeyResponse*)q; +} + +void _sai__SetRngKey::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__RngKeyType(soap, &((_sai__SetRngKey*)this)->Key); + /* transient soap skipped */ +} + +void _sai__SetRngKey::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetRngKey*)this)->Key = NULL; + /* transient soap skipped */ +} + +int _sai__SetRngKey::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetRngKey); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetRngKey::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetRngKey(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetRngKey(struct soap *soap, const char *tag, int id, const _sai__SetRngKey *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetRngKey), type); + soap_out_PointerTosai__RngKeyType(soap, "sai:Key", -1, &(((_sai__SetRngKey*)a)->Key), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetRngKey::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetRngKey(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetRngKey * SOAP_FMAC4 soap_get__sai__SetRngKey(struct soap *soap, _sai__SetRngKey *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetRngKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetRngKey::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetRngKey(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetRngKey * SOAP_FMAC4 soap_in__sai__SetRngKey(struct soap *soap, const char *tag, _sai__SetRngKey *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetRngKey *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetRngKey, sizeof(_sai__SetRngKey), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetRngKey) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetRngKey *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Key1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Key1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__RngKeyType(soap, "sai:Key", &(((_sai__SetRngKey*)a)->Key), "sai:RngKeyType")) + { soap_flag_Key1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Key1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetRngKey *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetRngKey, 0, sizeof(_sai__SetRngKey), 0, soap_copy__sai__SetRngKey); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetRngKey * SOAP_FMAC6 soap_new__sai__SetRngKey(struct soap *soap, int n) +{ return soap_instantiate__sai__SetRngKey(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetRngKey(struct soap *soap, _sai__SetRngKey *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetRngKey * SOAP_FMAC4 soap_instantiate__sai__SetRngKey(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetRngKey(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetRngKey, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetRngKey; + if (size) + *size = sizeof(_sai__SetRngKey); + ((_sai__SetRngKey*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetRngKey[n]; + if (size) + *size = n * sizeof(_sai__SetRngKey); + for (int i = 0; i < n; i++) + ((_sai__SetRngKey*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetRngKey*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetRngKey(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetRngKey %p -> %p\n", q, p)); + *(_sai__SetRngKey*)p = *(_sai__SetRngKey*)q; +} + +void _sai__SetTLSKeyAndCertificateResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetTLSKeyAndCertificateResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetTLSKeyAndCertificateResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetTLSKeyAndCertificateResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTLSKeyAndCertificateResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTLSKeyAndCertificateResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSKeyAndCertificateResponse(struct soap *soap, const char *tag, int id, const _sai__SetTLSKeyAndCertificateResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetTLSKeyAndCertificateResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTLSKeyAndCertificateResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTLSKeyAndCertificateResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse * SOAP_FMAC4 soap_get__sai__SetTLSKeyAndCertificateResponse(struct soap *soap, _sai__SetTLSKeyAndCertificateResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTLSKeyAndCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTLSKeyAndCertificateResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTLSKeyAndCertificateResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse * SOAP_FMAC4 soap_in__sai__SetTLSKeyAndCertificateResponse(struct soap *soap, const char *tag, _sai__SetTLSKeyAndCertificateResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTLSKeyAndCertificateResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse, sizeof(_sai__SetTLSKeyAndCertificateResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTLSKeyAndCertificateResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetTLSKeyAndCertificateResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTLSKeyAndCertificateResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse, 0, sizeof(_sai__SetTLSKeyAndCertificateResponse), 0, soap_copy__sai__SetTLSKeyAndCertificateResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTLSKeyAndCertificateResponse * SOAP_FMAC6 soap_new__sai__SetTLSKeyAndCertificateResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTLSKeyAndCertificateResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSKeyAndCertificateResponse(struct soap *soap, _sai__SetTLSKeyAndCertificateResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse * SOAP_FMAC4 soap_instantiate__sai__SetTLSKeyAndCertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTLSKeyAndCertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTLSKeyAndCertificateResponse; + if (size) + *size = sizeof(_sai__SetTLSKeyAndCertificateResponse); + ((_sai__SetTLSKeyAndCertificateResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTLSKeyAndCertificateResponse[n]; + if (size) + *size = n * sizeof(_sai__SetTLSKeyAndCertificateResponse); + for (int i = 0; i < n; i++) + ((_sai__SetTLSKeyAndCertificateResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTLSKeyAndCertificateResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSKeyAndCertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTLSKeyAndCertificateResponse %p -> %p\n", q, p)); + *(_sai__SetTLSKeyAndCertificateResponse*)p = *(_sai__SetTLSKeyAndCertificateResponse*)q; +} + +void _sai__SetTLSKeyAndCertificate::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__RsaKeyType(soap, &((_sai__SetTLSKeyAndCertificate*)this)->PrivateKey); + soap_serialize_PointerTosai__CertificateChainType(soap, &((_sai__SetTLSKeyAndCertificate*)this)->CertificateChain); + /* transient soap skipped */ +} + +void _sai__SetTLSKeyAndCertificate::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetTLSKeyAndCertificate*)this)->PrivateKey = NULL; + ((_sai__SetTLSKeyAndCertificate*)this)->CertificateChain = NULL; + /* transient soap skipped */ +} + +int _sai__SetTLSKeyAndCertificate::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTLSKeyAndCertificate); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTLSKeyAndCertificate::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTLSKeyAndCertificate(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTLSKeyAndCertificate(struct soap *soap, const char *tag, int id, const _sai__SetTLSKeyAndCertificate *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTLSKeyAndCertificate), type); + soap_out_PointerTosai__RsaKeyType(soap, "sai:PrivateKey", -1, &(((_sai__SetTLSKeyAndCertificate*)a)->PrivateKey), ""); + soap_out_PointerTosai__CertificateChainType(soap, "sai:CertificateChain", -1, &(((_sai__SetTLSKeyAndCertificate*)a)->CertificateChain), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTLSKeyAndCertificate::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTLSKeyAndCertificate(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_get__sai__SetTLSKeyAndCertificate(struct soap *soap, _sai__SetTLSKeyAndCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTLSKeyAndCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTLSKeyAndCertificate::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTLSKeyAndCertificate(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_in__sai__SetTLSKeyAndCertificate(struct soap *soap, const char *tag, _sai__SetTLSKeyAndCertificate *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTLSKeyAndCertificate *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTLSKeyAndCertificate, sizeof(_sai__SetTLSKeyAndCertificate), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTLSKeyAndCertificate) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTLSKeyAndCertificate *)a->soap_in(soap, tag, type); + } + } + short soap_flag_PrivateKey1 = 1, soap_flag_CertificateChain1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_PrivateKey1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__RsaKeyType(soap, "sai:PrivateKey", &(((_sai__SetTLSKeyAndCertificate*)a)->PrivateKey), "sai:RsaKeyType")) + { soap_flag_PrivateKey1--; + continue; + } + if (soap_flag_CertificateChain1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__CertificateChainType(soap, "sai:CertificateChain", &(((_sai__SetTLSKeyAndCertificate*)a)->CertificateChain), "sai:CertificateChainType")) + { soap_flag_CertificateChain1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CertificateChain1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTLSKeyAndCertificate *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTLSKeyAndCertificate, 0, sizeof(_sai__SetTLSKeyAndCertificate), 0, soap_copy__sai__SetTLSKeyAndCertificate); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTLSKeyAndCertificate * SOAP_FMAC6 soap_new__sai__SetTLSKeyAndCertificate(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTLSKeyAndCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTLSKeyAndCertificate(struct soap *soap, _sai__SetTLSKeyAndCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_instantiate__sai__SetTLSKeyAndCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTLSKeyAndCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTLSKeyAndCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTLSKeyAndCertificate; + if (size) + *size = sizeof(_sai__SetTLSKeyAndCertificate); + ((_sai__SetTLSKeyAndCertificate*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTLSKeyAndCertificate[n]; + if (size) + *size = n * sizeof(_sai__SetTLSKeyAndCertificate); + for (int i = 0; i < n; i++) + ((_sai__SetTLSKeyAndCertificate*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTLSKeyAndCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTLSKeyAndCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTLSKeyAndCertificate %p -> %p\n", q, p)); + *(_sai__SetTLSKeyAndCertificate*)p = *(_sai__SetTLSKeyAndCertificate*)q; +} + +void _sai__SetTlsEnabledResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetTlsEnabledResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetTlsEnabledResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetTlsEnabledResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTlsEnabledResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTlsEnabledResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTlsEnabledResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTlsEnabledResponse(struct soap *soap, const char *tag, int id, const _sai__SetTlsEnabledResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTlsEnabledResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetTlsEnabledResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTlsEnabledResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTlsEnabledResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTlsEnabledResponse * SOAP_FMAC4 soap_get__sai__SetTlsEnabledResponse(struct soap *soap, _sai__SetTlsEnabledResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTlsEnabledResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTlsEnabledResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTlsEnabledResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTlsEnabledResponse * SOAP_FMAC4 soap_in__sai__SetTlsEnabledResponse(struct soap *soap, const char *tag, _sai__SetTlsEnabledResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTlsEnabledResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTlsEnabledResponse, sizeof(_sai__SetTlsEnabledResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTlsEnabledResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTlsEnabledResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetTlsEnabledResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTlsEnabledResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTlsEnabledResponse, 0, sizeof(_sai__SetTlsEnabledResponse), 0, soap_copy__sai__SetTlsEnabledResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTlsEnabledResponse * SOAP_FMAC6 soap_new__sai__SetTlsEnabledResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTlsEnabledResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTlsEnabledResponse(struct soap *soap, _sai__SetTlsEnabledResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTlsEnabledResponse * SOAP_FMAC4 soap_instantiate__sai__SetTlsEnabledResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTlsEnabledResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTlsEnabledResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTlsEnabledResponse; + if (size) + *size = sizeof(_sai__SetTlsEnabledResponse); + ((_sai__SetTlsEnabledResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTlsEnabledResponse[n]; + if (size) + *size = n * sizeof(_sai__SetTlsEnabledResponse); + for (int i = 0; i < n; i++) + ((_sai__SetTlsEnabledResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTlsEnabledResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTlsEnabledResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTlsEnabledResponse %p -> %p\n", q, p)); + *(_sai__SetTlsEnabledResponse*)p = *(_sai__SetTlsEnabledResponse*)q; +} + +void _sai__SetTlsEnabled::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__SetTlsEnabled*)this)->Enabled, SOAP_TYPE_bool); + /* transient soap skipped */ +} + +void _sai__SetTlsEnabled::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((_sai__SetTlsEnabled*)this)->Enabled); + /* transient soap skipped */ +} + +int _sai__SetTlsEnabled::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetTlsEnabled); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetTlsEnabled::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetTlsEnabled(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetTlsEnabled(struct soap *soap, const char *tag, int id, const _sai__SetTlsEnabled *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetTlsEnabled), type); + soap_out_bool(soap, "sai:Enabled", -1, &(((_sai__SetTlsEnabled*)a)->Enabled), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetTlsEnabled::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetTlsEnabled(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetTlsEnabled * SOAP_FMAC4 soap_get__sai__SetTlsEnabled(struct soap *soap, _sai__SetTlsEnabled *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetTlsEnabled(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetTlsEnabled::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetTlsEnabled(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetTlsEnabled * SOAP_FMAC4 soap_in__sai__SetTlsEnabled(struct soap *soap, const char *tag, _sai__SetTlsEnabled *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetTlsEnabled *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetTlsEnabled, sizeof(_sai__SetTlsEnabled), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetTlsEnabled) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetTlsEnabled *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Enabled1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Enabled1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:Enabled", &(((_sai__SetTlsEnabled*)a)->Enabled), "xsd:boolean")) + { soap_flag_Enabled1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Enabled1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetTlsEnabled *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetTlsEnabled, 0, sizeof(_sai__SetTlsEnabled), 0, soap_copy__sai__SetTlsEnabled); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetTlsEnabled * SOAP_FMAC6 soap_new__sai__SetTlsEnabled(struct soap *soap, int n) +{ return soap_instantiate__sai__SetTlsEnabled(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetTlsEnabled(struct soap *soap, _sai__SetTlsEnabled *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetTlsEnabled * SOAP_FMAC4 soap_instantiate__sai__SetTlsEnabled(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetTlsEnabled(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetTlsEnabled, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetTlsEnabled; + if (size) + *size = sizeof(_sai__SetTlsEnabled); + ((_sai__SetTlsEnabled*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetTlsEnabled[n]; + if (size) + *size = n * sizeof(_sai__SetTlsEnabled); + for (int i = 0; i < n; i++) + ((_sai__SetTlsEnabled*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetTlsEnabled*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetTlsEnabled(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetTlsEnabled %p -> %p\n", q, p)); + *(_sai__SetTlsEnabled*)p = *(_sai__SetTlsEnabled*)q; +} + +void _sai__RemoveUserAclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__RemoveUserAclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__RemoveUserAclEntryResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__RemoveUserAclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__RemoveUserAclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__RemoveUserAclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__RemoveUserAclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__RemoveUserAclEntryResponse(struct soap *soap, const char *tag, int id, const _sai__RemoveUserAclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__RemoveUserAclEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__RemoveUserAclEntryResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__RemoveUserAclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__RemoveUserAclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse * SOAP_FMAC4 soap_get__sai__RemoveUserAclEntryResponse(struct soap *soap, _sai__RemoveUserAclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__RemoveUserAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__RemoveUserAclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__RemoveUserAclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse * SOAP_FMAC4 soap_in__sai__RemoveUserAclEntryResponse(struct soap *soap, const char *tag, _sai__RemoveUserAclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__RemoveUserAclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__RemoveUserAclEntryResponse, sizeof(_sai__RemoveUserAclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__RemoveUserAclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__RemoveUserAclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__RemoveUserAclEntryResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__RemoveUserAclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__RemoveUserAclEntryResponse, 0, sizeof(_sai__RemoveUserAclEntryResponse), 0, soap_copy__sai__RemoveUserAclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__RemoveUserAclEntryResponse * SOAP_FMAC6 soap_new__sai__RemoveUserAclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__RemoveUserAclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__RemoveUserAclEntryResponse(struct soap *soap, _sai__RemoveUserAclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__RemoveUserAclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__RemoveUserAclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__RemoveUserAclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__RemoveUserAclEntryResponse; + if (size) + *size = sizeof(_sai__RemoveUserAclEntryResponse); + ((_sai__RemoveUserAclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__RemoveUserAclEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__RemoveUserAclEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__RemoveUserAclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__RemoveUserAclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__RemoveUserAclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__RemoveUserAclEntryResponse %p -> %p\n", q, p)); + *(_sai__RemoveUserAclEntryResponse*)p = *(_sai__RemoveUserAclEntryResponse*)q; +} + +void _sai__RemoveUserAclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__RemoveUserAclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__UserAclEntryHandleType(soap, &((_sai__RemoveUserAclEntry*)this)->Handle); + /* transient soap skipped */ +} + +int _sai__RemoveUserAclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__RemoveUserAclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__RemoveUserAclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__RemoveUserAclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__RemoveUserAclEntry(struct soap *soap, const char *tag, int id, const _sai__RemoveUserAclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__RemoveUserAclEntry), type); + soap_out_sai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((_sai__RemoveUserAclEntry*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__RemoveUserAclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__RemoveUserAclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__RemoveUserAclEntry * SOAP_FMAC4 soap_get__sai__RemoveUserAclEntry(struct soap *soap, _sai__RemoveUserAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__RemoveUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__RemoveUserAclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__RemoveUserAclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__RemoveUserAclEntry * SOAP_FMAC4 soap_in__sai__RemoveUserAclEntry(struct soap *soap, const char *tag, _sai__RemoveUserAclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__RemoveUserAclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__RemoveUserAclEntry, sizeof(_sai__RemoveUserAclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__RemoveUserAclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__RemoveUserAclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclEntryHandleType(soap, "sai:Handle", &(((_sai__RemoveUserAclEntry*)a)->Handle), "sai:UserAclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__RemoveUserAclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__RemoveUserAclEntry, 0, sizeof(_sai__RemoveUserAclEntry), 0, soap_copy__sai__RemoveUserAclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__RemoveUserAclEntry * SOAP_FMAC6 soap_new__sai__RemoveUserAclEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__RemoveUserAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__RemoveUserAclEntry(struct soap *soap, _sai__RemoveUserAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__RemoveUserAclEntry * SOAP_FMAC4 soap_instantiate__sai__RemoveUserAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__RemoveUserAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__RemoveUserAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__RemoveUserAclEntry; + if (size) + *size = sizeof(_sai__RemoveUserAclEntry); + ((_sai__RemoveUserAclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__RemoveUserAclEntry[n]; + if (size) + *size = n * sizeof(_sai__RemoveUserAclEntry); + for (int i = 0; i < n; i++) + ((_sai__RemoveUserAclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__RemoveUserAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__RemoveUserAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__RemoveUserAclEntry %p -> %p\n", q, p)); + *(_sai__RemoveUserAclEntry*)p = *(_sai__RemoveUserAclEntry*)q; +} + +void _sai__UpdateUserAclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__UpdateUserAclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__UpdateUserAclEntryResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__UpdateUserAclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__UpdateUserAclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__UpdateUserAclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__UpdateUserAclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateUserAclEntryResponse(struct soap *soap, const char *tag, int id, const _sai__UpdateUserAclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__UpdateUserAclEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__UpdateUserAclEntryResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__UpdateUserAclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__UpdateUserAclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse * SOAP_FMAC4 soap_get__sai__UpdateUserAclEntryResponse(struct soap *soap, _sai__UpdateUserAclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__UpdateUserAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__UpdateUserAclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__UpdateUserAclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse * SOAP_FMAC4 soap_in__sai__UpdateUserAclEntryResponse(struct soap *soap, const char *tag, _sai__UpdateUserAclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__UpdateUserAclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__UpdateUserAclEntryResponse, sizeof(_sai__UpdateUserAclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__UpdateUserAclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__UpdateUserAclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__UpdateUserAclEntryResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__UpdateUserAclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__UpdateUserAclEntryResponse, 0, sizeof(_sai__UpdateUserAclEntryResponse), 0, soap_copy__sai__UpdateUserAclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__UpdateUserAclEntryResponse * SOAP_FMAC6 soap_new__sai__UpdateUserAclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__UpdateUserAclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateUserAclEntryResponse(struct soap *soap, _sai__UpdateUserAclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__UpdateUserAclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__UpdateUserAclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__UpdateUserAclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__UpdateUserAclEntryResponse; + if (size) + *size = sizeof(_sai__UpdateUserAclEntryResponse); + ((_sai__UpdateUserAclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__UpdateUserAclEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__UpdateUserAclEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__UpdateUserAclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__UpdateUserAclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateUserAclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__UpdateUserAclEntryResponse %p -> %p\n", q, p)); + *(_sai__UpdateUserAclEntryResponse*)p = *(_sai__UpdateUserAclEntryResponse*)q; +} + +void _sai__UpdateUserAclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__UserAclEntryType(soap, &((_sai__UpdateUserAclEntry*)this)->Entry); + /* transient soap skipped */ +} + +void _sai__UpdateUserAclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__UserAclEntryHandleType(soap, &((_sai__UpdateUserAclEntry*)this)->Handle); + ((_sai__UpdateUserAclEntry*)this)->Entry = NULL; + /* transient soap skipped */ +} + +int _sai__UpdateUserAclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__UpdateUserAclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__UpdateUserAclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__UpdateUserAclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__UpdateUserAclEntry(struct soap *soap, const char *tag, int id, const _sai__UpdateUserAclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__UpdateUserAclEntry), type); + soap_out_sai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((_sai__UpdateUserAclEntry*)a)->Handle), ""); + soap_out_PointerTosai__UserAclEntryType(soap, "sai:Entry", -1, &(((_sai__UpdateUserAclEntry*)a)->Entry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__UpdateUserAclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__UpdateUserAclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntry * SOAP_FMAC4 soap_get__sai__UpdateUserAclEntry(struct soap *soap, _sai__UpdateUserAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__UpdateUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__UpdateUserAclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__UpdateUserAclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntry * SOAP_FMAC4 soap_in__sai__UpdateUserAclEntry(struct soap *soap, const char *tag, _sai__UpdateUserAclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__UpdateUserAclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__UpdateUserAclEntry, sizeof(_sai__UpdateUserAclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__UpdateUserAclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__UpdateUserAclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1, soap_flag_Entry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclEntryHandleType(soap, "sai:Handle", &(((_sai__UpdateUserAclEntry*)a)->Handle), "sai:UserAclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + if (soap_flag_Entry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UserAclEntryType(soap, "sai:Entry", &(((_sai__UpdateUserAclEntry*)a)->Entry), "sai:UserAclEntryType")) + { soap_flag_Entry1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0 || soap_flag_Entry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__UpdateUserAclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__UpdateUserAclEntry, 0, sizeof(_sai__UpdateUserAclEntry), 0, soap_copy__sai__UpdateUserAclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__UpdateUserAclEntry * SOAP_FMAC6 soap_new__sai__UpdateUserAclEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__UpdateUserAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__UpdateUserAclEntry(struct soap *soap, _sai__UpdateUserAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntry * SOAP_FMAC4 soap_instantiate__sai__UpdateUserAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__UpdateUserAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__UpdateUserAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__UpdateUserAclEntry; + if (size) + *size = sizeof(_sai__UpdateUserAclEntry); + ((_sai__UpdateUserAclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__UpdateUserAclEntry[n]; + if (size) + *size = n * sizeof(_sai__UpdateUserAclEntry); + for (int i = 0; i < n; i++) + ((_sai__UpdateUserAclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__UpdateUserAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__UpdateUserAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__UpdateUserAclEntry %p -> %p\n", q, p)); + *(_sai__UpdateUserAclEntry*)p = *(_sai__UpdateUserAclEntry*)q; +} + +void _sai__GetAdminAclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_sai__AclStringType(soap, &((_sai__GetAdminAclEntryResponse*)this)->Username); + /* transient soap skipped */ +} + +void _sai__GetAdminAclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetAdminAclEntryResponse*)this)->StatusCode); + soap_default_sai__AclStringType(soap, &((_sai__GetAdminAclEntryResponse*)this)->Username); + /* transient soap skipped */ +} + +int _sai__GetAdminAclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetAdminAclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetAdminAclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetAdminAclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetAdminAclEntryResponse(struct soap *soap, const char *tag, int id, const _sai__GetAdminAclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetAdminAclEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetAdminAclEntryResponse*)a)->StatusCode), ""); + soap_out_sai__AclStringType(soap, "sai:Username", -1, &(((_sai__GetAdminAclEntryResponse*)a)->Username), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetAdminAclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetAdminAclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetAdminAclEntryResponse * SOAP_FMAC4 soap_get__sai__GetAdminAclEntryResponse(struct soap *soap, _sai__GetAdminAclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetAdminAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetAdminAclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetAdminAclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetAdminAclEntryResponse * SOAP_FMAC4 soap_in__sai__GetAdminAclEntryResponse(struct soap *soap, const char *tag, _sai__GetAdminAclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetAdminAclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetAdminAclEntryResponse, sizeof(_sai__GetAdminAclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetAdminAclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetAdminAclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Username1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetAdminAclEntryResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Username1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_sai__AclStringType(soap, "sai:Username", &(((_sai__GetAdminAclEntryResponse*)a)->Username), "sai:AclStringType")) + { soap_flag_Username1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Username1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetAdminAclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetAdminAclEntryResponse, 0, sizeof(_sai__GetAdminAclEntryResponse), 0, soap_copy__sai__GetAdminAclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetAdminAclEntryResponse * SOAP_FMAC6 soap_new__sai__GetAdminAclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetAdminAclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetAdminAclEntryResponse(struct soap *soap, _sai__GetAdminAclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetAdminAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__GetAdminAclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetAdminAclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetAdminAclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetAdminAclEntryResponse; + if (size) + *size = sizeof(_sai__GetAdminAclEntryResponse); + ((_sai__GetAdminAclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetAdminAclEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__GetAdminAclEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__GetAdminAclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetAdminAclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetAdminAclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetAdminAclEntryResponse %p -> %p\n", q, p)); + *(_sai__GetAdminAclEntryResponse*)p = *(_sai__GetAdminAclEntryResponse*)q; +} + +void _sai__GetAdminAclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetAdminAclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + /* transient soap skipped */ +} + +int _sai__GetAdminAclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetAdminAclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetAdminAclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetAdminAclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetAdminAclEntry(struct soap *soap, const char *tag, int id, const _sai__GetAdminAclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetAdminAclEntry), type); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetAdminAclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetAdminAclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetAdminAclEntry * SOAP_FMAC4 soap_get__sai__GetAdminAclEntry(struct soap *soap, _sai__GetAdminAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetAdminAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetAdminAclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetAdminAclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetAdminAclEntry * SOAP_FMAC4 soap_in__sai__GetAdminAclEntry(struct soap *soap, const char *tag, _sai__GetAdminAclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetAdminAclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetAdminAclEntry, sizeof(_sai__GetAdminAclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetAdminAclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetAdminAclEntry *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetAdminAclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetAdminAclEntry, 0, sizeof(_sai__GetAdminAclEntry), 0, soap_copy__sai__GetAdminAclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetAdminAclEntry * SOAP_FMAC6 soap_new__sai__GetAdminAclEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__GetAdminAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetAdminAclEntry(struct soap *soap, _sai__GetAdminAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetAdminAclEntry * SOAP_FMAC4 soap_instantiate__sai__GetAdminAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetAdminAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetAdminAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetAdminAclEntry; + if (size) + *size = sizeof(_sai__GetAdminAclEntry); + ((_sai__GetAdminAclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetAdminAclEntry[n]; + if (size) + *size = n * sizeof(_sai__GetAdminAclEntry); + for (int i = 0; i < n; i++) + ((_sai__GetAdminAclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetAdminAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetAdminAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetAdminAclEntry %p -> %p\n", q, p)); + *(_sai__GetAdminAclEntry*)p = *(_sai__GetAdminAclEntry*)q; +} + +void _sai__GetUserAclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__UserAclEntryType(soap, &((_sai__GetUserAclEntryResponse*)this)->Entry); + /* transient soap skipped */ +} + +void _sai__GetUserAclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__GetUserAclEntryResponse*)this)->StatusCode); + ((_sai__GetUserAclEntryResponse*)this)->Entry = NULL; + /* transient soap skipped */ +} + +int _sai__GetUserAclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetUserAclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetUserAclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetUserAclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetUserAclEntryResponse(struct soap *soap, const char *tag, int id, const _sai__GetUserAclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetUserAclEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__GetUserAclEntryResponse*)a)->StatusCode), ""); + soap_out_PointerTosai__UserAclEntryType(soap, "sai:Entry", -1, &(((_sai__GetUserAclEntryResponse*)a)->Entry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetUserAclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetUserAclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntryResponse * SOAP_FMAC4 soap_get__sai__GetUserAclEntryResponse(struct soap *soap, _sai__GetUserAclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetUserAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetUserAclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetUserAclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntryResponse * SOAP_FMAC4 soap_in__sai__GetUserAclEntryResponse(struct soap *soap, const char *tag, _sai__GetUserAclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetUserAclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetUserAclEntryResponse, sizeof(_sai__GetUserAclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetUserAclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetUserAclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Entry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__GetUserAclEntryResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Entry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UserAclEntryType(soap, "sai:Entry", &(((_sai__GetUserAclEntryResponse*)a)->Entry), "sai:UserAclEntryType")) + { soap_flag_Entry1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Entry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetUserAclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetUserAclEntryResponse, 0, sizeof(_sai__GetUserAclEntryResponse), 0, soap_copy__sai__GetUserAclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetUserAclEntryResponse * SOAP_FMAC6 soap_new__sai__GetUserAclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__GetUserAclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetUserAclEntryResponse(struct soap *soap, _sai__GetUserAclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetUserAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__GetUserAclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetUserAclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetUserAclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetUserAclEntryResponse; + if (size) + *size = sizeof(_sai__GetUserAclEntryResponse); + ((_sai__GetUserAclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetUserAclEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__GetUserAclEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__GetUserAclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetUserAclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetUserAclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetUserAclEntryResponse %p -> %p\n", q, p)); + *(_sai__GetUserAclEntryResponse*)p = *(_sai__GetUserAclEntryResponse*)q; +} + +void _sai__GetUserAclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__GetUserAclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__UserAclEntryHandleType(soap, &((_sai__GetUserAclEntry*)this)->Handle); + /* transient soap skipped */ +} + +int _sai__GetUserAclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__GetUserAclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__GetUserAclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__GetUserAclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__GetUserAclEntry(struct soap *soap, const char *tag, int id, const _sai__GetUserAclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__GetUserAclEntry), type); + soap_out_sai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((_sai__GetUserAclEntry*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__GetUserAclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__GetUserAclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntry * SOAP_FMAC4 soap_get__sai__GetUserAclEntry(struct soap *soap, _sai__GetUserAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__GetUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__GetUserAclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__GetUserAclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntry * SOAP_FMAC4 soap_in__sai__GetUserAclEntry(struct soap *soap, const char *tag, _sai__GetUserAclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__GetUserAclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__GetUserAclEntry, sizeof(_sai__GetUserAclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__GetUserAclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__GetUserAclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclEntryHandleType(soap, "sai:Handle", &(((_sai__GetUserAclEntry*)a)->Handle), "sai:UserAclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__GetUserAclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__GetUserAclEntry, 0, sizeof(_sai__GetUserAclEntry), 0, soap_copy__sai__GetUserAclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__GetUserAclEntry * SOAP_FMAC6 soap_new__sai__GetUserAclEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__GetUserAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__GetUserAclEntry(struct soap *soap, _sai__GetUserAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__GetUserAclEntry * SOAP_FMAC4 soap_instantiate__sai__GetUserAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__GetUserAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__GetUserAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__GetUserAclEntry; + if (size) + *size = sizeof(_sai__GetUserAclEntry); + ((_sai__GetUserAclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__GetUserAclEntry[n]; + if (size) + *size = n * sizeof(_sai__GetUserAclEntry); + for (int i = 0; i < n; i++) + ((_sai__GetUserAclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__GetUserAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__GetUserAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__GetUserAclEntry %p -> %p\n", q, p)); + *(_sai__GetUserAclEntry*)p = *(_sai__GetUserAclEntry*)q; +} + +void _sai__EnumerateUserAclEntriesResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__EnumerateUserAclEntriesResponse*)this)->TotalCount, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((_sai__EnumerateUserAclEntriesResponse*)this)->HandleCount, SOAP_TYPE_unsignedInt); + soap_serialize_PointerTosai__UserAclEntryHandleListType(soap, &((_sai__EnumerateUserAclEntriesResponse*)this)->Handles); + /* transient soap skipped */ +} + +void _sai__EnumerateUserAclEntriesResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__EnumerateUserAclEntriesResponse*)this)->StatusCode); + soap_default_unsignedInt(soap, &((_sai__EnumerateUserAclEntriesResponse*)this)->TotalCount); + soap_default_unsignedInt(soap, &((_sai__EnumerateUserAclEntriesResponse*)this)->HandleCount); + ((_sai__EnumerateUserAclEntriesResponse*)this)->Handles = NULL; + /* transient soap skipped */ +} + +int _sai__EnumerateUserAclEntriesResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnumerateUserAclEntriesResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnumerateUserAclEntriesResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnumerateUserAclEntriesResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateUserAclEntriesResponse(struct soap *soap, const char *tag, int id, const _sai__EnumerateUserAclEntriesResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnumerateUserAclEntriesResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__EnumerateUserAclEntriesResponse*)a)->StatusCode), ""); + soap_out_unsignedInt(soap, "sai:TotalCount", -1, &(((_sai__EnumerateUserAclEntriesResponse*)a)->TotalCount), ""); + soap_out_unsignedInt(soap, "sai:HandleCount", -1, &(((_sai__EnumerateUserAclEntriesResponse*)a)->HandleCount), ""); + soap_out_PointerTosai__UserAclEntryHandleListType(soap, "sai:Handles", -1, &(((_sai__EnumerateUserAclEntriesResponse*)a)->Handles), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnumerateUserAclEntriesResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnumerateUserAclEntriesResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse * SOAP_FMAC4 soap_get__sai__EnumerateUserAclEntriesResponse(struct soap *soap, _sai__EnumerateUserAclEntriesResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnumerateUserAclEntriesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnumerateUserAclEntriesResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnumerateUserAclEntriesResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse * SOAP_FMAC4 soap_in__sai__EnumerateUserAclEntriesResponse(struct soap *soap, const char *tag, _sai__EnumerateUserAclEntriesResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnumerateUserAclEntriesResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnumerateUserAclEntriesResponse, sizeof(_sai__EnumerateUserAclEntriesResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnumerateUserAclEntriesResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnumerateUserAclEntriesResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_TotalCount1 = 1, soap_flag_HandleCount1 = 1, soap_flag_Handles1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__EnumerateUserAclEntriesResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_TotalCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:TotalCount", &(((_sai__EnumerateUserAclEntriesResponse*)a)->TotalCount), "xsd:unsignedInt")) + { soap_flag_TotalCount1--; + continue; + } + if (soap_flag_HandleCount1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:HandleCount", &(((_sai__EnumerateUserAclEntriesResponse*)a)->HandleCount), "xsd:unsignedInt")) + { soap_flag_HandleCount1--; + continue; + } + if (soap_flag_Handles1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UserAclEntryHandleListType(soap, "sai:Handles", &(((_sai__EnumerateUserAclEntriesResponse*)a)->Handles), "sai:UserAclEntryHandleListType")) + { soap_flag_Handles1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_TotalCount1 > 0 || soap_flag_HandleCount1 > 0 || soap_flag_Handles1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnumerateUserAclEntriesResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnumerateUserAclEntriesResponse, 0, sizeof(_sai__EnumerateUserAclEntriesResponse), 0, soap_copy__sai__EnumerateUserAclEntriesResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnumerateUserAclEntriesResponse * SOAP_FMAC6 soap_new__sai__EnumerateUserAclEntriesResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__EnumerateUserAclEntriesResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateUserAclEntriesResponse(struct soap *soap, _sai__EnumerateUserAclEntriesResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse * SOAP_FMAC4 soap_instantiate__sai__EnumerateUserAclEntriesResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnumerateUserAclEntriesResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnumerateUserAclEntriesResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnumerateUserAclEntriesResponse; + if (size) + *size = sizeof(_sai__EnumerateUserAclEntriesResponse); + ((_sai__EnumerateUserAclEntriesResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnumerateUserAclEntriesResponse[n]; + if (size) + *size = n * sizeof(_sai__EnumerateUserAclEntriesResponse); + for (int i = 0; i < n; i++) + ((_sai__EnumerateUserAclEntriesResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnumerateUserAclEntriesResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateUserAclEntriesResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnumerateUserAclEntriesResponse %p -> %p\n", q, p)); + *(_sai__EnumerateUserAclEntriesResponse*)p = *(_sai__EnumerateUserAclEntriesResponse*)q; +} + +void _sai__EnumerateUserAclEntries::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((_sai__EnumerateUserAclEntries*)this)->StartIndex, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void _sai__EnumerateUserAclEntries::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((_sai__EnumerateUserAclEntries*)this)->StartIndex); + /* transient soap skipped */ +} + +int _sai__EnumerateUserAclEntries::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__EnumerateUserAclEntries); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__EnumerateUserAclEntries::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__EnumerateUserAclEntries(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__EnumerateUserAclEntries(struct soap *soap, const char *tag, int id, const _sai__EnumerateUserAclEntries *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__EnumerateUserAclEntries), type); + soap_out_unsignedInt(soap, "sai:StartIndex", -1, &(((_sai__EnumerateUserAclEntries*)a)->StartIndex), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__EnumerateUserAclEntries::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__EnumerateUserAclEntries(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_get__sai__EnumerateUserAclEntries(struct soap *soap, _sai__EnumerateUserAclEntries *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__EnumerateUserAclEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__EnumerateUserAclEntries::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__EnumerateUserAclEntries(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_in__sai__EnumerateUserAclEntries(struct soap *soap, const char *tag, _sai__EnumerateUserAclEntries *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__EnumerateUserAclEntries *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__EnumerateUserAclEntries, sizeof(_sai__EnumerateUserAclEntries), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__EnumerateUserAclEntries) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__EnumerateUserAclEntries *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StartIndex1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StartIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:StartIndex", &(((_sai__EnumerateUserAclEntries*)a)->StartIndex), "xsd:unsignedInt")) + { soap_flag_StartIndex1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StartIndex1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__EnumerateUserAclEntries *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__EnumerateUserAclEntries, 0, sizeof(_sai__EnumerateUserAclEntries), 0, soap_copy__sai__EnumerateUserAclEntries); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__EnumerateUserAclEntries * SOAP_FMAC6 soap_new__sai__EnumerateUserAclEntries(struct soap *soap, int n) +{ return soap_instantiate__sai__EnumerateUserAclEntries(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__EnumerateUserAclEntries(struct soap *soap, _sai__EnumerateUserAclEntries *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_instantiate__sai__EnumerateUserAclEntries(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__EnumerateUserAclEntries(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__EnumerateUserAclEntries, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__EnumerateUserAclEntries; + if (size) + *size = sizeof(_sai__EnumerateUserAclEntries); + ((_sai__EnumerateUserAclEntries*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__EnumerateUserAclEntries[n]; + if (size) + *size = n * sizeof(_sai__EnumerateUserAclEntries); + for (int i = 0; i < n; i++) + ((_sai__EnumerateUserAclEntries*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__EnumerateUserAclEntries*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__EnumerateUserAclEntries(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__EnumerateUserAclEntries %p -> %p\n", q, p)); + *(_sai__EnumerateUserAclEntries*)p = *(_sai__EnumerateUserAclEntries*)q; +} + +void _sai__SetAdminAclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__SetAdminAclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__SetAdminAclEntryResponse*)this)->StatusCode); + /* transient soap skipped */ +} + +int _sai__SetAdminAclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetAdminAclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetAdminAclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetAdminAclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAdminAclEntryResponse(struct soap *soap, const char *tag, int id, const _sai__SetAdminAclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetAdminAclEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__SetAdminAclEntryResponse*)a)->StatusCode), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetAdminAclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetAdminAclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryResponse * SOAP_FMAC4 soap_get__sai__SetAdminAclEntryResponse(struct soap *soap, _sai__SetAdminAclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetAdminAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetAdminAclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetAdminAclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryResponse * SOAP_FMAC4 soap_in__sai__SetAdminAclEntryResponse(struct soap *soap, const char *tag, _sai__SetAdminAclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetAdminAclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetAdminAclEntryResponse, sizeof(_sai__SetAdminAclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetAdminAclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetAdminAclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__SetAdminAclEntryResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetAdminAclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetAdminAclEntryResponse, 0, sizeof(_sai__SetAdminAclEntryResponse), 0, soap_copy__sai__SetAdminAclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetAdminAclEntryResponse * SOAP_FMAC6 soap_new__sai__SetAdminAclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__SetAdminAclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAdminAclEntryResponse(struct soap *soap, _sai__SetAdminAclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__SetAdminAclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetAdminAclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetAdminAclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetAdminAclEntryResponse; + if (size) + *size = sizeof(_sai__SetAdminAclEntryResponse); + ((_sai__SetAdminAclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetAdminAclEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__SetAdminAclEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__SetAdminAclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetAdminAclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAdminAclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetAdminAclEntryResponse %p -> %p\n", q, p)); + *(_sai__SetAdminAclEntryResponse*)p = *(_sai__SetAdminAclEntryResponse*)q; +} + +void _sai__SetAdminAclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__AdminAclEntryType(soap, &((_sai__SetAdminAclEntry*)this)->Entry); + /* transient soap skipped */ +} + +void _sai__SetAdminAclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__SetAdminAclEntry*)this)->Entry = NULL; + /* transient soap skipped */ +} + +int _sai__SetAdminAclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__SetAdminAclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__SetAdminAclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__SetAdminAclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__SetAdminAclEntry(struct soap *soap, const char *tag, int id, const _sai__SetAdminAclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__SetAdminAclEntry), type); + soap_out_PointerTosai__AdminAclEntryType(soap, "sai:Entry", -1, &(((_sai__SetAdminAclEntry*)a)->Entry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__SetAdminAclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__SetAdminAclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntry * SOAP_FMAC4 soap_get__sai__SetAdminAclEntry(struct soap *soap, _sai__SetAdminAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__SetAdminAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__SetAdminAclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__SetAdminAclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntry * SOAP_FMAC4 soap_in__sai__SetAdminAclEntry(struct soap *soap, const char *tag, _sai__SetAdminAclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__SetAdminAclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__SetAdminAclEntry, sizeof(_sai__SetAdminAclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__SetAdminAclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__SetAdminAclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Entry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Entry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__AdminAclEntryType(soap, "sai:Entry", &(((_sai__SetAdminAclEntry*)a)->Entry), "sai:AdminAclEntryType")) + { soap_flag_Entry1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Entry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__SetAdminAclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__SetAdminAclEntry, 0, sizeof(_sai__SetAdminAclEntry), 0, soap_copy__sai__SetAdminAclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__SetAdminAclEntry * SOAP_FMAC6 soap_new__sai__SetAdminAclEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__SetAdminAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__SetAdminAclEntry(struct soap *soap, _sai__SetAdminAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__SetAdminAclEntry * SOAP_FMAC4 soap_instantiate__sai__SetAdminAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__SetAdminAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__SetAdminAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__SetAdminAclEntry; + if (size) + *size = sizeof(_sai__SetAdminAclEntry); + ((_sai__SetAdminAclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__SetAdminAclEntry[n]; + if (size) + *size = n * sizeof(_sai__SetAdminAclEntry); + for (int i = 0; i < n; i++) + ((_sai__SetAdminAclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__SetAdminAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__SetAdminAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__SetAdminAclEntry %p -> %p\n", q, p)); + *(_sai__SetAdminAclEntry*)p = *(_sai__SetAdminAclEntry*)q; +} + +void _sai__AddUserAclEntryResponse::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void _sai__AddUserAclEntryResponse::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__PT_USCORESTATUS(soap, &((_sai__AddUserAclEntryResponse*)this)->StatusCode); + soap_default_sai__UserAclEntryHandleType(soap, &((_sai__AddUserAclEntryResponse*)this)->Handle); + /* transient soap skipped */ +} + +int _sai__AddUserAclEntryResponse::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__AddUserAclEntryResponse); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__AddUserAclEntryResponse::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__AddUserAclEntryResponse(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddUserAclEntryResponse(struct soap *soap, const char *tag, int id, const _sai__AddUserAclEntryResponse *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__AddUserAclEntryResponse), type); + soap_element_result(soap, "sai:StatusCode"); + soap_out_sai__PT_USCORESTATUS(soap, "sai:StatusCode", -1, &(((_sai__AddUserAclEntryResponse*)a)->StatusCode), ""); + soap_out_sai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((_sai__AddUserAclEntryResponse*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__AddUserAclEntryResponse::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__AddUserAclEntryResponse(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntryResponse * SOAP_FMAC4 soap_get__sai__AddUserAclEntryResponse(struct soap *soap, _sai__AddUserAclEntryResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__AddUserAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__AddUserAclEntryResponse::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__AddUserAclEntryResponse(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntryResponse * SOAP_FMAC4 soap_in__sai__AddUserAclEntryResponse(struct soap *soap, const char *tag, _sai__AddUserAclEntryResponse *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__AddUserAclEntryResponse *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__AddUserAclEntryResponse, sizeof(_sai__AddUserAclEntryResponse), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__AddUserAclEntryResponse) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__AddUserAclEntryResponse *)a->soap_in(soap, tag, type); + } + } + short soap_flag_StatusCode1 = 1, soap_flag_Handle1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_StatusCode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__PT_USCORESTATUS(soap, "sai:StatusCode", &(((_sai__AddUserAclEntryResponse*)a)->StatusCode), "sai:PT_STATUS")) + { soap_flag_StatusCode1--; + continue; + } + if (soap_flag_Handle1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__UserAclEntryHandleType(soap, "sai:Handle", &(((_sai__AddUserAclEntryResponse*)a)->Handle), "sai:UserAclEntryHandleType")) + { soap_flag_Handle1--; + continue; + } + /* transient soap skipped */ + soap_check_result(soap, "sai:StatusCode"); + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_StatusCode1 > 0 || soap_flag_Handle1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__AddUserAclEntryResponse *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__AddUserAclEntryResponse, 0, sizeof(_sai__AddUserAclEntryResponse), 0, soap_copy__sai__AddUserAclEntryResponse); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__AddUserAclEntryResponse * SOAP_FMAC6 soap_new__sai__AddUserAclEntryResponse(struct soap *soap, int n) +{ return soap_instantiate__sai__AddUserAclEntryResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddUserAclEntryResponse(struct soap *soap, _sai__AddUserAclEntryResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__AddUserAclEntryResponse * SOAP_FMAC4 soap_instantiate__sai__AddUserAclEntryResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__AddUserAclEntryResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__AddUserAclEntryResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__AddUserAclEntryResponse; + if (size) + *size = sizeof(_sai__AddUserAclEntryResponse); + ((_sai__AddUserAclEntryResponse*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__AddUserAclEntryResponse[n]; + if (size) + *size = n * sizeof(_sai__AddUserAclEntryResponse); + for (int i = 0; i < n; i++) + ((_sai__AddUserAclEntryResponse*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__AddUserAclEntryResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddUserAclEntryResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__AddUserAclEntryResponse %p -> %p\n", q, p)); + *(_sai__AddUserAclEntryResponse*)p = *(_sai__AddUserAclEntryResponse*)q; +} + +void _sai__AddUserAclEntry::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__UserAclEntryType(soap, &((_sai__AddUserAclEntry*)this)->Entry); + /* transient soap skipped */ +} + +void _sai__AddUserAclEntry::soap_default(struct soap *soap) +{ + this->soap = soap; + ((_sai__AddUserAclEntry*)this)->Entry = NULL; + /* transient soap skipped */ +} + +int _sai__AddUserAclEntry::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE__sai__AddUserAclEntry); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int _sai__AddUserAclEntry::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out__sai__AddUserAclEntry(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__AddUserAclEntry(struct soap *soap, const char *tag, int id, const _sai__AddUserAclEntry *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE__sai__AddUserAclEntry), type); + soap_out_PointerTosai__UserAclEntryType(soap, "sai:Entry", -1, &(((_sai__AddUserAclEntry*)a)->Entry), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *_sai__AddUserAclEntry::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get__sai__AddUserAclEntry(soap, this, tag, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntry * SOAP_FMAC4 soap_get__sai__AddUserAclEntry(struct soap *soap, _sai__AddUserAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in__sai__AddUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *_sai__AddUserAclEntry::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in__sai__AddUserAclEntry(soap, tag, this, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntry * SOAP_FMAC4 soap_in__sai__AddUserAclEntry(struct soap *soap, const char *tag, _sai__AddUserAclEntry *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (_sai__AddUserAclEntry *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE__sai__AddUserAclEntry, sizeof(_sai__AddUserAclEntry), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE__sai__AddUserAclEntry) + { soap_revert(soap); + *soap->id = '\0'; + return (_sai__AddUserAclEntry *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Entry1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Entry1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UserAclEntryType(soap, "sai:Entry", &(((_sai__AddUserAclEntry*)a)->Entry), "sai:UserAclEntryType")) + { soap_flag_Entry1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Entry1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (_sai__AddUserAclEntry *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE__sai__AddUserAclEntry, 0, sizeof(_sai__AddUserAclEntry), 0, soap_copy__sai__AddUserAclEntry); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 _sai__AddUserAclEntry * SOAP_FMAC6 soap_new__sai__AddUserAclEntry(struct soap *soap, int n) +{ return soap_instantiate__sai__AddUserAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete__sai__AddUserAclEntry(struct soap *soap, _sai__AddUserAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 _sai__AddUserAclEntry * SOAP_FMAC4 soap_instantiate__sai__AddUserAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate__sai__AddUserAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE__sai__AddUserAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new _sai__AddUserAclEntry; + if (size) + *size = sizeof(_sai__AddUserAclEntry); + ((_sai__AddUserAclEntry*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new _sai__AddUserAclEntry[n]; + if (size) + *size = n * sizeof(_sai__AddUserAclEntry); + for (int i = 0; i < n; i++) + ((_sai__AddUserAclEntry*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (_sai__AddUserAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy__sai__AddUserAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying _sai__AddUserAclEntry %p -> %p\n", q, p)); + *(_sai__AddUserAclEntry*)p = *(_sai__AddUserAclEntry*)q; +} + +void sai__GlobalPowerPolicyType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__GlobalPowerPolicyType*)this)->IdleWakeTimeout, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void sai__GlobalPowerPolicyType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((sai__GlobalPowerPolicyType*)this)->IdleWakeTimeout); + /* transient soap skipped */ +} + +int sai__GlobalPowerPolicyType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__GlobalPowerPolicyType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__GlobalPowerPolicyType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__GlobalPowerPolicyType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__GlobalPowerPolicyType(struct soap *soap, const char *tag, int id, const sai__GlobalPowerPolicyType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__GlobalPowerPolicyType), type); + soap_out_unsignedInt(soap, "sai:IdleWakeTimeout", -1, &(((sai__GlobalPowerPolicyType*)a)->IdleWakeTimeout), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__GlobalPowerPolicyType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__GlobalPowerPolicyType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__GlobalPowerPolicyType * SOAP_FMAC4 soap_get_sai__GlobalPowerPolicyType(struct soap *soap, sai__GlobalPowerPolicyType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__GlobalPowerPolicyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__GlobalPowerPolicyType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__GlobalPowerPolicyType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__GlobalPowerPolicyType * SOAP_FMAC4 soap_in_sai__GlobalPowerPolicyType(struct soap *soap, const char *tag, sai__GlobalPowerPolicyType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__GlobalPowerPolicyType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__GlobalPowerPolicyType, sizeof(sai__GlobalPowerPolicyType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__GlobalPowerPolicyType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__GlobalPowerPolicyType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_IdleWakeTimeout1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_IdleWakeTimeout1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:IdleWakeTimeout", &(((sai__GlobalPowerPolicyType*)a)->IdleWakeTimeout), "xsd:unsignedInt")) + { soap_flag_IdleWakeTimeout1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_IdleWakeTimeout1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__GlobalPowerPolicyType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__GlobalPowerPolicyType, 0, sizeof(sai__GlobalPowerPolicyType), 0, soap_copy_sai__GlobalPowerPolicyType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__GlobalPowerPolicyType * SOAP_FMAC6 soap_new_sai__GlobalPowerPolicyType(struct soap *soap, int n) +{ return soap_instantiate_sai__GlobalPowerPolicyType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__GlobalPowerPolicyType(struct soap *soap, sai__GlobalPowerPolicyType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__GlobalPowerPolicyType * SOAP_FMAC4 soap_instantiate_sai__GlobalPowerPolicyType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__GlobalPowerPolicyType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__GlobalPowerPolicyType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__GlobalPowerPolicyType; + if (size) + *size = sizeof(sai__GlobalPowerPolicyType); + ((sai__GlobalPowerPolicyType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__GlobalPowerPolicyType[n]; + if (size) + *size = n * sizeof(sai__GlobalPowerPolicyType); + for (int i = 0; i < n; i++) + ((sai__GlobalPowerPolicyType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__GlobalPowerPolicyType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__GlobalPowerPolicyType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__GlobalPowerPolicyType %p -> %p\n", q, p)); + *(sai__GlobalPowerPolicyType*)p = *(sai__GlobalPowerPolicyType*)q; +} + +void sai__EnvironmentDetectionType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__EnvironmentDetectionDomainType(soap, &((sai__EnvironmentDetectionType*)this)->LocalDomains); + soap_serialize_PointerTounsignedInt(soap, &((sai__EnvironmentDetectionType*)this)->ExternalCircuitBreakerPolicy); + /* transient soap skipped */ +} + +void sai__EnvironmentDetectionType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((sai__EnvironmentDetectionType*)this)->LocalDomains = NULL; + ((sai__EnvironmentDetectionType*)this)->ExternalCircuitBreakerPolicy = NULL; + /* transient soap skipped */ +} + +int sai__EnvironmentDetectionType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__EnvironmentDetectionType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__EnvironmentDetectionType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__EnvironmentDetectionType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__EnvironmentDetectionType(struct soap *soap, const char *tag, int id, const sai__EnvironmentDetectionType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__EnvironmentDetectionType), type); + soap_out_PointerTosai__EnvironmentDetectionDomainType(soap, "sai:LocalDomains", -1, &(((sai__EnvironmentDetectionType*)a)->LocalDomains), ""); + soap_out_PointerTounsignedInt(soap, "sai:ExternalCircuitBreakerPolicy", -1, &(((sai__EnvironmentDetectionType*)a)->ExternalCircuitBreakerPolicy), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__EnvironmentDetectionType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__EnvironmentDetectionType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__EnvironmentDetectionType * SOAP_FMAC4 soap_get_sai__EnvironmentDetectionType(struct soap *soap, sai__EnvironmentDetectionType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__EnvironmentDetectionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__EnvironmentDetectionType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__EnvironmentDetectionType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__EnvironmentDetectionType * SOAP_FMAC4 soap_in_sai__EnvironmentDetectionType(struct soap *soap, const char *tag, sai__EnvironmentDetectionType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__EnvironmentDetectionType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__EnvironmentDetectionType, sizeof(sai__EnvironmentDetectionType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__EnvironmentDetectionType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__EnvironmentDetectionType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_LocalDomains1 = 1, soap_flag_ExternalCircuitBreakerPolicy1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_LocalDomains1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__EnvironmentDetectionDomainType(soap, "sai:LocalDomains", &(((sai__EnvironmentDetectionType*)a)->LocalDomains), "sai:EnvironmentDetectionDomainType")) + { soap_flag_LocalDomains1--; + continue; + } + if (soap_flag_ExternalCircuitBreakerPolicy1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTounsignedInt(soap, "sai:ExternalCircuitBreakerPolicy", &(((sai__EnvironmentDetectionType*)a)->ExternalCircuitBreakerPolicy), "xsd:unsignedInt")) + { soap_flag_ExternalCircuitBreakerPolicy1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_LocalDomains1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__EnvironmentDetectionType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__EnvironmentDetectionType, 0, sizeof(sai__EnvironmentDetectionType), 0, soap_copy_sai__EnvironmentDetectionType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__EnvironmentDetectionType * SOAP_FMAC6 soap_new_sai__EnvironmentDetectionType(struct soap *soap, int n) +{ return soap_instantiate_sai__EnvironmentDetectionType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__EnvironmentDetectionType(struct soap *soap, sai__EnvironmentDetectionType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__EnvironmentDetectionType * SOAP_FMAC4 soap_instantiate_sai__EnvironmentDetectionType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__EnvironmentDetectionType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__EnvironmentDetectionType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__EnvironmentDetectionType; + if (size) + *size = sizeof(sai__EnvironmentDetectionType); + ((sai__EnvironmentDetectionType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__EnvironmentDetectionType[n]; + if (size) + *size = n * sizeof(sai__EnvironmentDetectionType); + for (int i = 0; i < n; i++) + ((sai__EnvironmentDetectionType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__EnvironmentDetectionType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__EnvironmentDetectionType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__EnvironmentDetectionType %p -> %p\n", q, p)); + *(sai__EnvironmentDetectionType*)p = *(sai__EnvironmentDetectionType*)q; +} + +void sai__EnvironmentDetectionDomainType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfstd__string(soap, &((sai__EnvironmentDetectionDomainType*)this)->values); + /* transient soap skipped */ +} + +void sai__EnvironmentDetectionDomainType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfstd__string(soap, &((sai__EnvironmentDetectionDomainType*)this)->values); + /* transient soap skipped */ +} + +int sai__EnvironmentDetectionDomainType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__EnvironmentDetectionDomainType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__EnvironmentDetectionDomainType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__EnvironmentDetectionDomainType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__EnvironmentDetectionDomainType(struct soap *soap, const char *tag, int id, const sai__EnvironmentDetectionDomainType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__EnvironmentDetectionDomainType), type); + soap_out_std__vectorTemplateOfstd__string(soap, "sai:values", -1, &(((sai__EnvironmentDetectionDomainType*)a)->values), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__EnvironmentDetectionDomainType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__EnvironmentDetectionDomainType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__EnvironmentDetectionDomainType * SOAP_FMAC4 soap_get_sai__EnvironmentDetectionDomainType(struct soap *soap, sai__EnvironmentDetectionDomainType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__EnvironmentDetectionDomainType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__EnvironmentDetectionDomainType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__EnvironmentDetectionDomainType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__EnvironmentDetectionDomainType * SOAP_FMAC4 soap_in_sai__EnvironmentDetectionDomainType(struct soap *soap, const char *tag, sai__EnvironmentDetectionDomainType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__EnvironmentDetectionDomainType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__EnvironmentDetectionDomainType, sizeof(sai__EnvironmentDetectionDomainType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__EnvironmentDetectionDomainType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__EnvironmentDetectionDomainType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfstd__string(soap, "sai:values", &(((sai__EnvironmentDetectionDomainType*)a)->values), "xsd:string")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((sai__EnvironmentDetectionDomainType*)a)->values.size() > 5)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__EnvironmentDetectionDomainType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__EnvironmentDetectionDomainType, 0, sizeof(sai__EnvironmentDetectionDomainType), 0, soap_copy_sai__EnvironmentDetectionDomainType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__EnvironmentDetectionDomainType * SOAP_FMAC6 soap_new_sai__EnvironmentDetectionDomainType(struct soap *soap, int n) +{ return soap_instantiate_sai__EnvironmentDetectionDomainType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__EnvironmentDetectionDomainType(struct soap *soap, sai__EnvironmentDetectionDomainType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__EnvironmentDetectionDomainType * SOAP_FMAC4 soap_instantiate_sai__EnvironmentDetectionDomainType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__EnvironmentDetectionDomainType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__EnvironmentDetectionDomainType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__EnvironmentDetectionDomainType; + if (size) + *size = sizeof(sai__EnvironmentDetectionDomainType); + ((sai__EnvironmentDetectionDomainType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__EnvironmentDetectionDomainType[n]; + if (size) + *size = n * sizeof(sai__EnvironmentDetectionDomainType); + for (int i = 0; i < n; i++) + ((sai__EnvironmentDetectionDomainType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__EnvironmentDetectionDomainType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__EnvironmentDetectionDomainType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__EnvironmentDetectionDomainType %p -> %p\n", q, p)); + *(sai__EnvironmentDetectionDomainType*)p = *(sai__EnvironmentDetectionDomainType*)q; +} + +void sai__ProvisioningAuditRecordType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__ProvisioningAuditRecordType*)this)->SecureDNS, SOAP_TYPE_bool); + soap_embedded(soap, &((sai__ProvisioningAuditRecordType*)this)->HostInitiated, SOAP_TYPE_bool); + soap_serialize_PointerTostd__string(soap, &((sai__ProvisioningAuditRecordType*)this)->ProvServerFQDN); + soap_embedded(soap, &((sai__ProvisioningAuditRecordType*)this)->SelectedHashData, SOAP_TYPE_xsd__base64Binary); + ((sai__ProvisioningAuditRecordType*)this)->SelectedHashData.soap_serialize(soap); + soap_serialize_std__vectorTemplateOfxsd__base64Binary(soap, &((sai__ProvisioningAuditRecordType*)this)->CaCertSerials); + soap_serialize_PointerTobool(soap, &((sai__ProvisioningAuditRecordType*)this)->AdditionalCaSerialNums); + soap_embedded(soap, &((sai__ProvisioningAuditRecordType*)this)->IsOemDefault, SOAP_TYPE_bool); + soap_embedded(soap, &((sai__ProvisioningAuditRecordType*)this)->IsTimeValid, SOAP_TYPE_bool); + soap_embedded(soap, &((sai__ProvisioningAuditRecordType*)this)->TlsStartTime, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void sai__ProvisioningAuditRecordType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__ProvisioningTLSModeType(soap, &((sai__ProvisioningAuditRecordType*)this)->ProvisioningTLSMode); + soap_default_bool(soap, &((sai__ProvisioningAuditRecordType*)this)->SecureDNS); + soap_default_bool(soap, &((sai__ProvisioningAuditRecordType*)this)->HostInitiated); + ((sai__ProvisioningAuditRecordType*)this)->ProvServerFQDN = NULL; + soap_default_sai__HashTypeType(soap, &((sai__ProvisioningAuditRecordType*)this)->SelectedHashType); + ((sai__ProvisioningAuditRecordType*)this)->SelectedHashData.xsd__base64Binary::soap_default(soap); + soap_default_std__vectorTemplateOfxsd__base64Binary(soap, &((sai__ProvisioningAuditRecordType*)this)->CaCertSerials); + ((sai__ProvisioningAuditRecordType*)this)->AdditionalCaSerialNums = NULL; + soap_default_bool(soap, &((sai__ProvisioningAuditRecordType*)this)->IsOemDefault); + soap_default_bool(soap, &((sai__ProvisioningAuditRecordType*)this)->IsTimeValid); + soap_default_sai__IPv4AddressType(soap, &((sai__ProvisioningAuditRecordType*)this)->ProvServerIP); + soap_default_unsignedInt(soap, &((sai__ProvisioningAuditRecordType*)this)->TlsStartTime); + /* transient soap skipped */ +} + +int sai__ProvisioningAuditRecordType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__ProvisioningAuditRecordType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__ProvisioningAuditRecordType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__ProvisioningAuditRecordType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__ProvisioningAuditRecordType(struct soap *soap, const char *tag, int id, const sai__ProvisioningAuditRecordType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__ProvisioningAuditRecordType), type); + soap_out_sai__ProvisioningTLSModeType(soap, "sai:ProvisioningTLSMode", -1, &(((sai__ProvisioningAuditRecordType*)a)->ProvisioningTLSMode), ""); + soap_out_bool(soap, "sai:SecureDNS", -1, &(((sai__ProvisioningAuditRecordType*)a)->SecureDNS), ""); + soap_out_bool(soap, "sai:HostInitiated", -1, &(((sai__ProvisioningAuditRecordType*)a)->HostInitiated), ""); + soap_out_PointerTostd__string(soap, "sai:ProvServerFQDN", -1, &(((sai__ProvisioningAuditRecordType*)a)->ProvServerFQDN), ""); + soap_out_sai__HashTypeType(soap, "sai:SelectedHashType", -1, &(((sai__ProvisioningAuditRecordType*)a)->SelectedHashType), ""); + (((sai__ProvisioningAuditRecordType*)a)->SelectedHashData).soap_out(soap, "sai:SelectedHashData", -1, ""); + soap_out_std__vectorTemplateOfxsd__base64Binary(soap, "sai:CaCertSerials", -1, &(((sai__ProvisioningAuditRecordType*)a)->CaCertSerials), ""); + soap_out_PointerTobool(soap, "sai:AdditionalCaSerialNums", -1, &(((sai__ProvisioningAuditRecordType*)a)->AdditionalCaSerialNums), ""); + soap_out_bool(soap, "sai:IsOemDefault", -1, &(((sai__ProvisioningAuditRecordType*)a)->IsOemDefault), ""); + soap_out_bool(soap, "sai:IsTimeValid", -1, &(((sai__ProvisioningAuditRecordType*)a)->IsTimeValid), ""); + soap_out_sai__IPv4AddressType(soap, "sai:ProvServerIP", -1, &(((sai__ProvisioningAuditRecordType*)a)->ProvServerIP), ""); + soap_out_unsignedInt(soap, "sai:TlsStartTime", -1, &(((sai__ProvisioningAuditRecordType*)a)->TlsStartTime), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__ProvisioningAuditRecordType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__ProvisioningAuditRecordType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__ProvisioningAuditRecordType * SOAP_FMAC4 soap_get_sai__ProvisioningAuditRecordType(struct soap *soap, sai__ProvisioningAuditRecordType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__ProvisioningAuditRecordType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__ProvisioningAuditRecordType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__ProvisioningAuditRecordType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__ProvisioningAuditRecordType * SOAP_FMAC4 soap_in_sai__ProvisioningAuditRecordType(struct soap *soap, const char *tag, sai__ProvisioningAuditRecordType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__ProvisioningAuditRecordType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__ProvisioningAuditRecordType, sizeof(sai__ProvisioningAuditRecordType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__ProvisioningAuditRecordType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__ProvisioningAuditRecordType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_ProvisioningTLSMode1 = 1, soap_flag_SecureDNS1 = 1, soap_flag_HostInitiated1 = 1, soap_flag_ProvServerFQDN1 = 1, soap_flag_SelectedHashType1 = 1, soap_flag_SelectedHashData1 = 1, soap_flag_AdditionalCaSerialNums1 = 1, soap_flag_IsOemDefault1 = 1, soap_flag_IsTimeValid1 = 1, soap_flag_ProvServerIP1 = 1, soap_flag_TlsStartTime1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_ProvisioningTLSMode1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__ProvisioningTLSModeType(soap, "sai:ProvisioningTLSMode", &(((sai__ProvisioningAuditRecordType*)a)->ProvisioningTLSMode), "sai:ProvisioningTLSModeType")) + { soap_flag_ProvisioningTLSMode1--; + continue; + } + if (soap_flag_SecureDNS1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:SecureDNS", &(((sai__ProvisioningAuditRecordType*)a)->SecureDNS), "xsd:boolean")) + { soap_flag_SecureDNS1--; + continue; + } + if (soap_flag_HostInitiated1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:HostInitiated", &(((sai__ProvisioningAuditRecordType*)a)->HostInitiated), "xsd:boolean")) + { soap_flag_HostInitiated1--; + continue; + } + if (soap_flag_ProvServerFQDN1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_PointerTostd__string(soap, "sai:ProvServerFQDN", &(((sai__ProvisioningAuditRecordType*)a)->ProvServerFQDN), "xsd:string")) + { soap_flag_ProvServerFQDN1--; + continue; + } + if (soap_flag_SelectedHashType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__HashTypeType(soap, "sai:SelectedHashType", &(((sai__ProvisioningAuditRecordType*)a)->SelectedHashType), "sai:HashTypeType")) + { soap_flag_SelectedHashType1--; + continue; + } + if (soap_flag_SelectedHashData1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__ProvisioningAuditRecordType*)a)->SelectedHashData).soap_in(soap, "sai:SelectedHashData", "xsd:base64Binary")) + { soap_flag_SelectedHashData1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfxsd__base64Binary(soap, "sai:CaCertSerials", &(((sai__ProvisioningAuditRecordType*)a)->CaCertSerials), "xsd:base64Binary")) + continue; + if (soap_flag_AdditionalCaSerialNums1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTobool(soap, "sai:AdditionalCaSerialNums", &(((sai__ProvisioningAuditRecordType*)a)->AdditionalCaSerialNums), "xsd:boolean")) + { soap_flag_AdditionalCaSerialNums1--; + continue; + } + if (soap_flag_IsOemDefault1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:IsOemDefault", &(((sai__ProvisioningAuditRecordType*)a)->IsOemDefault), "xsd:boolean")) + { soap_flag_IsOemDefault1--; + continue; + } + if (soap_flag_IsTimeValid1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:IsTimeValid", &(((sai__ProvisioningAuditRecordType*)a)->IsTimeValid), "xsd:boolean")) + { soap_flag_IsTimeValid1--; + continue; + } + if (soap_flag_ProvServerIP1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__IPv4AddressType(soap, "sai:ProvServerIP", &(((sai__ProvisioningAuditRecordType*)a)->ProvServerIP), "sai:IPv4AddressType")) + { soap_flag_ProvServerIP1--; + continue; + } + if (soap_flag_TlsStartTime1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:TlsStartTime", &(((sai__ProvisioningAuditRecordType*)a)->TlsStartTime), "xsd:unsignedInt")) + { soap_flag_TlsStartTime1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_ProvisioningTLSMode1 > 0 || soap_flag_SecureDNS1 > 0 || soap_flag_HostInitiated1 > 0 || soap_flag_SelectedHashType1 > 0 || soap_flag_SelectedHashData1 > 0 || soap_flag_IsOemDefault1 > 0 || soap_flag_IsTimeValid1 > 0 || soap_flag_ProvServerIP1 > 0 || soap_flag_TlsStartTime1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__ProvisioningAuditRecordType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__ProvisioningAuditRecordType, 0, sizeof(sai__ProvisioningAuditRecordType), 0, soap_copy_sai__ProvisioningAuditRecordType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__ProvisioningAuditRecordType * SOAP_FMAC6 soap_new_sai__ProvisioningAuditRecordType(struct soap *soap, int n) +{ return soap_instantiate_sai__ProvisioningAuditRecordType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__ProvisioningAuditRecordType(struct soap *soap, sai__ProvisioningAuditRecordType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__ProvisioningAuditRecordType * SOAP_FMAC4 soap_instantiate_sai__ProvisioningAuditRecordType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__ProvisioningAuditRecordType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__ProvisioningAuditRecordType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__ProvisioningAuditRecordType; + if (size) + *size = sizeof(sai__ProvisioningAuditRecordType); + ((sai__ProvisioningAuditRecordType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__ProvisioningAuditRecordType[n]; + if (size) + *size = n * sizeof(sai__ProvisioningAuditRecordType); + for (int i = 0; i < n; i++) + ((sai__ProvisioningAuditRecordType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__ProvisioningAuditRecordType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__ProvisioningAuditRecordType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__ProvisioningAuditRecordType %p -> %p\n", q, p)); + *(sai__ProvisioningAuditRecordType*)p = *(sai__ProvisioningAuditRecordType*)q; +} + +void sai__CertHashEntryType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__CertHashEntryType*)this)->Default, SOAP_TYPE_bool); + soap_embedded(soap, &((sai__CertHashEntryType*)this)->Active, SOAP_TYPE_bool); + soap_embedded(soap, &((sai__CertHashEntryType*)this)->Hash, SOAP_TYPE_xsd__base64Binary); + ((sai__CertHashEntryType*)this)->Hash.soap_serialize(soap); + soap_serialize_sai__FriendlyNameType(soap, &((sai__CertHashEntryType*)this)->FriendlyName); + /* transient soap skipped */ +} + +void sai__CertHashEntryType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_bool(soap, &((sai__CertHashEntryType*)this)->Default); + soap_default_bool(soap, &((sai__CertHashEntryType*)this)->Active); + soap_default_sai__HashTypeType(soap, &((sai__CertHashEntryType*)this)->HashType); + ((sai__CertHashEntryType*)this)->Hash.xsd__base64Binary::soap_default(soap); + soap_default_sai__FriendlyNameType(soap, &((sai__CertHashEntryType*)this)->FriendlyName); + /* transient soap skipped */ +} + +int sai__CertHashEntryType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__CertHashEntryType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__CertHashEntryType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__CertHashEntryType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CertHashEntryType(struct soap *soap, const char *tag, int id, const sai__CertHashEntryType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__CertHashEntryType), type); + soap_out_bool(soap, "sai:Default", -1, &(((sai__CertHashEntryType*)a)->Default), ""); + soap_out_bool(soap, "sai:Active", -1, &(((sai__CertHashEntryType*)a)->Active), ""); + soap_out_sai__HashTypeType(soap, "sai:HashType", -1, &(((sai__CertHashEntryType*)a)->HashType), ""); + (((sai__CertHashEntryType*)a)->Hash).soap_out(soap, "sai:Hash", -1, ""); + soap_out_sai__FriendlyNameType(soap, "sai:FriendlyName", -1, &(((sai__CertHashEntryType*)a)->FriendlyName), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__CertHashEntryType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__CertHashEntryType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__CertHashEntryType * SOAP_FMAC4 soap_get_sai__CertHashEntryType(struct soap *soap, sai__CertHashEntryType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__CertHashEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__CertHashEntryType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__CertHashEntryType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__CertHashEntryType * SOAP_FMAC4 soap_in_sai__CertHashEntryType(struct soap *soap, const char *tag, sai__CertHashEntryType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__CertHashEntryType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__CertHashEntryType, sizeof(sai__CertHashEntryType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__CertHashEntryType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__CertHashEntryType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Default1 = 1, soap_flag_Active1 = 1, soap_flag_HashType1 = 1, soap_flag_Hash1 = 1, soap_flag_FriendlyName1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Default1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:Default", &(((sai__CertHashEntryType*)a)->Default), "xsd:boolean")) + { soap_flag_Default1--; + continue; + } + if (soap_flag_Active1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_bool(soap, "sai:Active", &(((sai__CertHashEntryType*)a)->Active), "xsd:boolean")) + { soap_flag_Active1--; + continue; + } + if (soap_flag_HashType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__HashTypeType(soap, "sai:HashType", &(((sai__CertHashEntryType*)a)->HashType), "sai:HashTypeType")) + { soap_flag_HashType1--; + continue; + } + if (soap_flag_Hash1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__CertHashEntryType*)a)->Hash).soap_in(soap, "sai:Hash", "xsd:base64Binary")) + { soap_flag_Hash1--; + continue; + } + if (soap_flag_FriendlyName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_sai__FriendlyNameType(soap, "sai:FriendlyName", &(((sai__CertHashEntryType*)a)->FriendlyName), "sai:FriendlyNameType")) + { soap_flag_FriendlyName1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Default1 > 0 || soap_flag_Active1 > 0 || soap_flag_HashType1 > 0 || soap_flag_Hash1 > 0 || soap_flag_FriendlyName1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__CertHashEntryType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__CertHashEntryType, 0, sizeof(sai__CertHashEntryType), 0, soap_copy_sai__CertHashEntryType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__CertHashEntryType * SOAP_FMAC6 soap_new_sai__CertHashEntryType(struct soap *soap, int n) +{ return soap_instantiate_sai__CertHashEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__CertHashEntryType(struct soap *soap, sai__CertHashEntryType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__CertHashEntryType * SOAP_FMAC4 soap_instantiate_sai__CertHashEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__CertHashEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__CertHashEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__CertHashEntryType; + if (size) + *size = sizeof(sai__CertHashEntryType); + ((sai__CertHashEntryType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__CertHashEntryType[n]; + if (size) + *size = n * sizeof(sai__CertHashEntryType); + for (int i = 0; i < n; i++) + ((sai__CertHashEntryType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__CertHashEntryType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__CertHashEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__CertHashEntryType %p -> %p\n", q, p)); + *(sai__CertHashEntryType*)p = *(sai__CertHashEntryType*)q; +} + +void sai__PkiCapsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__PkiCapsType*)this)->CrlStoreSize, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__PkiCapsType*)this)->RootCertMaxSize, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__PkiCapsType*)this)->RootCertMaxInstances, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__PkiCapsType*)this)->FqdnSuffixMaxEntries, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__PkiCapsType*)this)->FqdnSuffixMaxEntryLength, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__PkiCapsType*)this)->CertChainMaxSize, SOAP_TYPE_unsignedInt); + soap_serialize_std__vectorTemplateOfunsignedInt(soap, &((sai__PkiCapsType*)this)->SupportedKeyLengths); + /* transient soap skipped */ +} + +void sai__PkiCapsType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((sai__PkiCapsType*)this)->CrlStoreSize); + soap_default_unsignedInt(soap, &((sai__PkiCapsType*)this)->RootCertMaxSize); + soap_default_unsignedInt(soap, &((sai__PkiCapsType*)this)->RootCertMaxInstances); + soap_default_unsignedInt(soap, &((sai__PkiCapsType*)this)->FqdnSuffixMaxEntries); + soap_default_unsignedInt(soap, &((sai__PkiCapsType*)this)->FqdnSuffixMaxEntryLength); + soap_default_unsignedInt(soap, &((sai__PkiCapsType*)this)->CertChainMaxSize); + soap_default_std__vectorTemplateOfunsignedInt(soap, &((sai__PkiCapsType*)this)->SupportedKeyLengths); + /* transient soap skipped */ +} + +int sai__PkiCapsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__PkiCapsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__PkiCapsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__PkiCapsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__PkiCapsType(struct soap *soap, const char *tag, int id, const sai__PkiCapsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__PkiCapsType), type); + soap_out_unsignedInt(soap, "sai:CrlStoreSize", -1, &(((sai__PkiCapsType*)a)->CrlStoreSize), ""); + soap_out_unsignedInt(soap, "sai:RootCertMaxSize", -1, &(((sai__PkiCapsType*)a)->RootCertMaxSize), ""); + soap_out_unsignedInt(soap, "sai:RootCertMaxInstances", -1, &(((sai__PkiCapsType*)a)->RootCertMaxInstances), ""); + soap_out_unsignedInt(soap, "sai:FqdnSuffixMaxEntries", -1, &(((sai__PkiCapsType*)a)->FqdnSuffixMaxEntries), ""); + soap_out_unsignedInt(soap, "sai:FqdnSuffixMaxEntryLength", -1, &(((sai__PkiCapsType*)a)->FqdnSuffixMaxEntryLength), ""); + soap_out_unsignedInt(soap, "sai:CertChainMaxSize", -1, &(((sai__PkiCapsType*)a)->CertChainMaxSize), ""); + soap_out_std__vectorTemplateOfunsignedInt(soap, "sai:SupportedKeyLengths", -1, &(((sai__PkiCapsType*)a)->SupportedKeyLengths), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__PkiCapsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__PkiCapsType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__PkiCapsType * SOAP_FMAC4 soap_get_sai__PkiCapsType(struct soap *soap, sai__PkiCapsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__PkiCapsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__PkiCapsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__PkiCapsType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__PkiCapsType * SOAP_FMAC4 soap_in_sai__PkiCapsType(struct soap *soap, const char *tag, sai__PkiCapsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__PkiCapsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__PkiCapsType, sizeof(sai__PkiCapsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__PkiCapsType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__PkiCapsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CrlStoreSize1 = 1, soap_flag_RootCertMaxSize1 = 1, soap_flag_RootCertMaxInstances1 = 1, soap_flag_FqdnSuffixMaxEntries1 = 1, soap_flag_FqdnSuffixMaxEntryLength1 = 1, soap_flag_CertChainMaxSize1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CrlStoreSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:CrlStoreSize", &(((sai__PkiCapsType*)a)->CrlStoreSize), "xsd:unsignedInt")) + { soap_flag_CrlStoreSize1--; + continue; + } + if (soap_flag_RootCertMaxSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:RootCertMaxSize", &(((sai__PkiCapsType*)a)->RootCertMaxSize), "xsd:unsignedInt")) + { soap_flag_RootCertMaxSize1--; + continue; + } + if (soap_flag_RootCertMaxInstances1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:RootCertMaxInstances", &(((sai__PkiCapsType*)a)->RootCertMaxInstances), "xsd:unsignedInt")) + { soap_flag_RootCertMaxInstances1--; + continue; + } + if (soap_flag_FqdnSuffixMaxEntries1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:FqdnSuffixMaxEntries", &(((sai__PkiCapsType*)a)->FqdnSuffixMaxEntries), "xsd:unsignedInt")) + { soap_flag_FqdnSuffixMaxEntries1--; + continue; + } + if (soap_flag_FqdnSuffixMaxEntryLength1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:FqdnSuffixMaxEntryLength", &(((sai__PkiCapsType*)a)->FqdnSuffixMaxEntryLength), "xsd:unsignedInt")) + { soap_flag_FqdnSuffixMaxEntryLength1--; + continue; + } + if (soap_flag_CertChainMaxSize1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:CertChainMaxSize", &(((sai__PkiCapsType*)a)->CertChainMaxSize), "xsd:unsignedInt")) + { soap_flag_CertChainMaxSize1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfunsignedInt(soap, "sai:SupportedKeyLengths", &(((sai__PkiCapsType*)a)->SupportedKeyLengths), "xsd:unsignedInt")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CrlStoreSize1 > 0 || soap_flag_RootCertMaxSize1 > 0 || soap_flag_RootCertMaxInstances1 > 0 || soap_flag_FqdnSuffixMaxEntries1 > 0 || soap_flag_FqdnSuffixMaxEntryLength1 > 0 || soap_flag_CertChainMaxSize1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__PkiCapsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__PkiCapsType, 0, sizeof(sai__PkiCapsType), 0, soap_copy_sai__PkiCapsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__PkiCapsType * SOAP_FMAC6 soap_new_sai__PkiCapsType(struct soap *soap, int n) +{ return soap_instantiate_sai__PkiCapsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__PkiCapsType(struct soap *soap, sai__PkiCapsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__PkiCapsType * SOAP_FMAC4 soap_instantiate_sai__PkiCapsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__PkiCapsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__PkiCapsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__PkiCapsType; + if (size) + *size = sizeof(sai__PkiCapsType); + ((sai__PkiCapsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__PkiCapsType[n]; + if (size) + *size = n * sizeof(sai__PkiCapsType); + for (int i = 0; i < n; i++) + ((sai__PkiCapsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__PkiCapsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__PkiCapsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__PkiCapsType %p -> %p\n", q, p)); + *(sai__PkiCapsType*)p = *(sai__PkiCapsType*)q; +} + +void sai__CrlType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__CrlType*)this)->CrlUrl, SOAP_TYPE_std__string); + soap_serialize_std__string(soap, &((sai__CrlType*)this)->CrlUrl); + soap_serialize_std__vectorTemplateOfxsd__base64Binary(soap, &((sai__CrlType*)this)->SerialNumber); + /* transient soap skipped */ +} + +void sai__CrlType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__string(soap, &((sai__CrlType*)this)->CrlUrl); + soap_default_std__vectorTemplateOfxsd__base64Binary(soap, &((sai__CrlType*)this)->SerialNumber); + /* transient soap skipped */ +} + +int sai__CrlType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__CrlType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__CrlType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__CrlType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CrlType(struct soap *soap, const char *tag, int id, const sai__CrlType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__CrlType), type); + soap_out_std__string(soap, "sai:CrlUrl", -1, &(((sai__CrlType*)a)->CrlUrl), ""); + soap_out_std__vectorTemplateOfxsd__base64Binary(soap, "sai:SerialNumber", -1, &(((sai__CrlType*)a)->SerialNumber), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__CrlType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__CrlType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__CrlType * SOAP_FMAC4 soap_get_sai__CrlType(struct soap *soap, sai__CrlType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__CrlType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__CrlType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__CrlType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__CrlType * SOAP_FMAC4 soap_in_sai__CrlType(struct soap *soap, const char *tag, sai__CrlType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__CrlType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__CrlType, sizeof(sai__CrlType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__CrlType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__CrlType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_CrlUrl1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_CrlUrl1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_std__string(soap, "sai:CrlUrl", &(((sai__CrlType*)a)->CrlUrl), "xsd:string")) + { soap_flag_CrlUrl1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfxsd__base64Binary(soap, "sai:SerialNumber", &(((sai__CrlType*)a)->SerialNumber), "xsd:base64Binary")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_CrlUrl1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__CrlType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__CrlType, 0, sizeof(sai__CrlType), 0, soap_copy_sai__CrlType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__CrlType * SOAP_FMAC6 soap_new_sai__CrlType(struct soap *soap, int n) +{ return soap_instantiate_sai__CrlType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__CrlType(struct soap *soap, sai__CrlType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__CrlType * SOAP_FMAC4 soap_instantiate_sai__CrlType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__CrlType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__CrlType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__CrlType; + if (size) + *size = sizeof(sai__CrlType); + ((sai__CrlType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__CrlType[n]; + if (size) + *size = n * sizeof(sai__CrlType); + for (int i = 0; i < n; i++) + ((sai__CrlType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__CrlType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__CrlType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__CrlType %p -> %p\n", q, p)); + *(sai__CrlType*)p = *(sai__CrlType*)q; +} + +void sai__CertificateType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__CertificateType*)this)->X509cert, SOAP_TYPE_xsd__base64Binary); + ((sai__CertificateType*)this)->X509cert.soap_serialize(soap); + /* transient soap skipped */ +} + +void sai__CertificateType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((sai__CertificateType*)this)->X509cert.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int sai__CertificateType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__CertificateType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__CertificateType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__CertificateType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CertificateType(struct soap *soap, const char *tag, int id, const sai__CertificateType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__CertificateType), type); + (((sai__CertificateType*)a)->X509cert).soap_out(soap, "sai:X509cert", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__CertificateType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__CertificateType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__CertificateType * SOAP_FMAC4 soap_get_sai__CertificateType(struct soap *soap, sai__CertificateType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__CertificateType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__CertificateType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__CertificateType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__CertificateType * SOAP_FMAC4 soap_in_sai__CertificateType(struct soap *soap, const char *tag, sai__CertificateType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__CertificateType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__CertificateType, sizeof(sai__CertificateType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__CertificateType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__CertificateType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_X509cert1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_X509cert1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__CertificateType*)a)->X509cert).soap_in(soap, "sai:X509cert", "xsd:base64Binary")) + { soap_flag_X509cert1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_X509cert1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__CertificateType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__CertificateType, 0, sizeof(sai__CertificateType), 0, soap_copy_sai__CertificateType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__CertificateType * SOAP_FMAC6 soap_new_sai__CertificateType(struct soap *soap, int n) +{ return soap_instantiate_sai__CertificateType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__CertificateType(struct soap *soap, sai__CertificateType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__CertificateType * SOAP_FMAC4 soap_instantiate_sai__CertificateType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__CertificateType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__CertificateType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__CertificateType; + if (size) + *size = sizeof(sai__CertificateType); + ((sai__CertificateType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__CertificateType[n]; + if (size) + *size = n * sizeof(sai__CertificateType); + for (int i = 0; i < n; i++) + ((sai__CertificateType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__CertificateType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__CertificateType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__CertificateType %p -> %p\n", q, p)); + *(sai__CertificateType*)p = *(sai__CertificateType*)q; +} + +void sai__TlsOptionsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + /* transient soap skipped */ +} + +void sai__TlsOptionsType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__InterfaceType(soap, &((sai__TlsOptionsType*)this)->Interface); + soap_default_sai__TlsAthenticationType(soap, &((sai__TlsOptionsType*)this)->TlsAuthentication); + /* transient soap skipped */ +} + +int sai__TlsOptionsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__TlsOptionsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__TlsOptionsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__TlsOptionsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__TlsOptionsType(struct soap *soap, const char *tag, int id, const sai__TlsOptionsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__TlsOptionsType), type); + soap_out_sai__InterfaceType(soap, "sai:Interface", -1, &(((sai__TlsOptionsType*)a)->Interface), ""); + soap_out_sai__TlsAthenticationType(soap, "sai:TlsAuthentication", -1, &(((sai__TlsOptionsType*)a)->TlsAuthentication), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__TlsOptionsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__TlsOptionsType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__TlsOptionsType * SOAP_FMAC4 soap_get_sai__TlsOptionsType(struct soap *soap, sai__TlsOptionsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__TlsOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__TlsOptionsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__TlsOptionsType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__TlsOptionsType * SOAP_FMAC4 soap_in_sai__TlsOptionsType(struct soap *soap, const char *tag, sai__TlsOptionsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__TlsOptionsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__TlsOptionsType, sizeof(sai__TlsOptionsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__TlsOptionsType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__TlsOptionsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Interface1 = 1, soap_flag_TlsAuthentication1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Interface1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__InterfaceType(soap, "sai:Interface", &(((sai__TlsOptionsType*)a)->Interface), "sai:InterfaceType")) + { soap_flag_Interface1--; + continue; + } + if (soap_flag_TlsAuthentication1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__TlsAthenticationType(soap, "sai:TlsAuthentication", &(((sai__TlsOptionsType*)a)->TlsAuthentication), "sai:TlsAthenticationType")) + { soap_flag_TlsAuthentication1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Interface1 > 0 || soap_flag_TlsAuthentication1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__TlsOptionsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__TlsOptionsType, 0, sizeof(sai__TlsOptionsType), 0, soap_copy_sai__TlsOptionsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__TlsOptionsType * SOAP_FMAC6 soap_new_sai__TlsOptionsType(struct soap *soap, int n) +{ return soap_instantiate_sai__TlsOptionsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__TlsOptionsType(struct soap *soap, sai__TlsOptionsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__TlsOptionsType * SOAP_FMAC4 soap_instantiate_sai__TlsOptionsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__TlsOptionsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__TlsOptionsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__TlsOptionsType; + if (size) + *size = sizeof(sai__TlsOptionsType); + ((sai__TlsOptionsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__TlsOptionsType[n]; + if (size) + *size = n * sizeof(sai__TlsOptionsType); + for (int i = 0; i < n; i++) + ((sai__TlsOptionsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__TlsOptionsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__TlsOptionsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__TlsOptionsType %p -> %p\n", q, p)); + *(sai__TlsOptionsType*)p = *(sai__TlsOptionsType*)q; +} + +void sai__KerberosOptionsType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__sai__KerberosRealmName(soap, &((sai__KerberosOptionsType*)this)->KerberosRealmName); + soap_serialize_std__vectorTemplateOfPointerTosai__KerberosSpnType(soap, &((sai__KerberosOptionsType*)this)->KerberosSpn); + soap_embedded(soap, &((sai__KerberosOptionsType*)this)->KerberosKeyVersion, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__KerberosOptionsType*)this)->KerberosMasterKey, SOAP_TYPE_xsd__base64Binary); + ((sai__KerberosOptionsType*)this)->KerberosMasterKey.soap_serialize(soap); + soap_embedded(soap, &((sai__KerberosOptionsType*)this)->KerberosMaximumClockTolerance, SOAP_TYPE_unsignedInt); + /* transient soap skipped */ +} + +void sai__KerberosOptionsType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default__sai__KerberosRealmName(soap, &((sai__KerberosOptionsType*)this)->KerberosRealmName); + soap_default_std__vectorTemplateOfPointerTosai__KerberosSpnType(soap, &((sai__KerberosOptionsType*)this)->KerberosSpn); + soap_default_unsignedInt(soap, &((sai__KerberosOptionsType*)this)->KerberosKeyVersion); + soap_default_sai__KerberosEncryptionType(soap, &((sai__KerberosOptionsType*)this)->KerberosEncryption); + ((sai__KerberosOptionsType*)this)->KerberosMasterKey.xsd__base64Binary::soap_default(soap); + soap_default_unsignedInt(soap, &((sai__KerberosOptionsType*)this)->KerberosMaximumClockTolerance); + /* transient soap skipped */ +} + +int sai__KerberosOptionsType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__KerberosOptionsType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__KerberosOptionsType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__KerberosOptionsType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__KerberosOptionsType(struct soap *soap, const char *tag, int id, const sai__KerberosOptionsType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__KerberosOptionsType), type); + soap_out__sai__KerberosRealmName(soap, "sai:KerberosRealmName", -1, &(((sai__KerberosOptionsType*)a)->KerberosRealmName), ""); + soap_out_std__vectorTemplateOfPointerTosai__KerberosSpnType(soap, "sai:KerberosSpn", -1, &(((sai__KerberosOptionsType*)a)->KerberosSpn), ""); + soap_out_unsignedInt(soap, "sai:KerberosKeyVersion", -1, &(((sai__KerberosOptionsType*)a)->KerberosKeyVersion), ""); + soap_out_sai__KerberosEncryptionType(soap, "sai:KerberosEncryption", -1, &(((sai__KerberosOptionsType*)a)->KerberosEncryption), ""); + (((sai__KerberosOptionsType*)a)->KerberosMasterKey).soap_out(soap, "sai:KerberosMasterKey", -1, ""); + soap_out_unsignedInt(soap, "sai:KerberosMaximumClockTolerance", -1, &(((sai__KerberosOptionsType*)a)->KerberosMaximumClockTolerance), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__KerberosOptionsType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__KerberosOptionsType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__KerberosOptionsType * SOAP_FMAC4 soap_get_sai__KerberosOptionsType(struct soap *soap, sai__KerberosOptionsType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__KerberosOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__KerberosOptionsType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__KerberosOptionsType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__KerberosOptionsType * SOAP_FMAC4 soap_in_sai__KerberosOptionsType(struct soap *soap, const char *tag, sai__KerberosOptionsType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__KerberosOptionsType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__KerberosOptionsType, sizeof(sai__KerberosOptionsType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__KerberosOptionsType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__KerberosOptionsType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_KerberosRealmName1 = 1, soap_flag_KerberosKeyVersion1 = 1, soap_flag_KerberosEncryption1 = 1, soap_flag_KerberosMasterKey1 = 1, soap_flag_KerberosMaximumClockTolerance1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_KerberosRealmName1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in__sai__KerberosRealmName(soap, "sai:KerberosRealmName", &(((sai__KerberosOptionsType*)a)->KerberosRealmName), "")) + { soap_flag_KerberosRealmName1--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfPointerTosai__KerberosSpnType(soap, "sai:KerberosSpn", &(((sai__KerberosOptionsType*)a)->KerberosSpn), "sai:KerberosSpnType")) + continue; + if (soap_flag_KerberosKeyVersion1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:KerberosKeyVersion", &(((sai__KerberosOptionsType*)a)->KerberosKeyVersion), "xsd:unsignedInt")) + { soap_flag_KerberosKeyVersion1--; + continue; + } + if (soap_flag_KerberosEncryption1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__KerberosEncryptionType(soap, "sai:KerberosEncryption", &(((sai__KerberosOptionsType*)a)->KerberosEncryption), "sai:KerberosEncryptionType")) + { soap_flag_KerberosEncryption1--; + continue; + } + if (soap_flag_KerberosMasterKey1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__KerberosOptionsType*)a)->KerberosMasterKey).soap_in(soap, "sai:KerberosMasterKey", "xsd:base64Binary")) + { soap_flag_KerberosMasterKey1--; + continue; + } + if (soap_flag_KerberosMaximumClockTolerance1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:KerberosMaximumClockTolerance", &(((sai__KerberosOptionsType*)a)->KerberosMaximumClockTolerance), "xsd:unsignedInt")) + { soap_flag_KerberosMaximumClockTolerance1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_KerberosRealmName1 > 0 || ((sai__KerberosOptionsType*)a)->KerberosSpn.size() > 4 || soap_flag_KerberosKeyVersion1 > 0 || soap_flag_KerberosEncryption1 > 0 || soap_flag_KerberosMasterKey1 > 0 || soap_flag_KerberosMaximumClockTolerance1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__KerberosOptionsType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__KerberosOptionsType, 0, sizeof(sai__KerberosOptionsType), 0, soap_copy_sai__KerberosOptionsType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__KerberosOptionsType * SOAP_FMAC6 soap_new_sai__KerberosOptionsType(struct soap *soap, int n) +{ return soap_instantiate_sai__KerberosOptionsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__KerberosOptionsType(struct soap *soap, sai__KerberosOptionsType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__KerberosOptionsType * SOAP_FMAC4 soap_instantiate_sai__KerberosOptionsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__KerberosOptionsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__KerberosOptionsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__KerberosOptionsType; + if (size) + *size = sizeof(sai__KerberosOptionsType); + ((sai__KerberosOptionsType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__KerberosOptionsType[n]; + if (size) + *size = n * sizeof(sai__KerberosOptionsType); + for (int i = 0; i < n; i++) + ((sai__KerberosOptionsType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__KerberosOptionsType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__KerberosOptionsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__KerberosOptionsType %p -> %p\n", q, p)); + *(sai__KerberosOptionsType*)p = *(sai__KerberosOptionsType*)q; +} + +void sai__KerberosSpnType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__sai__SpnString(soap, &((sai__KerberosSpnType*)this)->SpnString); + /* transient soap skipped */ +} + +void sai__KerberosSpnType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__KerberosSpnProtocolType(soap, &((sai__KerberosSpnType*)this)->SpnProtocolIndex); + soap_default__sai__SpnString(soap, &((sai__KerberosSpnType*)this)->SpnString); + /* transient soap skipped */ +} + +int sai__KerberosSpnType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__KerberosSpnType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__KerberosSpnType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__KerberosSpnType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__KerberosSpnType(struct soap *soap, const char *tag, int id, const sai__KerberosSpnType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__KerberosSpnType), type); + soap_out_sai__KerberosSpnProtocolType(soap, "sai:SpnProtocolIndex", -1, &(((sai__KerberosSpnType*)a)->SpnProtocolIndex), ""); + soap_out__sai__SpnString(soap, "sai:SpnString", -1, &(((sai__KerberosSpnType*)a)->SpnString), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__KerberosSpnType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__KerberosSpnType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__KerberosSpnType * SOAP_FMAC4 soap_get_sai__KerberosSpnType(struct soap *soap, sai__KerberosSpnType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__KerberosSpnType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__KerberosSpnType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__KerberosSpnType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__KerberosSpnType * SOAP_FMAC4 soap_in_sai__KerberosSpnType(struct soap *soap, const char *tag, sai__KerberosSpnType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__KerberosSpnType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__KerberosSpnType, sizeof(sai__KerberosSpnType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__KerberosSpnType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__KerberosSpnType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_SpnProtocolIndex1 = 1, soap_flag_SpnString1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_SpnProtocolIndex1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__KerberosSpnProtocolType(soap, "sai:SpnProtocolIndex", &(((sai__KerberosSpnType*)a)->SpnProtocolIndex), "sai:KerberosSpnProtocolType")) + { soap_flag_SpnProtocolIndex1--; + continue; + } + if (soap_flag_SpnString1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in__sai__SpnString(soap, "sai:SpnString", &(((sai__KerberosSpnType*)a)->SpnString), "")) + { soap_flag_SpnString1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_SpnProtocolIndex1 > 0 || soap_flag_SpnString1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__KerberosSpnType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__KerberosSpnType, 0, sizeof(sai__KerberosSpnType), 0, soap_copy_sai__KerberosSpnType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__KerberosSpnType * SOAP_FMAC6 soap_new_sai__KerberosSpnType(struct soap *soap, int n) +{ return soap_instantiate_sai__KerberosSpnType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__KerberosSpnType(struct soap *soap, sai__KerberosSpnType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__KerberosSpnType * SOAP_FMAC4 soap_instantiate_sai__KerberosSpnType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__KerberosSpnType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__KerberosSpnType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__KerberosSpnType; + if (size) + *size = sizeof(sai__KerberosSpnType); + ((sai__KerberosSpnType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__KerberosSpnType[n]; + if (size) + *size = n * sizeof(sai__KerberosSpnType); + for (int i = 0; i < n; i++) + ((sai__KerberosSpnType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__KerberosSpnType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__KerberosSpnType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__KerberosSpnType %p -> %p\n", q, p)); + *(sai__KerberosSpnType*)p = *(sai__KerberosSpnType*)q; +} + +void sai__AdminAclEntryExType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_sai__AclStringType(soap, &((sai__AdminAclEntryExType*)this)->Username); + soap_embedded(soap, &((sai__AdminAclEntryExType*)this)->DigestPassword, SOAP_TYPE_xsd__base64Binary); + ((sai__AdminAclEntryExType*)this)->DigestPassword.soap_serialize(soap); + /* transient soap skipped */ +} + +void sai__AdminAclEntryExType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__AclStringType(soap, &((sai__AdminAclEntryExType*)this)->Username); + ((sai__AdminAclEntryExType*)this)->DigestPassword.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int sai__AdminAclEntryExType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__AdminAclEntryExType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__AdminAclEntryExType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__AdminAclEntryExType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AdminAclEntryExType(struct soap *soap, const char *tag, int id, const sai__AdminAclEntryExType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__AdminAclEntryExType), type); + soap_out_sai__AclStringType(soap, "sai:Username", -1, &(((sai__AdminAclEntryExType*)a)->Username), ""); + (((sai__AdminAclEntryExType*)a)->DigestPassword).soap_out(soap, "sai:DigestPassword", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__AdminAclEntryExType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__AdminAclEntryExType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__AdminAclEntryExType * SOAP_FMAC4 soap_get_sai__AdminAclEntryExType(struct soap *soap, sai__AdminAclEntryExType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__AdminAclEntryExType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__AdminAclEntryExType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__AdminAclEntryExType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__AdminAclEntryExType * SOAP_FMAC4 soap_in_sai__AdminAclEntryExType(struct soap *soap, const char *tag, sai__AdminAclEntryExType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__AdminAclEntryExType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__AdminAclEntryExType, sizeof(sai__AdminAclEntryExType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__AdminAclEntryExType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__AdminAclEntryExType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Username1 = 1, soap_flag_DigestPassword1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Username1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_sai__AclStringType(soap, "sai:Username", &(((sai__AdminAclEntryExType*)a)->Username), "sai:AclStringType")) + { soap_flag_Username1--; + continue; + } + if (soap_flag_DigestPassword1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__AdminAclEntryExType*)a)->DigestPassword).soap_in(soap, "sai:DigestPassword", "xsd:base64Binary")) + { soap_flag_DigestPassword1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Username1 > 0 || soap_flag_DigestPassword1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__AdminAclEntryExType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__AdminAclEntryExType, 0, sizeof(sai__AdminAclEntryExType), 0, soap_copy_sai__AdminAclEntryExType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__AdminAclEntryExType * SOAP_FMAC6 soap_new_sai__AdminAclEntryExType(struct soap *soap, int n) +{ return soap_instantiate_sai__AdminAclEntryExType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AdminAclEntryExType(struct soap *soap, sai__AdminAclEntryExType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__AdminAclEntryExType * SOAP_FMAC4 soap_instantiate_sai__AdminAclEntryExType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__AdminAclEntryExType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__AdminAclEntryExType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__AdminAclEntryExType; + if (size) + *size = sizeof(sai__AdminAclEntryExType); + ((sai__AdminAclEntryExType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__AdminAclEntryExType[n]; + if (size) + *size = n * sizeof(sai__AdminAclEntryExType); + for (int i = 0; i < n; i++) + ((sai__AdminAclEntryExType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__AdminAclEntryExType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AdminAclEntryExType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__AdminAclEntryExType %p -> %p\n", q, p)); + *(sai__AdminAclEntryExType*)p = *(sai__AdminAclEntryExType*)q; +} + +void sai__UserAclEntryExType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_PointerTosai__UserAclRealmListType(soap, &((sai__UserAclEntryExType*)this)->Realms); + soap_serialize__sai__union_UserAclEntryExType(soap, ((sai__UserAclEntryExType*)this)->__union_UserAclEntryExType, &((sai__UserAclEntryExType*)this)->union_UserAclEntryExType); + /* transient soap skipped */ +} + +void sai__UserAclEntryExType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__AccessPermissionType(soap, &((sai__UserAclEntryExType*)this)->AccessPermission); + ((sai__UserAclEntryExType*)this)->Realms = NULL; + ((sai__UserAclEntryExType*)this)->__union_UserAclEntryExType = 0; + /* transient soap skipped */ +} + +int sai__UserAclEntryExType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__UserAclEntryExType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__UserAclEntryExType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__UserAclEntryExType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclEntryExType(struct soap *soap, const char *tag, int id, const sai__UserAclEntryExType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__UserAclEntryExType), type); + soap_out_sai__AccessPermissionType(soap, "sai:AccessPermission", -1, &(((sai__UserAclEntryExType*)a)->AccessPermission), ""); + soap_out_PointerTosai__UserAclRealmListType(soap, "sai:Realms", -1, &(((sai__UserAclEntryExType*)a)->Realms), ""); + soap_out__sai__union_UserAclEntryExType(soap, ((sai__UserAclEntryExType*)a)->__union_UserAclEntryExType, &((sai__UserAclEntryExType*)a)->union_UserAclEntryExType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__UserAclEntryExType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__UserAclEntryExType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__UserAclEntryExType * SOAP_FMAC4 soap_get_sai__UserAclEntryExType(struct soap *soap, sai__UserAclEntryExType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__UserAclEntryExType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__UserAclEntryExType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__UserAclEntryExType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__UserAclEntryExType * SOAP_FMAC4 soap_in_sai__UserAclEntryExType(struct soap *soap, const char *tag, sai__UserAclEntryExType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__UserAclEntryExType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__UserAclEntryExType, sizeof(sai__UserAclEntryExType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__UserAclEntryExType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__UserAclEntryExType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_AccessPermission1 = 1, soap_flag_Realms1 = 1, soap_flag_union_UserAclEntryExType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_AccessPermission1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__AccessPermissionType(soap, "sai:AccessPermission", &(((sai__UserAclEntryExType*)a)->AccessPermission), "sai:AccessPermissionType")) + { soap_flag_AccessPermission1--; + continue; + } + if (soap_flag_Realms1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UserAclRealmListType(soap, "sai:Realms", &(((sai__UserAclEntryExType*)a)->Realms), "sai:UserAclRealmListType")) + { soap_flag_Realms1--; + continue; + } + if (soap_flag_union_UserAclEntryExType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__sai__union_UserAclEntryExType(soap, &((sai__UserAclEntryExType*)a)->__union_UserAclEntryExType, &((sai__UserAclEntryExType*)a)->union_UserAclEntryExType)) + { soap_flag_union_UserAclEntryExType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_AccessPermission1 > 0 || soap_flag_Realms1 > 0 || soap_flag_union_UserAclEntryExType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__UserAclEntryExType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__UserAclEntryExType, 0, sizeof(sai__UserAclEntryExType), 0, soap_copy_sai__UserAclEntryExType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__UserAclEntryExType * SOAP_FMAC6 soap_new_sai__UserAclEntryExType(struct soap *soap, int n) +{ return soap_instantiate_sai__UserAclEntryExType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserAclEntryExType(struct soap *soap, sai__UserAclEntryExType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__UserAclEntryExType * SOAP_FMAC4 soap_instantiate_sai__UserAclEntryExType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__UserAclEntryExType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__UserAclEntryExType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__UserAclEntryExType; + if (size) + *size = sizeof(sai__UserAclEntryExType); + ((sai__UserAclEntryExType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__UserAclEntryExType[n]; + if (size) + *size = n * sizeof(sai__UserAclEntryExType); + for (int i = 0; i < n; i++) + ((sai__UserAclEntryExType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__UserAclEntryExType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserAclEntryExType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__UserAclEntryExType %p -> %p\n", q, p)); + *(sai__UserAclEntryExType*)p = *(sai__UserAclEntryExType*)q; +} + +void sai__UserEntryKerberosType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__UserEntryKerberosType*)this)->Sid, SOAP_TYPE_xsd__base64Binary); + ((sai__UserEntryKerberosType*)this)->Sid.soap_serialize(soap); + /* transient soap skipped */ +} + +void sai__UserEntryKerberosType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((sai__UserEntryKerberosType*)this)->Sid.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int sai__UserEntryKerberosType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__UserEntryKerberosType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__UserEntryKerberosType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__UserEntryKerberosType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserEntryKerberosType(struct soap *soap, const char *tag, int id, const sai__UserEntryKerberosType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__UserEntryKerberosType), type); + (((sai__UserEntryKerberosType*)a)->Sid).soap_out(soap, "sai:Sid", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__UserEntryKerberosType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__UserEntryKerberosType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__UserEntryKerberosType * SOAP_FMAC4 soap_get_sai__UserEntryKerberosType(struct soap *soap, sai__UserEntryKerberosType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__UserEntryKerberosType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__UserEntryKerberosType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__UserEntryKerberosType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__UserEntryKerberosType * SOAP_FMAC4 soap_in_sai__UserEntryKerberosType(struct soap *soap, const char *tag, sai__UserEntryKerberosType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__UserEntryKerberosType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__UserEntryKerberosType, sizeof(sai__UserEntryKerberosType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__UserEntryKerberosType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__UserEntryKerberosType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Sid1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Sid1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__UserEntryKerberosType*)a)->Sid).soap_in(soap, "sai:Sid", "xsd:base64Binary")) + { soap_flag_Sid1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Sid1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__UserEntryKerberosType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__UserEntryKerberosType, 0, sizeof(sai__UserEntryKerberosType), 0, soap_copy_sai__UserEntryKerberosType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__UserEntryKerberosType * SOAP_FMAC6 soap_new_sai__UserEntryKerberosType(struct soap *soap, int n) +{ return soap_instantiate_sai__UserEntryKerberosType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserEntryKerberosType(struct soap *soap, sai__UserEntryKerberosType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__UserEntryKerberosType * SOAP_FMAC4 soap_instantiate_sai__UserEntryKerberosType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__UserEntryKerberosType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__UserEntryKerberosType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__UserEntryKerberosType; + if (size) + *size = sizeof(sai__UserEntryKerberosType); + ((sai__UserEntryKerberosType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__UserEntryKerberosType[n]; + if (size) + *size = n * sizeof(sai__UserEntryKerberosType); + for (int i = 0; i < n; i++) + ((sai__UserEntryKerberosType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__UserEntryKerberosType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserEntryKerberosType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__UserEntryKerberosType %p -> %p\n", q, p)); + *(sai__UserEntryKerberosType*)p = *(sai__UserEntryKerberosType*)q; +} + +void sai__UserEntryDigestType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_sai__AclStringType(soap, &((sai__UserEntryDigestType*)this)->Username); + soap_embedded(soap, &((sai__UserEntryDigestType*)this)->DigestPassword, SOAP_TYPE_xsd__base64Binary); + ((sai__UserEntryDigestType*)this)->DigestPassword.soap_serialize(soap); + /* transient soap skipped */ +} + +void sai__UserEntryDigestType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__AclStringType(soap, &((sai__UserEntryDigestType*)this)->Username); + ((sai__UserEntryDigestType*)this)->DigestPassword.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int sai__UserEntryDigestType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__UserEntryDigestType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__UserEntryDigestType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__UserEntryDigestType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserEntryDigestType(struct soap *soap, const char *tag, int id, const sai__UserEntryDigestType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__UserEntryDigestType), type); + soap_out_sai__AclStringType(soap, "sai:Username", -1, &(((sai__UserEntryDigestType*)a)->Username), ""); + (((sai__UserEntryDigestType*)a)->DigestPassword).soap_out(soap, "sai:DigestPassword", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__UserEntryDigestType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__UserEntryDigestType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__UserEntryDigestType * SOAP_FMAC4 soap_get_sai__UserEntryDigestType(struct soap *soap, sai__UserEntryDigestType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__UserEntryDigestType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__UserEntryDigestType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__UserEntryDigestType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__UserEntryDigestType * SOAP_FMAC4 soap_in_sai__UserEntryDigestType(struct soap *soap, const char *tag, sai__UserEntryDigestType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__UserEntryDigestType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__UserEntryDigestType, sizeof(sai__UserEntryDigestType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__UserEntryDigestType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__UserEntryDigestType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Username1 = 1, soap_flag_DigestPassword1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Username1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_sai__AclStringType(soap, "sai:Username", &(((sai__UserEntryDigestType*)a)->Username), "sai:AclStringType")) + { soap_flag_Username1--; + continue; + } + if (soap_flag_DigestPassword1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__UserEntryDigestType*)a)->DigestPassword).soap_in(soap, "sai:DigestPassword", "xsd:base64Binary")) + { soap_flag_DigestPassword1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Username1 > 0 || soap_flag_DigestPassword1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__UserEntryDigestType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__UserEntryDigestType, 0, sizeof(sai__UserEntryDigestType), 0, soap_copy_sai__UserEntryDigestType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__UserEntryDigestType * SOAP_FMAC6 soap_new_sai__UserEntryDigestType(struct soap *soap, int n) +{ return soap_instantiate_sai__UserEntryDigestType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserEntryDigestType(struct soap *soap, sai__UserEntryDigestType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__UserEntryDigestType * SOAP_FMAC4 soap_instantiate_sai__UserEntryDigestType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__UserEntryDigestType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__UserEntryDigestType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__UserEntryDigestType; + if (size) + *size = sizeof(sai__UserEntryDigestType); + ((sai__UserEntryDigestType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__UserEntryDigestType[n]; + if (size) + *size = n * sizeof(sai__UserEntryDigestType); + for (int i = 0; i < n; i++) + ((sai__UserEntryDigestType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__UserEntryDigestType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserEntryDigestType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__UserEntryDigestType %p -> %p\n", q, p)); + *(sai__UserEntryDigestType*)p = *(sai__UserEntryDigestType*)q; +} + +void sai__AmtVersion::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__AmtVersion*)this)->major, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((sai__AmtVersion*)this)->minor, SOAP_TYPE_unsignedByte); + soap_embedded(soap, &((sai__AmtVersion*)this)->micro, SOAP_TYPE_unsignedShort); + /* transient soap skipped */ +} + +void sai__AmtVersion::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedByte(soap, &((sai__AmtVersion*)this)->major); + soap_default_unsignedByte(soap, &((sai__AmtVersion*)this)->minor); + soap_default_unsignedShort(soap, &((sai__AmtVersion*)this)->micro); + /* transient soap skipped */ +} + +int sai__AmtVersion::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__AmtVersion); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__AmtVersion::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__AmtVersion(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AmtVersion(struct soap *soap, const char *tag, int id, const sai__AmtVersion *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__AmtVersion), type); + soap_out_unsignedByte(soap, "sai:major", -1, &(((sai__AmtVersion*)a)->major), ""); + soap_out_unsignedByte(soap, "sai:minor", -1, &(((sai__AmtVersion*)a)->minor), ""); + soap_out_unsignedShort(soap, "sai:micro", -1, &(((sai__AmtVersion*)a)->micro), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__AmtVersion::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__AmtVersion(soap, this, tag, type); +} + +SOAP_FMAC3 sai__AmtVersion * SOAP_FMAC4 soap_get_sai__AmtVersion(struct soap *soap, sai__AmtVersion *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__AmtVersion(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__AmtVersion::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__AmtVersion(soap, tag, this, type); +} + +SOAP_FMAC3 sai__AmtVersion * SOAP_FMAC4 soap_in_sai__AmtVersion(struct soap *soap, const char *tag, sai__AmtVersion *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__AmtVersion *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__AmtVersion, sizeof(sai__AmtVersion), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__AmtVersion) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__AmtVersion *)a->soap_in(soap, tag, type); + } + } + short soap_flag_major1 = 1, soap_flag_minor1 = 1, soap_flag_micro1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_major1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "sai:major", &(((sai__AmtVersion*)a)->major), "xsd:unsignedByte")) + { soap_flag_major1--; + continue; + } + if (soap_flag_minor1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedByte(soap, "sai:minor", &(((sai__AmtVersion*)a)->minor), "xsd:unsignedByte")) + { soap_flag_minor1--; + continue; + } + if (soap_flag_micro1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedShort(soap, "sai:micro", &(((sai__AmtVersion*)a)->micro), "xsd:unsignedShort")) + { soap_flag_micro1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_major1 > 0 || soap_flag_minor1 > 0 || soap_flag_micro1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__AmtVersion *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__AmtVersion, 0, sizeof(sai__AmtVersion), 0, soap_copy_sai__AmtVersion); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__AmtVersion * SOAP_FMAC6 soap_new_sai__AmtVersion(struct soap *soap, int n) +{ return soap_instantiate_sai__AmtVersion(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AmtVersion(struct soap *soap, sai__AmtVersion *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__AmtVersion * SOAP_FMAC4 soap_instantiate_sai__AmtVersion(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__AmtVersion(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__AmtVersion, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__AmtVersion; + if (size) + *size = sizeof(sai__AmtVersion); + ((sai__AmtVersion*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__AmtVersion[n]; + if (size) + *size = n * sizeof(sai__AmtVersion); + for (int i = 0; i < n; i++) + ((sai__AmtVersion*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__AmtVersion*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AmtVersion(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__AmtVersion %p -> %p\n", q, p)); + *(sai__AmtVersion*)p = *(sai__AmtVersion*)q; +} + +void sai__UpdateCoreUrlKeyType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__UpdateCoreUrlKeyType*)this)->KeyLength, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__UpdateCoreUrlKeyType*)this)->KeyAlgorithm, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__UpdateCoreUrlKeyType*)this)->KeyData, SOAP_TYPE_xsd__base64Binary); + ((sai__UpdateCoreUrlKeyType*)this)->KeyData.soap_serialize(soap); + /* transient soap skipped */ +} + +void sai__UpdateCoreUrlKeyType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_unsignedInt(soap, &((sai__UpdateCoreUrlKeyType*)this)->KeyLength); + soap_default_unsignedInt(soap, &((sai__UpdateCoreUrlKeyType*)this)->KeyAlgorithm); + ((sai__UpdateCoreUrlKeyType*)this)->KeyData.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int sai__UpdateCoreUrlKeyType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__UpdateCoreUrlKeyType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__UpdateCoreUrlKeyType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__UpdateCoreUrlKeyType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UpdateCoreUrlKeyType(struct soap *soap, const char *tag, int id, const sai__UpdateCoreUrlKeyType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__UpdateCoreUrlKeyType), type); + soap_out_unsignedInt(soap, "sai:KeyLength", -1, &(((sai__UpdateCoreUrlKeyType*)a)->KeyLength), ""); + soap_out_unsignedInt(soap, "sai:KeyAlgorithm", -1, &(((sai__UpdateCoreUrlKeyType*)a)->KeyAlgorithm), ""); + (((sai__UpdateCoreUrlKeyType*)a)->KeyData).soap_out(soap, "sai:KeyData", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__UpdateCoreUrlKeyType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__UpdateCoreUrlKeyType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__UpdateCoreUrlKeyType * SOAP_FMAC4 soap_get_sai__UpdateCoreUrlKeyType(struct soap *soap, sai__UpdateCoreUrlKeyType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__UpdateCoreUrlKeyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__UpdateCoreUrlKeyType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__UpdateCoreUrlKeyType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__UpdateCoreUrlKeyType * SOAP_FMAC4 soap_in_sai__UpdateCoreUrlKeyType(struct soap *soap, const char *tag, sai__UpdateCoreUrlKeyType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__UpdateCoreUrlKeyType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__UpdateCoreUrlKeyType, sizeof(sai__UpdateCoreUrlKeyType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__UpdateCoreUrlKeyType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__UpdateCoreUrlKeyType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_KeyLength1 = 1, soap_flag_KeyAlgorithm1 = 1, soap_flag_KeyData1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_KeyLength1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:KeyLength", &(((sai__UpdateCoreUrlKeyType*)a)->KeyLength), "xsd:unsignedInt")) + { soap_flag_KeyLength1--; + continue; + } + if (soap_flag_KeyAlgorithm1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:KeyAlgorithm", &(((sai__UpdateCoreUrlKeyType*)a)->KeyAlgorithm), "xsd:unsignedInt")) + { soap_flag_KeyAlgorithm1--; + continue; + } + if (soap_flag_KeyData1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__UpdateCoreUrlKeyType*)a)->KeyData).soap_in(soap, "sai:KeyData", "xsd:base64Binary")) + { soap_flag_KeyData1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_KeyLength1 > 0 || soap_flag_KeyAlgorithm1 > 0 || soap_flag_KeyData1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__UpdateCoreUrlKeyType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__UpdateCoreUrlKeyType, 0, sizeof(sai__UpdateCoreUrlKeyType), 0, soap_copy_sai__UpdateCoreUrlKeyType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__UpdateCoreUrlKeyType * SOAP_FMAC6 soap_new_sai__UpdateCoreUrlKeyType(struct soap *soap, int n) +{ return soap_instantiate_sai__UpdateCoreUrlKeyType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UpdateCoreUrlKeyType(struct soap *soap, sai__UpdateCoreUrlKeyType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__UpdateCoreUrlKeyType * SOAP_FMAC4 soap_instantiate_sai__UpdateCoreUrlKeyType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__UpdateCoreUrlKeyType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__UpdateCoreUrlKeyType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__UpdateCoreUrlKeyType; + if (size) + *size = sizeof(sai__UpdateCoreUrlKeyType); + ((sai__UpdateCoreUrlKeyType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__UpdateCoreUrlKeyType[n]; + if (size) + *size = n * sizeof(sai__UpdateCoreUrlKeyType); + for (int i = 0; i < n; i++) + ((sai__UpdateCoreUrlKeyType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__UpdateCoreUrlKeyType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UpdateCoreUrlKeyType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__UpdateCoreUrlKeyType %p -> %p\n", q, p)); + *(sai__UpdateCoreUrlKeyType*)p = *(sai__UpdateCoreUrlKeyType*)q; +} + +void sai__CertificateChainType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__CertificateChainType*)this)->Length, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__CertificateChainType*)this)->Value, SOAP_TYPE_xsd__base64Binary); + ((sai__CertificateChainType*)this)->Value.soap_serialize(soap); + /* transient soap skipped */ +} + +void sai__CertificateChainType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__RsaCertificateEncodingType(soap, &((sai__CertificateChainType*)this)->Encoding); + soap_default_unsignedInt(soap, &((sai__CertificateChainType*)this)->Length); + ((sai__CertificateChainType*)this)->Value.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int sai__CertificateChainType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__CertificateChainType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__CertificateChainType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__CertificateChainType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__CertificateChainType(struct soap *soap, const char *tag, int id, const sai__CertificateChainType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__CertificateChainType), type); + soap_out_sai__RsaCertificateEncodingType(soap, "sai:Encoding", -1, &(((sai__CertificateChainType*)a)->Encoding), ""); + soap_out_unsignedInt(soap, "sai:Length", -1, &(((sai__CertificateChainType*)a)->Length), ""); + (((sai__CertificateChainType*)a)->Value).soap_out(soap, "sai:Value", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__CertificateChainType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__CertificateChainType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__CertificateChainType * SOAP_FMAC4 soap_get_sai__CertificateChainType(struct soap *soap, sai__CertificateChainType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__CertificateChainType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__CertificateChainType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__CertificateChainType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__CertificateChainType * SOAP_FMAC4 soap_in_sai__CertificateChainType(struct soap *soap, const char *tag, sai__CertificateChainType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__CertificateChainType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__CertificateChainType, sizeof(sai__CertificateChainType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__CertificateChainType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__CertificateChainType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Encoding1 = 1, soap_flag_Length1 = 1, soap_flag_Value1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Encoding1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__RsaCertificateEncodingType(soap, "sai:Encoding", &(((sai__CertificateChainType*)a)->Encoding), "sai:RsaCertificateEncodingType")) + { soap_flag_Encoding1--; + continue; + } + if (soap_flag_Length1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:Length", &(((sai__CertificateChainType*)a)->Length), "xsd:unsignedInt")) + { soap_flag_Length1--; + continue; + } + if (soap_flag_Value1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__CertificateChainType*)a)->Value).soap_in(soap, "sai:Value", "xsd:base64Binary")) + { soap_flag_Value1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Encoding1 > 0 || soap_flag_Length1 > 0 || soap_flag_Value1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__CertificateChainType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__CertificateChainType, 0, sizeof(sai__CertificateChainType), 0, soap_copy_sai__CertificateChainType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__CertificateChainType * SOAP_FMAC6 soap_new_sai__CertificateChainType(struct soap *soap, int n) +{ return soap_instantiate_sai__CertificateChainType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__CertificateChainType(struct soap *soap, sai__CertificateChainType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__CertificateChainType * SOAP_FMAC4 soap_instantiate_sai__CertificateChainType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__CertificateChainType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__CertificateChainType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__CertificateChainType; + if (size) + *size = sizeof(sai__CertificateChainType); + ((sai__CertificateChainType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__CertificateChainType[n]; + if (size) + *size = n * sizeof(sai__CertificateChainType); + for (int i = 0; i < n; i++) + ((sai__CertificateChainType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__CertificateChainType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__CertificateChainType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__CertificateChainType %p -> %p\n", q, p)); + *(sai__CertificateChainType*)p = *(sai__CertificateChainType*)q; +} + +void sai__RngKeyType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__RngKeyType*)this)->Length, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__RngKeyType*)this)->Data, SOAP_TYPE_xsd__base64Binary); + ((sai__RngKeyType*)this)->Data.soap_serialize(soap); + /* transient soap skipped */ +} + +void sai__RngKeyType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__RngKeyEncodingType(soap, &((sai__RngKeyType*)this)->Type); + soap_default_unsignedInt(soap, &((sai__RngKeyType*)this)->Length); + ((sai__RngKeyType*)this)->Data.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int sai__RngKeyType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__RngKeyType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__RngKeyType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__RngKeyType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RngKeyType(struct soap *soap, const char *tag, int id, const sai__RngKeyType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__RngKeyType), type); + soap_out_sai__RngKeyEncodingType(soap, "sai:Type", -1, &(((sai__RngKeyType*)a)->Type), ""); + soap_out_unsignedInt(soap, "sai:Length", -1, &(((sai__RngKeyType*)a)->Length), ""); + (((sai__RngKeyType*)a)->Data).soap_out(soap, "sai:Data", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__RngKeyType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__RngKeyType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__RngKeyType * SOAP_FMAC4 soap_get_sai__RngKeyType(struct soap *soap, sai__RngKeyType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__RngKeyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__RngKeyType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__RngKeyType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__RngKeyType * SOAP_FMAC4 soap_in_sai__RngKeyType(struct soap *soap, const char *tag, sai__RngKeyType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__RngKeyType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__RngKeyType, sizeof(sai__RngKeyType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__RngKeyType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__RngKeyType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Type1 = 1, soap_flag_Length1 = 1, soap_flag_Data1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Type1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__RngKeyEncodingType(soap, "sai:Type", &(((sai__RngKeyType*)a)->Type), "sai:RngKeyEncodingType")) + { soap_flag_Type1--; + continue; + } + if (soap_flag_Length1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:Length", &(((sai__RngKeyType*)a)->Length), "xsd:unsignedInt")) + { soap_flag_Length1--; + continue; + } + if (soap_flag_Data1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__RngKeyType*)a)->Data).soap_in(soap, "sai:Data", "xsd:base64Binary")) + { soap_flag_Data1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Type1 > 0 || soap_flag_Length1 > 0 || soap_flag_Data1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__RngKeyType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__RngKeyType, 0, sizeof(sai__RngKeyType), 0, soap_copy_sai__RngKeyType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__RngKeyType * SOAP_FMAC6 soap_new_sai__RngKeyType(struct soap *soap, int n) +{ return soap_instantiate_sai__RngKeyType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__RngKeyType(struct soap *soap, sai__RngKeyType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__RngKeyType * SOAP_FMAC4 soap_instantiate_sai__RngKeyType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__RngKeyType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__RngKeyType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__RngKeyType; + if (size) + *size = sizeof(sai__RngKeyType); + ((sai__RngKeyType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__RngKeyType[n]; + if (size) + *size = n * sizeof(sai__RngKeyType); + for (int i = 0; i < n; i++) + ((sai__RngKeyType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__RngKeyType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__RngKeyType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__RngKeyType %p -> %p\n", q, p)); + *(sai__RngKeyType*)p = *(sai__RngKeyType*)q; +} + +void sai__RsaKeyType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((sai__RsaKeyType*)this)->Length, SOAP_TYPE_unsignedInt); + soap_embedded(soap, &((sai__RsaKeyType*)this)->Value, SOAP_TYPE_xsd__base64Binary); + ((sai__RsaKeyType*)this)->Value.soap_serialize(soap); + /* transient soap skipped */ +} + +void sai__RsaKeyType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__RsaKeyEncodingType(soap, &((sai__RsaKeyType*)this)->Encoding); + soap_default_unsignedInt(soap, &((sai__RsaKeyType*)this)->Length); + ((sai__RsaKeyType*)this)->Value.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int sai__RsaKeyType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__RsaKeyType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__RsaKeyType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__RsaKeyType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__RsaKeyType(struct soap *soap, const char *tag, int id, const sai__RsaKeyType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__RsaKeyType), type); + soap_out_sai__RsaKeyEncodingType(soap, "sai:Encoding", -1, &(((sai__RsaKeyType*)a)->Encoding), ""); + soap_out_unsignedInt(soap, "sai:Length", -1, &(((sai__RsaKeyType*)a)->Length), ""); + (((sai__RsaKeyType*)a)->Value).soap_out(soap, "sai:Value", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__RsaKeyType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__RsaKeyType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__RsaKeyType * SOAP_FMAC4 soap_get_sai__RsaKeyType(struct soap *soap, sai__RsaKeyType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__RsaKeyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__RsaKeyType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__RsaKeyType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__RsaKeyType * SOAP_FMAC4 soap_in_sai__RsaKeyType(struct soap *soap, const char *tag, sai__RsaKeyType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__RsaKeyType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__RsaKeyType, sizeof(sai__RsaKeyType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__RsaKeyType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__RsaKeyType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Encoding1 = 1, soap_flag_Length1 = 1, soap_flag_Value1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Encoding1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_sai__RsaKeyEncodingType(soap, "sai:Encoding", &(((sai__RsaKeyType*)a)->Encoding), "sai:RsaKeyEncodingType")) + { soap_flag_Encoding1--; + continue; + } + if (soap_flag_Length1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_unsignedInt(soap, "sai:Length", &(((sai__RsaKeyType*)a)->Length), "xsd:unsignedInt")) + { soap_flag_Length1--; + continue; + } + if (soap_flag_Value1 && soap->error == SOAP_TAG_MISMATCH) + if ((((sai__RsaKeyType*)a)->Value).soap_in(soap, "sai:Value", "xsd:base64Binary")) + { soap_flag_Value1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Encoding1 > 0 || soap_flag_Length1 > 0 || soap_flag_Value1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__RsaKeyType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__RsaKeyType, 0, sizeof(sai__RsaKeyType), 0, soap_copy_sai__RsaKeyType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__RsaKeyType * SOAP_FMAC6 soap_new_sai__RsaKeyType(struct soap *soap, int n) +{ return soap_instantiate_sai__RsaKeyType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__RsaKeyType(struct soap *soap, sai__RsaKeyType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__RsaKeyType * SOAP_FMAC4 soap_instantiate_sai__RsaKeyType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__RsaKeyType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__RsaKeyType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__RsaKeyType; + if (size) + *size = sizeof(sai__RsaKeyType); + ((sai__RsaKeyType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__RsaKeyType[n]; + if (size) + *size = n * sizeof(sai__RsaKeyType); + for (int i = 0; i < n; i++) + ((sai__RsaKeyType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__RsaKeyType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__RsaKeyType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__RsaKeyType %p -> %p\n", q, p)); + *(sai__RsaKeyType*)p = *(sai__RsaKeyType*)q; +} + +void sai__UserAclRealmListType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfsai__UserAclRealmType(soap, &((sai__UserAclRealmListType*)this)->Realm); + /* transient soap skipped */ +} + +void sai__UserAclRealmListType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfsai__UserAclRealmType(soap, &((sai__UserAclRealmListType*)this)->Realm); + /* transient soap skipped */ +} + +int sai__UserAclRealmListType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__UserAclRealmListType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__UserAclRealmListType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__UserAclRealmListType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclRealmListType(struct soap *soap, const char *tag, int id, const sai__UserAclRealmListType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__UserAclRealmListType), type); + soap_out_std__vectorTemplateOfsai__UserAclRealmType(soap, "sai:Realm", -1, &(((sai__UserAclRealmListType*)a)->Realm), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__UserAclRealmListType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__UserAclRealmListType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__UserAclRealmListType * SOAP_FMAC4 soap_get_sai__UserAclRealmListType(struct soap *soap, sai__UserAclRealmListType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__UserAclRealmListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__UserAclRealmListType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__UserAclRealmListType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__UserAclRealmListType * SOAP_FMAC4 soap_in_sai__UserAclRealmListType(struct soap *soap, const char *tag, sai__UserAclRealmListType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__UserAclRealmListType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__UserAclRealmListType, sizeof(sai__UserAclRealmListType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__UserAclRealmListType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__UserAclRealmListType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfsai__UserAclRealmType(soap, "sai:Realm", &(((sai__UserAclRealmListType*)a)->Realm), "sai:UserAclRealmType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((sai__UserAclRealmListType*)a)->Realm.size() > 16)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__UserAclRealmListType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__UserAclRealmListType, 0, sizeof(sai__UserAclRealmListType), 0, soap_copy_sai__UserAclRealmListType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__UserAclRealmListType * SOAP_FMAC6 soap_new_sai__UserAclRealmListType(struct soap *soap, int n) +{ return soap_instantiate_sai__UserAclRealmListType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserAclRealmListType(struct soap *soap, sai__UserAclRealmListType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__UserAclRealmListType * SOAP_FMAC4 soap_instantiate_sai__UserAclRealmListType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__UserAclRealmListType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__UserAclRealmListType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__UserAclRealmListType; + if (size) + *size = sizeof(sai__UserAclRealmListType); + ((sai__UserAclRealmListType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__UserAclRealmListType[n]; + if (size) + *size = n * sizeof(sai__UserAclRealmListType); + for (int i = 0; i < n; i++) + ((sai__UserAclRealmListType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__UserAclRealmListType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserAclRealmListType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__UserAclRealmListType %p -> %p\n", q, p)); + *(sai__UserAclRealmListType*)p = *(sai__UserAclRealmListType*)q; +} + +void sai__UserAclEntryHandleListType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_std__vectorTemplateOfsai__UserAclEntryHandleType(soap, &((sai__UserAclEntryHandleListType*)this)->Handle); + /* transient soap skipped */ +} + +void sai__UserAclEntryHandleListType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_std__vectorTemplateOfsai__UserAclEntryHandleType(soap, &((sai__UserAclEntryHandleListType*)this)->Handle); + /* transient soap skipped */ +} + +int sai__UserAclEntryHandleListType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__UserAclEntryHandleListType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__UserAclEntryHandleListType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__UserAclEntryHandleListType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclEntryHandleListType(struct soap *soap, const char *tag, int id, const sai__UserAclEntryHandleListType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__UserAclEntryHandleListType), type); + soap_out_std__vectorTemplateOfsai__UserAclEntryHandleType(soap, "sai:Handle", -1, &(((sai__UserAclEntryHandleListType*)a)->Handle), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__UserAclEntryHandleListType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__UserAclEntryHandleListType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__UserAclEntryHandleListType * SOAP_FMAC4 soap_get_sai__UserAclEntryHandleListType(struct soap *soap, sai__UserAclEntryHandleListType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__UserAclEntryHandleListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__UserAclEntryHandleListType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__UserAclEntryHandleListType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__UserAclEntryHandleListType * SOAP_FMAC4 soap_in_sai__UserAclEntryHandleListType(struct soap *soap, const char *tag, sai__UserAclEntryHandleListType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__UserAclEntryHandleListType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__UserAclEntryHandleListType, sizeof(sai__UserAclEntryHandleListType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__UserAclEntryHandleListType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__UserAclEntryHandleListType *)a->soap_in(soap, tag, type); + } + }; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap->error == SOAP_TAG_MISMATCH) + if (soap_in_std__vectorTemplateOfsai__UserAclEntryHandleType(soap, "sai:Handle", &(((sai__UserAclEntryHandleListType*)a)->Handle), "sai:UserAclEntryHandleType")) + continue; + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (((sai__UserAclEntryHandleListType*)a)->Handle.size() > 7)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__UserAclEntryHandleListType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__UserAclEntryHandleListType, 0, sizeof(sai__UserAclEntryHandleListType), 0, soap_copy_sai__UserAclEntryHandleListType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__UserAclEntryHandleListType * SOAP_FMAC6 soap_new_sai__UserAclEntryHandleListType(struct soap *soap, int n) +{ return soap_instantiate_sai__UserAclEntryHandleListType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserAclEntryHandleListType(struct soap *soap, sai__UserAclEntryHandleListType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__UserAclEntryHandleListType * SOAP_FMAC4 soap_instantiate_sai__UserAclEntryHandleListType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__UserAclEntryHandleListType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__UserAclEntryHandleListType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__UserAclEntryHandleListType; + if (size) + *size = sizeof(sai__UserAclEntryHandleListType); + ((sai__UserAclEntryHandleListType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__UserAclEntryHandleListType[n]; + if (size) + *size = n * sizeof(sai__UserAclEntryHandleListType); + for (int i = 0; i < n; i++) + ((sai__UserAclEntryHandleListType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__UserAclEntryHandleListType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserAclEntryHandleListType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__UserAclEntryHandleListType %p -> %p\n", q, p)); + *(sai__UserAclEntryHandleListType*)p = *(sai__UserAclEntryHandleListType*)q; +} + +void sai__AdminAclEntryType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_sai__AclStringType(soap, &((sai__AdminAclEntryType*)this)->Username); + soap_serialize_sai__AclPasswordStringType(soap, &((sai__AdminAclEntryType*)this)->Password); + /* transient soap skipped */ +} + +void sai__AdminAclEntryType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__AclStringType(soap, &((sai__AdminAclEntryType*)this)->Username); + soap_default_sai__AclPasswordStringType(soap, &((sai__AdminAclEntryType*)this)->Password); + /* transient soap skipped */ +} + +int sai__AdminAclEntryType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__AdminAclEntryType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__AdminAclEntryType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__AdminAclEntryType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__AdminAclEntryType(struct soap *soap, const char *tag, int id, const sai__AdminAclEntryType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__AdminAclEntryType), type); + soap_out_sai__AclStringType(soap, "sai:Username", -1, &(((sai__AdminAclEntryType*)a)->Username), ""); + soap_out_sai__AclPasswordStringType(soap, "sai:Password", -1, &(((sai__AdminAclEntryType*)a)->Password), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__AdminAclEntryType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__AdminAclEntryType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__AdminAclEntryType * SOAP_FMAC4 soap_get_sai__AdminAclEntryType(struct soap *soap, sai__AdminAclEntryType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__AdminAclEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__AdminAclEntryType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__AdminAclEntryType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__AdminAclEntryType * SOAP_FMAC4 soap_in_sai__AdminAclEntryType(struct soap *soap, const char *tag, sai__AdminAclEntryType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__AdminAclEntryType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__AdminAclEntryType, sizeof(sai__AdminAclEntryType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__AdminAclEntryType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__AdminAclEntryType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Username1 = 1, soap_flag_Password1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Username1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_sai__AclStringType(soap, "sai:Username", &(((sai__AdminAclEntryType*)a)->Username), "sai:AclStringType")) + { soap_flag_Username1--; + continue; + } + if (soap_flag_Password1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_sai__AclPasswordStringType(soap, "sai:Password", &(((sai__AdminAclEntryType*)a)->Password), "sai:AclPasswordStringType")) + { soap_flag_Password1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Username1 > 0 || soap_flag_Password1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__AdminAclEntryType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__AdminAclEntryType, 0, sizeof(sai__AdminAclEntryType), 0, soap_copy_sai__AdminAclEntryType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__AdminAclEntryType * SOAP_FMAC6 soap_new_sai__AdminAclEntryType(struct soap *soap, int n) +{ return soap_instantiate_sai__AdminAclEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__AdminAclEntryType(struct soap *soap, sai__AdminAclEntryType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__AdminAclEntryType * SOAP_FMAC4 soap_instantiate_sai__AdminAclEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__AdminAclEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__AdminAclEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__AdminAclEntryType; + if (size) + *size = sizeof(sai__AdminAclEntryType); + ((sai__AdminAclEntryType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__AdminAclEntryType[n]; + if (size) + *size = n * sizeof(sai__AdminAclEntryType); + for (int i = 0; i < n; i++) + ((sai__AdminAclEntryType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__AdminAclEntryType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__AdminAclEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__AdminAclEntryType %p -> %p\n", q, p)); + *(sai__AdminAclEntryType*)p = *(sai__AdminAclEntryType*)q; +} + +void sai__UserAclEntryType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_sai__AclStringType(soap, &((sai__UserAclEntryType*)this)->Username); + soap_serialize_sai__AclPasswordStringType(soap, &((sai__UserAclEntryType*)this)->Password); + soap_serialize_PointerTosai__UserAclRealmListType(soap, &((sai__UserAclEntryType*)this)->Realms); + /* transient soap skipped */ +} + +void sai__UserAclEntryType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_sai__AclStringType(soap, &((sai__UserAclEntryType*)this)->Username); + soap_default_sai__AclPasswordStringType(soap, &((sai__UserAclEntryType*)this)->Password); + ((sai__UserAclEntryType*)this)->Realms = NULL; + /* transient soap skipped */ +} + +int sai__UserAclEntryType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_sai__UserAclEntryType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int sai__UserAclEntryType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_sai__UserAclEntryType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_sai__UserAclEntryType(struct soap *soap, const char *tag, int id, const sai__UserAclEntryType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_sai__UserAclEntryType), type); + soap_out_sai__AclStringType(soap, "sai:Username", -1, &(((sai__UserAclEntryType*)a)->Username), ""); + soap_out_sai__AclPasswordStringType(soap, "sai:Password", -1, &(((sai__UserAclEntryType*)a)->Password), ""); + soap_out_PointerTosai__UserAclRealmListType(soap, "sai:Realms", -1, &(((sai__UserAclEntryType*)a)->Realms), ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *sai__UserAclEntryType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_sai__UserAclEntryType(soap, this, tag, type); +} + +SOAP_FMAC3 sai__UserAclEntryType * SOAP_FMAC4 soap_get_sai__UserAclEntryType(struct soap *soap, sai__UserAclEntryType *p, const char *tag, const char *type) +{ + if ((p = soap_in_sai__UserAclEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *sai__UserAclEntryType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_sai__UserAclEntryType(soap, tag, this, type); +} + +SOAP_FMAC3 sai__UserAclEntryType * SOAP_FMAC4 soap_in_sai__UserAclEntryType(struct soap *soap, const char *tag, sai__UserAclEntryType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (sai__UserAclEntryType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_sai__UserAclEntryType, sizeof(sai__UserAclEntryType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_sai__UserAclEntryType) + { soap_revert(soap); + *soap->id = '\0'; + return (sai__UserAclEntryType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_Username1 = 1, soap_flag_Password1 = 1, soap_flag_Realms1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_Username1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_sai__AclStringType(soap, "sai:Username", &(((sai__UserAclEntryType*)a)->Username), "sai:AclStringType")) + { soap_flag_Username1--; + continue; + } + if (soap_flag_Password1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_sai__AclPasswordStringType(soap, "sai:Password", &(((sai__UserAclEntryType*)a)->Password), "sai:AclPasswordStringType")) + { soap_flag_Password1--; + continue; + } + if (soap_flag_Realms1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTosai__UserAclRealmListType(soap, "sai:Realms", &(((sai__UserAclEntryType*)a)->Realms), "sai:UserAclRealmListType")) + { soap_flag_Realms1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_Username1 > 0 || soap_flag_Password1 > 0 || soap_flag_Realms1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (sai__UserAclEntryType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_sai__UserAclEntryType, 0, sizeof(sai__UserAclEntryType), 0, soap_copy_sai__UserAclEntryType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 sai__UserAclEntryType * SOAP_FMAC6 soap_new_sai__UserAclEntryType(struct soap *soap, int n) +{ return soap_instantiate_sai__UserAclEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_sai__UserAclEntryType(struct soap *soap, sai__UserAclEntryType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 sai__UserAclEntryType * SOAP_FMAC4 soap_instantiate_sai__UserAclEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_sai__UserAclEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_sai__UserAclEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new sai__UserAclEntryType; + if (size) + *size = sizeof(sai__UserAclEntryType); + ((sai__UserAclEntryType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new sai__UserAclEntryType[n]; + if (size) + *size = n * sizeof(sai__UserAclEntryType); + for (int i = 0; i < n; i++) + ((sai__UserAclEntryType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (sai__UserAclEntryType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_sai__UserAclEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying sai__UserAclEntryType %p -> %p\n", q, p)); + *(sai__UserAclEntryType*)p = *(sai__UserAclEntryType*)q; +} + +void cstr__KeyPairType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__cstr__union_KeyPairType(soap, ((cstr__KeyPairType*)this)->__union_KeyPairType, &((cstr__KeyPairType*)this)->union_KeyPairType); + /* transient soap skipped */ +} + +void cstr__KeyPairType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cstr__KeyPairType*)this)->__union_KeyPairType = 0; + /* transient soap skipped */ +} + +int cstr__KeyPairType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cstr__KeyPairType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cstr__KeyPairType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cstr__KeyPairType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cstr__KeyPairType(struct soap *soap, const char *tag, int id, const cstr__KeyPairType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cstr__KeyPairType), type); + soap_out__cstr__union_KeyPairType(soap, ((cstr__KeyPairType*)a)->__union_KeyPairType, &((cstr__KeyPairType*)a)->union_KeyPairType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cstr__KeyPairType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cstr__KeyPairType(soap, this, tag, type); +} + +SOAP_FMAC3 cstr__KeyPairType * SOAP_FMAC4 soap_get_cstr__KeyPairType(struct soap *soap, cstr__KeyPairType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cstr__KeyPairType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cstr__KeyPairType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cstr__KeyPairType(soap, tag, this, type); +} + +SOAP_FMAC3 cstr__KeyPairType * SOAP_FMAC4 soap_in_cstr__KeyPairType(struct soap *soap, const char *tag, cstr__KeyPairType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cstr__KeyPairType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cstr__KeyPairType, sizeof(cstr__KeyPairType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cstr__KeyPairType) + { soap_revert(soap); + *soap->id = '\0'; + return (cstr__KeyPairType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_KeyPairType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_KeyPairType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__cstr__union_KeyPairType(soap, &((cstr__KeyPairType*)a)->__union_KeyPairType, &((cstr__KeyPairType*)a)->union_KeyPairType)) + { soap_flag_union_KeyPairType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_KeyPairType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cstr__KeyPairType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cstr__KeyPairType, 0, sizeof(cstr__KeyPairType), 0, soap_copy_cstr__KeyPairType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cstr__KeyPairType * SOAP_FMAC6 soap_new_cstr__KeyPairType(struct soap *soap, int n) +{ return soap_instantiate_cstr__KeyPairType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cstr__KeyPairType(struct soap *soap, cstr__KeyPairType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cstr__KeyPairType * SOAP_FMAC4 soap_instantiate_cstr__KeyPairType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cstr__KeyPairType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cstr__KeyPairType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cstr__KeyPairType; + if (size) + *size = sizeof(cstr__KeyPairType); + ((cstr__KeyPairType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cstr__KeyPairType[n]; + if (size) + *size = n * sizeof(cstr__KeyPairType); + for (int i = 0; i < n; i++) + ((cstr__KeyPairType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cstr__KeyPairType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cstr__KeyPairType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cstr__KeyPairType %p -> %p\n", q, p)); + *(cstr__KeyPairType*)p = *(cstr__KeyPairType*)q; +} + +void cstr__RSAKeyPairType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_embedded(soap, &((cstr__RSAKeyPairType*)this)->DERKey, SOAP_TYPE_xsd__base64Binary); + ((cstr__RSAKeyPairType*)this)->DERKey.soap_serialize(soap); + /* transient soap skipped */ +} + +void cstr__RSAKeyPairType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cstr__RSAKeyPairType*)this)->DERKey.xsd__base64Binary::soap_default(soap); + /* transient soap skipped */ +} + +int cstr__RSAKeyPairType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cstr__RSAKeyPairType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cstr__RSAKeyPairType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cstr__RSAKeyPairType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cstr__RSAKeyPairType(struct soap *soap, const char *tag, int id, const cstr__RSAKeyPairType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cstr__RSAKeyPairType), type); + (((cstr__RSAKeyPairType*)a)->DERKey).soap_out(soap, "cstr:DERKey", -1, ""); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cstr__RSAKeyPairType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cstr__RSAKeyPairType(soap, this, tag, type); +} + +SOAP_FMAC3 cstr__RSAKeyPairType * SOAP_FMAC4 soap_get_cstr__RSAKeyPairType(struct soap *soap, cstr__RSAKeyPairType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cstr__RSAKeyPairType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cstr__RSAKeyPairType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cstr__RSAKeyPairType(soap, tag, this, type); +} + +SOAP_FMAC3 cstr__RSAKeyPairType * SOAP_FMAC4 soap_in_cstr__RSAKeyPairType(struct soap *soap, const char *tag, cstr__RSAKeyPairType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cstr__RSAKeyPairType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cstr__RSAKeyPairType, sizeof(cstr__RSAKeyPairType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cstr__RSAKeyPairType) + { soap_revert(soap); + *soap->id = '\0'; + return (cstr__RSAKeyPairType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_DERKey1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_DERKey1 && soap->error == SOAP_TAG_MISMATCH) + if ((((cstr__RSAKeyPairType*)a)->DERKey).soap_in(soap, "cstr:DERKey", "xsd:base64Binary")) + { soap_flag_DERKey1--; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_DERKey1 > 0)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cstr__RSAKeyPairType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cstr__RSAKeyPairType, 0, sizeof(cstr__RSAKeyPairType), 0, soap_copy_cstr__RSAKeyPairType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cstr__RSAKeyPairType * SOAP_FMAC6 soap_new_cstr__RSAKeyPairType(struct soap *soap, int n) +{ return soap_instantiate_cstr__RSAKeyPairType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cstr__RSAKeyPairType(struct soap *soap, cstr__RSAKeyPairType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cstr__RSAKeyPairType * SOAP_FMAC4 soap_instantiate_cstr__RSAKeyPairType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cstr__RSAKeyPairType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cstr__RSAKeyPairType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cstr__RSAKeyPairType; + if (size) + *size = sizeof(cstr__RSAKeyPairType); + ((cstr__RSAKeyPairType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cstr__RSAKeyPairType[n]; + if (size) + *size = n * sizeof(cstr__RSAKeyPairType); + for (int i = 0; i < n; i++) + ((cstr__RSAKeyPairType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cstr__RSAKeyPairType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cstr__RSAKeyPairType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cstr__RSAKeyPairType %p -> %p\n", q, p)); + *(cstr__RSAKeyPairType*)p = *(cstr__RSAKeyPairType*)q; +} + +void cmn__NodeAddressType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize__cmn__union_NodeAddressType(soap, ((cmn__NodeAddressType*)this)->__union_NodeAddressType, &((cmn__NodeAddressType*)this)->union_NodeAddressType); + /* transient soap skipped */ +} + +void cmn__NodeAddressType::soap_default(struct soap *soap) +{ + this->soap = soap; + ((cmn__NodeAddressType*)this)->__union_NodeAddressType = 0; + /* transient soap skipped */ +} + +int cmn__NodeAddressType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cmn__NodeAddressType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cmn__NodeAddressType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cmn__NodeAddressType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__NodeAddressType(struct soap *soap, const char *tag, int id, const cmn__NodeAddressType *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_cmn__NodeAddressType), type); + soap_out__cmn__union_NodeAddressType(soap, ((cmn__NodeAddressType*)a)->__union_NodeAddressType, &((cmn__NodeAddressType*)a)->union_NodeAddressType); + /* transient soap skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *cmn__NodeAddressType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cmn__NodeAddressType(soap, this, tag, type); +} + +SOAP_FMAC3 cmn__NodeAddressType * SOAP_FMAC4 soap_get_cmn__NodeAddressType(struct soap *soap, cmn__NodeAddressType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cmn__NodeAddressType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cmn__NodeAddressType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cmn__NodeAddressType(soap, tag, this, type); +} + +SOAP_FMAC3 cmn__NodeAddressType * SOAP_FMAC4 soap_in_cmn__NodeAddressType(struct soap *soap, const char *tag, cmn__NodeAddressType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + a = (cmn__NodeAddressType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cmn__NodeAddressType, sizeof(cmn__NodeAddressType), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cmn__NodeAddressType) + { soap_revert(soap); + *soap->id = '\0'; + return (cmn__NodeAddressType *)a->soap_in(soap, tag, type); + } + } + short soap_flag_union_NodeAddressType1 = 1; + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_union_NodeAddressType1 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in__cmn__union_NodeAddressType(soap, &((cmn__NodeAddressType*)a)->__union_NodeAddressType, &((cmn__NodeAddressType*)a)->union_NodeAddressType)) + { soap_flag_union_NodeAddressType1 = 0; + continue; + } + /* transient soap skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_union_NodeAddressType1)) + { soap->error = SOAP_OCCURS; + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (cmn__NodeAddressType *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_cmn__NodeAddressType, 0, sizeof(cmn__NodeAddressType), 0, soap_copy_cmn__NodeAddressType); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 cmn__NodeAddressType * SOAP_FMAC6 soap_new_cmn__NodeAddressType(struct soap *soap, int n) +{ return soap_instantiate_cmn__NodeAddressType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__NodeAddressType(struct soap *soap, cmn__NodeAddressType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cmn__NodeAddressType * SOAP_FMAC4 soap_instantiate_cmn__NodeAddressType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cmn__NodeAddressType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cmn__NodeAddressType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cmn__NodeAddressType; + if (size) + *size = sizeof(cmn__NodeAddressType); + ((cmn__NodeAddressType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cmn__NodeAddressType[n]; + if (size) + *size = n * sizeof(cmn__NodeAddressType); + for (int i = 0; i < n; i++) + ((cmn__NodeAddressType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cmn__NodeAddressType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__NodeAddressType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cmn__NodeAddressType %p -> %p\n", q, p)); + *(cmn__NodeAddressType*)p = *(cmn__NodeAddressType*)q; +} + +void cmn__URLType::soap_serialize(struct soap *soap) const +{ + (void)soap; /* appease -Wall -Werror */ + soap_serialize_xsd__anyURI(soap, &((cmn__URLType*)this)->__item); + /* transient soap skipped */ +} + +void cmn__URLType::soap_default(struct soap *soap) +{ + this->soap = soap; + soap_default_xsd__anyURI(soap, &((cmn__URLType*)this)->__item); + ((cmn__URLType*)this)->__anyAttribute = NULL; + /* transient soap skipped */ +} + +int cmn__URLType::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_cmn__URLType); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int cmn__URLType::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ + return soap_out_cmn__URLType(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_cmn__URLType(struct soap *soap, const char *tag, int id, const cmn__URLType *a, const char *type) +{ + if (((cmn__URLType *)a)->__anyAttribute) + soap_set_attr(soap, "-anyAttribute", ((cmn__URLType *)a)->__anyAttribute); + return soap_out_xsd__anyURI(soap, tag, id, &(((cmn__URLType*)a)->__item), ""); +} + +void *cmn__URLType::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_cmn__URLType(soap, this, tag, type); +} + +SOAP_FMAC3 cmn__URLType * SOAP_FMAC4 soap_get_cmn__URLType(struct soap *soap, cmn__URLType *p, const char *tag, const char *type) +{ + if ((p = soap_in_cmn__URLType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *cmn__URLType::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_cmn__URLType(soap, tag, this, type); +} + +SOAP_FMAC3 cmn__URLType * SOAP_FMAC4 soap_in_cmn__URLType(struct soap *soap, const char *tag, cmn__URLType *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!(a = (cmn__URLType *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_cmn__URLType, sizeof(cmn__URLType), soap->type, soap->arrayType))) + { soap->error = SOAP_TAG_MISMATCH; + return NULL; + } + soap_revert(soap); + *soap->id = '\0'; + if (soap->alloced) + { a->soap_default(soap); + if (soap->clist->type != SOAP_TYPE_cmn__URLType) + return (cmn__URLType *)a->soap_in(soap, tag, type); + } + if (soap_s2string(soap, soap_attr_value(soap, "-anyAttribute", 0), &((cmn__URLType *)a)->__anyAttribute)) + return NULL; + if (!soap_in_xsd__anyURI(soap, tag, &(((cmn__URLType*)a)->__item), "cmn:URLType")) + return NULL; + return a; +} + +SOAP_FMAC5 cmn__URLType * SOAP_FMAC6 soap_new_cmn__URLType(struct soap *soap, int n) +{ return soap_instantiate_cmn__URLType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_cmn__URLType(struct soap *soap, cmn__URLType *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 cmn__URLType * SOAP_FMAC4 soap_instantiate_cmn__URLType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_cmn__URLType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_cmn__URLType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new cmn__URLType; + if (size) + *size = sizeof(cmn__URLType); + ((cmn__URLType*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new cmn__URLType[n]; + if (size) + *size = n * sizeof(cmn__URLType); + for (int i = 0; i < n; i++) + ((cmn__URLType*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (cmn__URLType*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_cmn__URLType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying cmn__URLType %p -> %p\n", q, p)); + *(cmn__URLType*)p = *(cmn__URLType*)q; +} + +void xsd__base64Binary::soap_serialize(struct soap *soap) const +{ + if (this->__ptr && !soap_array_reference(soap, this, (struct soap_array*)&this->__ptr, 1, SOAP_TYPE_xsd__base64Binary)) + if (this->id || this->type) + soap->mode |= SOAP_ENC_DIME; +} + +void xsd__base64Binary::soap_default(struct soap *soap) +{ + this->soap = soap; + this->__size = 0; + this->__ptr = NULL; + this->id = NULL; + this->type = NULL; + this->options = NULL; +} + +int xsd__base64Binary::soap_put(struct soap *soap, const char *tag, const char *type) const +{ + register int id = soap_embed(soap, (void*)this, (struct soap_array*)&this->__ptr, 1, tag, SOAP_TYPE_xsd__base64Binary); + if (this->soap_out(soap, tag, id, type)) + return soap->error; + return soap_putindependent(soap); +} + +int xsd__base64Binary::soap_out(struct soap *soap, const char *tag, int id, const char *type) const +{ return soap_out_xsd__base64Binary(soap, tag, id, this, type); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__base64Binary(struct soap *soap, const char *tag, int id, const xsd__base64Binary *a, const char *type) +{ + id = soap_attachment(soap, tag, id, a, (struct soap_array*)&a->__ptr, a->id, a->type, a->options, 1, type, SOAP_TYPE_xsd__base64Binary); + if (id < 0) + return soap->error; + soap_element_begin_out(soap, tag, id, type); + soap_putbase64(soap, a->__ptr, a->__size); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +void *xsd__base64Binary::soap_get(struct soap *soap, const char *tag, const char *type) +{ + return soap_get_xsd__base64Binary(soap, this, tag, type); +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_get_xsd__base64Binary(struct soap *soap, xsd__base64Binary *p, const char *tag, const char *type) +{ + if ((p = soap_in_xsd__base64Binary(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +void *xsd__base64Binary::soap_in(struct soap *soap, const char *tag, const char *type) +{ return soap_in_xsd__base64Binary(soap, tag, this, type); +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_in_xsd__base64Binary(struct soap *soap, const char *tag, xsd__base64Binary *a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":base64Binary") && soap_match_tag(soap, soap->type, ":base64")) + { soap->error = SOAP_TYPE; + return NULL; + } + a = (xsd__base64Binary *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_xsd__base64Binary, sizeof(xsd__base64Binary), soap->type, soap->arrayType); + if (!a) + return NULL; + if (soap->alloced) + a->soap_default(soap); + if (soap->body && !*soap->href) + { + a->__ptr = soap_getbase64(soap, &a->__size, 0); + if (soap_xop_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + if ((!a->__ptr && soap->error) || soap_element_end_in(soap, tag)) + return NULL; + } + else + { if (*soap->href != '#') + { if (soap_dime_forward(soap, &a->__ptr, &a->__size, &a->id, &a->type, &a->options)) + return NULL; + } + else + a = (xsd__base64Binary *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_xsd__base64Binary, 0, sizeof(xsd__base64Binary), 0, soap_copy_xsd__base64Binary); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 xsd__base64Binary * SOAP_FMAC6 soap_new_xsd__base64Binary(struct soap *soap, int n) +{ return soap_instantiate_xsd__base64Binary(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xsd__base64Binary(struct soap *soap, xsd__base64Binary *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 xsd__base64Binary * SOAP_FMAC4 soap_instantiate_xsd__base64Binary(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xsd__base64Binary(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xsd__base64Binary, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new xsd__base64Binary; + if (size) + *size = sizeof(xsd__base64Binary); + ((xsd__base64Binary*)cp->ptr)->soap = soap; + } + else + { cp->ptr = (void*)new xsd__base64Binary[n]; + if (size) + *size = n * sizeof(xsd__base64Binary); + for (int i = 0; i < n; i++) + ((xsd__base64Binary*)cp->ptr)[i].soap = soap; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (xsd__base64Binary*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xsd__base64Binary(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying xsd__base64Binary %p -> %p\n", q, p)); + *(xsd__base64Binary*)p = *(xsd__base64Binary*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_xsd__anyURI(struct soap *soap, std::string const*a) +{ soap_serialize_std__string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_xsd__anyURI(struct soap *soap, std::string *a) +{ soap_default_std__string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__anyURI(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_xsd__anyURI); + if (soap_out_xsd__anyURI(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__anyURI(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_xsd__anyURI), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_xsd__anyURI(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_xsd__anyURI(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_xsd__anyURI(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_xsd__anyURI, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, -1))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_xsd__anyURI, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_xsd__anyURI, 0, sizeof(std::string), 0, soap_copy_xsd__anyURI); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_xsd__anyURI(struct soap *soap, int n) +{ return soap_instantiate_xsd__anyURI(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_xsd__anyURI(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_xsd__anyURI(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xsd__anyURI(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_xsd__anyURI, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xsd__anyURI(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__string(struct soap *soap, const std::string *p) +{ (void)soap; (void)p; /* appease -Wall -Werror */ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__string(struct soap *soap, std::string *p) +{ (void)soap; /* appease -Wall -Werror */ + p->erase(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_std__string(struct soap *soap, const std::string *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_std__string); + if (soap_out_std__string(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__string(struct soap *soap, const char *tag, int id, const std::string *s, const char *type) +{ + if ((soap->mode & SOAP_C_NILSTRING) && s->empty()) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, s, SOAP_TYPE_std__string), type) || soap_string_out(soap, s->c_str(), 0) || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_get_std__string(struct soap *soap, std::string *p, const char *tag, const char *type) +{ + if ((p = soap_in_std__string(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC1 std::string * SOAP_FMAC2 soap_in_std__string(struct soap *soap, const char *tag, std::string *s, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, type)) + return NULL; + if (!s) + s = soap_new_std__string(soap, -1); + if (soap->null) + if (s) + s->erase(); + if (soap->body && !*soap->href) + { char *t; + s = (std::string*)soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_std__string, sizeof(std::string), soap->type, soap->arrayType); + if (s) + if ((t = soap_string_in(soap, 1, -1, -1))) + s->assign(t); + else + return NULL; + } + else + s = (std::string*)soap_id_forward(soap, soap->href, soap_class_id_enter(soap, soap->id, s, SOAP_TYPE_std__string, sizeof(std::string), soap->type, soap->arrayType), 0, SOAP_TYPE_std__string, 0, sizeof(std::string), 0, soap_copy_std__string); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return s; +} + +SOAP_FMAC5 std::string * SOAP_FMAC6 soap_new_std__string(struct soap *soap, int n) +{ return soap_instantiate_std__string(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__string(struct soap *soap, std::string *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::string * SOAP_FMAC4 soap_instantiate_std__string(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__string(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__string, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::string; + if (size) + *size = sizeof(std::string); + } + else + { cp->ptr = (void*)new std::string[n]; + if (size) + *size = n * sizeof(std::string); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::string*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__string(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::string %p -> %p\n", q, p)); + *(std::string*)p = *(std::string*)q; +} + +#ifndef WITH_NOGLOBAL + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize__QName(soap, &a->faultcode); + soap_serialize_string(soap, &a->faultstring); + soap_serialize_string(soap, &a->faultactor); + soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail); + soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code); + soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason); + soap_serialize_string(soap, &a->SOAP_ENV__Node); + soap_serialize_string(soap, &a->SOAP_ENV__Role); + soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_default__QName(soap, &a->faultcode); + soap_default_string(soap, &a->faultstring); + soap_default_string(soap, &a->faultactor); + a->detail = NULL; + a->SOAP_ENV__Code = NULL; + a->SOAP_ENV__Reason = NULL; + soap_default_string(soap, &a->SOAP_ENV__Node); + soap_default_string(soap, &a->SOAP_ENV__Role); + a->SOAP_ENV__Detail = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault); + if (soap_out_SOAP_ENV__Fault(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Fault(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Fault *a, const char *type) +{ + const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode); + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type); + soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, ""); + soap_out_string(soap, "faultstring", -1, &a->faultstring, ""); + soap_out_string(soap, "faultactor", -1, &a->faultactor, ""); + soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""); + soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""); + soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""); + soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, ""); + soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, ""); + soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_get_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p, const char *tag, const char *type) +{ + if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_in_SOAP_ENV__Fault(struct soap *soap, const char *tag, struct SOAP_ENV__Fault *a, const char *type) +{ + short soap_flag_faultcode = 1, soap_flag_faultstring = 1, soap_flag_faultactor = 1, soap_flag_detail = 1, soap_flag_SOAP_ENV__Code = 1, soap_flag_SOAP_ENV__Reason = 1, soap_flag_SOAP_ENV__Node = 1, soap_flag_SOAP_ENV__Role = 1, soap_flag_SOAP_ENV__Detail = 1; + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (struct SOAP_ENV__Fault *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default_SOAP_ENV__Fault(soap, a); + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in__QName(soap, "faultcode", &a->faultcode, "")) + { soap_flag_faultcode--; + continue; + } + if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string")) + { soap_flag_faultstring--; + continue; + } + if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string")) + { soap_flag_faultactor--; + continue; + } + if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, "")) + { soap_flag_detail--; + continue; + } + if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, "")) + { soap_flag_SOAP_ENV__Code--; + continue; + } + if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, "")) + { soap_flag_SOAP_ENV__Reason--; + continue; + } + if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string")) + { soap_flag_SOAP_ENV__Node--; + continue; + } + if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string")) + { soap_flag_SOAP_ENV__Role--; + continue; + } + if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, "")) + { soap_flag_SOAP_ENV__Detail--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (struct SOAP_ENV__Fault *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_SOAP_ENV__Fault, 0, sizeof(struct SOAP_ENV__Fault), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct SOAP_ENV__Fault * SOAP_FMAC6 soap_new_SOAP_ENV__Fault(struct soap *soap, int n) +{ return soap_instantiate_SOAP_ENV__Fault(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Fault(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Fault(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Fault, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct SOAP_ENV__Fault; + if (size) + *size = sizeof(struct SOAP_ENV__Fault); + } + else + { cp->ptr = (void*)new struct SOAP_ENV__Fault[n]; + if (size) + *size = n * sizeof(struct SOAP_ENV__Fault); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct SOAP_ENV__Fault*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Fault(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Fault %p -> %p\n", q, p)); + *(struct SOAP_ENV__Fault*)p = *(struct SOAP_ENV__Fault*)q; +} + +#endif + +#ifndef WITH_NOGLOBAL + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_string(soap, &a->SOAP_ENV__Text); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_default_string(soap, &a->SOAP_ENV__Text); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason); + if (soap_out_SOAP_ENV__Reason(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Reason(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Reason *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type); + soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, ""); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_get_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p, const char *tag, const char *type) +{ + if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_in_SOAP_ENV__Reason(struct soap *soap, const char *tag, struct SOAP_ENV__Reason *a, const char *type) +{ + short soap_flag_SOAP_ENV__Text = 1; + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (struct SOAP_ENV__Reason *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default_SOAP_ENV__Reason(soap, a); + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string")) + { soap_flag_SOAP_ENV__Text--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (struct SOAP_ENV__Reason *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_SOAP_ENV__Reason, 0, sizeof(struct SOAP_ENV__Reason), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct SOAP_ENV__Reason * SOAP_FMAC6 soap_new_SOAP_ENV__Reason(struct soap *soap, int n) +{ return soap_instantiate_SOAP_ENV__Reason(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Reason(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Reason(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Reason, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct SOAP_ENV__Reason; + if (size) + *size = sizeof(struct SOAP_ENV__Reason); + } + else + { cp->ptr = (void*)new struct SOAP_ENV__Reason[n]; + if (size) + *size = n * sizeof(struct SOAP_ENV__Reason); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct SOAP_ENV__Reason*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Reason(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Reason %p -> %p\n", q, p)); + *(struct SOAP_ENV__Reason*)p = *(struct SOAP_ENV__Reason*)q; +} + +#endif + +#ifndef WITH_NOGLOBAL + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_markelement(soap, a->fault, a->__type); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->__type = 0; + a->fault = NULL; + a->__any = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail); + if (soap_out_SOAP_ENV__Detail(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Detail(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Detail *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type); + soap_putelement(soap, a->fault, "fault", -1, a->__type); + soap_outliteral(soap, "-any", &a->__any, NULL); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_get_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p, const char *tag, const char *type) +{ + if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_in_SOAP_ENV__Detail(struct soap *soap, const char *tag, struct SOAP_ENV__Detail *a, const char *type) +{ + short soap_flag_fault = 1, soap_flag___any = 1; + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (struct SOAP_ENV__Detail *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default_SOAP_ENV__Detail(soap, a); + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH) + if ((a->fault = soap_getelement(soap, &a->__type))) + { soap_flag_fault = 0; + continue; + } + if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_inliteral(soap, "-any", &a->__any)) + { soap_flag___any--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (struct SOAP_ENV__Detail *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_SOAP_ENV__Detail, 0, sizeof(struct SOAP_ENV__Detail), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct SOAP_ENV__Detail * SOAP_FMAC6 soap_new_SOAP_ENV__Detail(struct soap *soap, int n) +{ return soap_instantiate_SOAP_ENV__Detail(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Detail(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Detail(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Detail, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct SOAP_ENV__Detail; + if (size) + *size = sizeof(struct SOAP_ENV__Detail); + } + else + { cp->ptr = (void*)new struct SOAP_ENV__Detail[n]; + if (size) + *size = n * sizeof(struct SOAP_ENV__Detail); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct SOAP_ENV__Detail*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Detail(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Detail %p -> %p\n", q, p)); + *(struct SOAP_ENV__Detail*)p = *(struct SOAP_ENV__Detail*)q; +} + +#endif + +#ifndef WITH_NOGLOBAL + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize__QName(soap, &a->SOAP_ENV__Value); + soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_default__QName(soap, &a->SOAP_ENV__Value); + a->SOAP_ENV__Subcode = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code); + if (soap_out_SOAP_ENV__Code(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Code(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Code *a, const char *type) +{ + const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value); + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type); + soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, ""); + soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""); + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_get_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p, const char *tag, const char *type) +{ + if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_in_SOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code *a, const char *type) +{ + short soap_flag_SOAP_ENV__Value = 1, soap_flag_SOAP_ENV__Subcode = 1; + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (struct SOAP_ENV__Code *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default_SOAP_ENV__Code(soap, a); + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG)) + if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, "")) + { soap_flag_SOAP_ENV__Value--; + continue; + } + if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, "")) + { soap_flag_SOAP_ENV__Subcode--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (struct SOAP_ENV__Code *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_SOAP_ENV__Code, 0, sizeof(struct SOAP_ENV__Code), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct SOAP_ENV__Code * SOAP_FMAC6 soap_new_SOAP_ENV__Code(struct soap *soap, int n) +{ return soap_instantiate_SOAP_ENV__Code(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Code(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Code(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Code, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct SOAP_ENV__Code; + if (size) + *size = sizeof(struct SOAP_ENV__Code); + } + else + { cp->ptr = (void*)new struct SOAP_ENV__Code[n]; + if (size) + *size = n * sizeof(struct SOAP_ENV__Code); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct SOAP_ENV__Code*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Code(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Code %p -> %p\n", q, p)); + *(struct SOAP_ENV__Code*)p = *(struct SOAP_ENV__Code*)q; +} + +#endif + +#ifndef WITH_NOGLOBAL + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + /* transient dummy skipped */ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + /* transient dummy skipped */ +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header); + if (soap_out_SOAP_ENV__Header(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Header(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Header *a, const char *type) +{ + soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type); + /* transient dummy skipped */ + soap_element_end_out(soap, tag); + return SOAP_OK; +} + +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_get_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p, const char *tag, const char *type) +{ + if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_in_SOAP_ENV__Header(struct soap *soap, const char *tag, struct SOAP_ENV__Header *a, const char *type) +{; + if (soap_element_begin_in(soap, tag, 0, type)) + return NULL; + a = (struct SOAP_ENV__Header *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default_SOAP_ENV__Header(soap, a); + if (soap->body && !*soap->href) + { + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + /* transient dummy skipped */ + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + if (soap_element_end_in(soap, tag)) + return NULL; + } + else + { a = (struct SOAP_ENV__Header *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_SOAP_ENV__Header, 0, sizeof(struct SOAP_ENV__Header), 0, NULL); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct SOAP_ENV__Header * SOAP_FMAC6 soap_new_SOAP_ENV__Header(struct soap *soap, int n) +{ return soap_instantiate_SOAP_ENV__Header(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Header(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Header(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Header, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct SOAP_ENV__Header; + if (size) + *size = sizeof(struct SOAP_ENV__Header); + } + else + { cp->ptr = (void*)new struct SOAP_ENV__Header[n]; + if (size) + *size = n * sizeof(struct SOAP_ENV__Header); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct SOAP_ENV__Header*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Header(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Header %p -> %p\n", q, p)); + *(struct SOAP_ENV__Header*)p = *(struct SOAP_ENV__Header*)q; +} + +#endif + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__GetWirelessSettings(struct soap *soap, const struct __wcxs__GetWirelessSettings *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_wcxs__GetWirelessSettingsRequest(soap, &a->wcxs__GetWirelessSettingsRequest); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__GetWirelessSettings(struct soap *soap, struct __wcxs__GetWirelessSettings *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->wcxs__GetWirelessSettingsRequest = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__GetWirelessSettings(struct soap *soap, const struct __wcxs__GetWirelessSettings *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___wcxs__GetWirelessSettings(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__GetWirelessSettings(struct soap *soap, const char *tag, int id, const struct __wcxs__GetWirelessSettings *a, const char *type) +{ + soap_out_PointerTo_wcxs__GetWirelessSettingsRequest(soap, "wcxs:GetWirelessSettingsRequest", -1, &a->wcxs__GetWirelessSettingsRequest, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __wcxs__GetWirelessSettings * SOAP_FMAC4 soap_get___wcxs__GetWirelessSettings(struct soap *soap, struct __wcxs__GetWirelessSettings *p, const char *tag, const char *type) +{ + if ((p = soap_in___wcxs__GetWirelessSettings(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __wcxs__GetWirelessSettings * SOAP_FMAC4 soap_in___wcxs__GetWirelessSettings(struct soap *soap, const char *tag, struct __wcxs__GetWirelessSettings *a, const char *type) +{ + short soap_flag_wcxs__GetWirelessSettingsRequest = 1; + a = (struct __wcxs__GetWirelessSettings *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___wcxs__GetWirelessSettings, sizeof(struct __wcxs__GetWirelessSettings), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___wcxs__GetWirelessSettings(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_wcxs__GetWirelessSettingsRequest && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_wcxs__GetWirelessSettingsRequest(soap, "wcxs:GetWirelessSettingsRequest", &a->wcxs__GetWirelessSettingsRequest, "")) + { soap_flag_wcxs__GetWirelessSettingsRequest--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __wcxs__GetWirelessSettings * SOAP_FMAC6 soap_new___wcxs__GetWirelessSettings(struct soap *soap, int n) +{ return soap_instantiate___wcxs__GetWirelessSettings(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__GetWirelessSettings(struct soap *soap, struct __wcxs__GetWirelessSettings *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __wcxs__GetWirelessSettings * SOAP_FMAC4 soap_instantiate___wcxs__GetWirelessSettings(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___wcxs__GetWirelessSettings(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___wcxs__GetWirelessSettings, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __wcxs__GetWirelessSettings; + if (size) + *size = sizeof(struct __wcxs__GetWirelessSettings); + } + else + { cp->ptr = (void*)new struct __wcxs__GetWirelessSettings[n]; + if (size) + *size = n * sizeof(struct __wcxs__GetWirelessSettings); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __wcxs__GetWirelessSettings*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__GetWirelessSettings(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __wcxs__GetWirelessSettings %p -> %p\n", q, p)); + *(struct __wcxs__GetWirelessSettings*)p = *(struct __wcxs__GetWirelessSettings*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__GetWirelessCapabilities(struct soap *soap, const struct __wcxs__GetWirelessCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_wcxs__GetWirelessCapabilitiesRequest(soap, &a->wcxs__GetWirelessCapabilitiesRequest); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__GetWirelessCapabilities(struct soap *soap, struct __wcxs__GetWirelessCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->wcxs__GetWirelessCapabilitiesRequest = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__GetWirelessCapabilities(struct soap *soap, const struct __wcxs__GetWirelessCapabilities *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___wcxs__GetWirelessCapabilities(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__GetWirelessCapabilities(struct soap *soap, const char *tag, int id, const struct __wcxs__GetWirelessCapabilities *a, const char *type) +{ + soap_out_PointerTo_wcxs__GetWirelessCapabilitiesRequest(soap, "wcxs:GetWirelessCapabilitiesRequest", -1, &a->wcxs__GetWirelessCapabilitiesRequest, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __wcxs__GetWirelessCapabilities * SOAP_FMAC4 soap_get___wcxs__GetWirelessCapabilities(struct soap *soap, struct __wcxs__GetWirelessCapabilities *p, const char *tag, const char *type) +{ + if ((p = soap_in___wcxs__GetWirelessCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __wcxs__GetWirelessCapabilities * SOAP_FMAC4 soap_in___wcxs__GetWirelessCapabilities(struct soap *soap, const char *tag, struct __wcxs__GetWirelessCapabilities *a, const char *type) +{ + short soap_flag_wcxs__GetWirelessCapabilitiesRequest = 1; + a = (struct __wcxs__GetWirelessCapabilities *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___wcxs__GetWirelessCapabilities, sizeof(struct __wcxs__GetWirelessCapabilities), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___wcxs__GetWirelessCapabilities(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_wcxs__GetWirelessCapabilitiesRequest && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_wcxs__GetWirelessCapabilitiesRequest(soap, "wcxs:GetWirelessCapabilitiesRequest", &a->wcxs__GetWirelessCapabilitiesRequest, "")) + { soap_flag_wcxs__GetWirelessCapabilitiesRequest--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __wcxs__GetWirelessCapabilities * SOAP_FMAC6 soap_new___wcxs__GetWirelessCapabilities(struct soap *soap, int n) +{ return soap_instantiate___wcxs__GetWirelessCapabilities(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__GetWirelessCapabilities(struct soap *soap, struct __wcxs__GetWirelessCapabilities *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __wcxs__GetWirelessCapabilities * SOAP_FMAC4 soap_instantiate___wcxs__GetWirelessCapabilities(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___wcxs__GetWirelessCapabilities(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___wcxs__GetWirelessCapabilities, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __wcxs__GetWirelessCapabilities; + if (size) + *size = sizeof(struct __wcxs__GetWirelessCapabilities); + } + else + { cp->ptr = (void*)new struct __wcxs__GetWirelessCapabilities[n]; + if (size) + *size = n * sizeof(struct __wcxs__GetWirelessCapabilities); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __wcxs__GetWirelessCapabilities*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__GetWirelessCapabilities(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __wcxs__GetWirelessCapabilities %p -> %p\n", q, p)); + *(struct __wcxs__GetWirelessCapabilities*)p = *(struct __wcxs__GetWirelessCapabilities*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__EnumerateWirelessProfiles(struct soap *soap, const struct __wcxs__EnumerateWirelessProfiles *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_wcxs__EnumerateWirelessProfilesRequest(soap, &a->wcxs__EnumerateWirelessProfilesRequest); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__EnumerateWirelessProfiles(struct soap *soap, struct __wcxs__EnumerateWirelessProfiles *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->wcxs__EnumerateWirelessProfilesRequest = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__EnumerateWirelessProfiles(struct soap *soap, const struct __wcxs__EnumerateWirelessProfiles *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___wcxs__EnumerateWirelessProfiles(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__EnumerateWirelessProfiles(struct soap *soap, const char *tag, int id, const struct __wcxs__EnumerateWirelessProfiles *a, const char *type) +{ + soap_out_PointerTo_wcxs__EnumerateWirelessProfilesRequest(soap, "wcxs:EnumerateWirelessProfilesRequest", -1, &a->wcxs__EnumerateWirelessProfilesRequest, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __wcxs__EnumerateWirelessProfiles * SOAP_FMAC4 soap_get___wcxs__EnumerateWirelessProfiles(struct soap *soap, struct __wcxs__EnumerateWirelessProfiles *p, const char *tag, const char *type) +{ + if ((p = soap_in___wcxs__EnumerateWirelessProfiles(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __wcxs__EnumerateWirelessProfiles * SOAP_FMAC4 soap_in___wcxs__EnumerateWirelessProfiles(struct soap *soap, const char *tag, struct __wcxs__EnumerateWirelessProfiles *a, const char *type) +{ + short soap_flag_wcxs__EnumerateWirelessProfilesRequest = 1; + a = (struct __wcxs__EnumerateWirelessProfiles *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___wcxs__EnumerateWirelessProfiles, sizeof(struct __wcxs__EnumerateWirelessProfiles), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___wcxs__EnumerateWirelessProfiles(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_wcxs__EnumerateWirelessProfilesRequest && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_wcxs__EnumerateWirelessProfilesRequest(soap, "wcxs:EnumerateWirelessProfilesRequest", &a->wcxs__EnumerateWirelessProfilesRequest, "")) + { soap_flag_wcxs__EnumerateWirelessProfilesRequest--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __wcxs__EnumerateWirelessProfiles * SOAP_FMAC6 soap_new___wcxs__EnumerateWirelessProfiles(struct soap *soap, int n) +{ return soap_instantiate___wcxs__EnumerateWirelessProfiles(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__EnumerateWirelessProfiles(struct soap *soap, struct __wcxs__EnumerateWirelessProfiles *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __wcxs__EnumerateWirelessProfiles * SOAP_FMAC4 soap_instantiate___wcxs__EnumerateWirelessProfiles(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___wcxs__EnumerateWirelessProfiles(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___wcxs__EnumerateWirelessProfiles, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __wcxs__EnumerateWirelessProfiles; + if (size) + *size = sizeof(struct __wcxs__EnumerateWirelessProfiles); + } + else + { cp->ptr = (void*)new struct __wcxs__EnumerateWirelessProfiles[n]; + if (size) + *size = n * sizeof(struct __wcxs__EnumerateWirelessProfiles); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __wcxs__EnumerateWirelessProfiles*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__EnumerateWirelessProfiles(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __wcxs__EnumerateWirelessProfiles %p -> %p\n", q, p)); + *(struct __wcxs__EnumerateWirelessProfiles*)p = *(struct __wcxs__EnumerateWirelessProfiles*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__UpdateWirelessProfile(struct soap *soap, const struct __wcxs__UpdateWirelessProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_wcxs__UpdateWirelessProfileRequest(soap, &a->wcxs__UpdateWirelessProfileRequest); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__UpdateWirelessProfile(struct soap *soap, struct __wcxs__UpdateWirelessProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->wcxs__UpdateWirelessProfileRequest = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__UpdateWirelessProfile(struct soap *soap, const struct __wcxs__UpdateWirelessProfile *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___wcxs__UpdateWirelessProfile(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__UpdateWirelessProfile(struct soap *soap, const char *tag, int id, const struct __wcxs__UpdateWirelessProfile *a, const char *type) +{ + soap_out_PointerTo_wcxs__UpdateWirelessProfileRequest(soap, "wcxs:UpdateWirelessProfileRequest", -1, &a->wcxs__UpdateWirelessProfileRequest, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __wcxs__UpdateWirelessProfile * SOAP_FMAC4 soap_get___wcxs__UpdateWirelessProfile(struct soap *soap, struct __wcxs__UpdateWirelessProfile *p, const char *tag, const char *type) +{ + if ((p = soap_in___wcxs__UpdateWirelessProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __wcxs__UpdateWirelessProfile * SOAP_FMAC4 soap_in___wcxs__UpdateWirelessProfile(struct soap *soap, const char *tag, struct __wcxs__UpdateWirelessProfile *a, const char *type) +{ + short soap_flag_wcxs__UpdateWirelessProfileRequest = 1; + a = (struct __wcxs__UpdateWirelessProfile *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___wcxs__UpdateWirelessProfile, sizeof(struct __wcxs__UpdateWirelessProfile), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___wcxs__UpdateWirelessProfile(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_wcxs__UpdateWirelessProfileRequest && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_wcxs__UpdateWirelessProfileRequest(soap, "wcxs:UpdateWirelessProfileRequest", &a->wcxs__UpdateWirelessProfileRequest, "")) + { soap_flag_wcxs__UpdateWirelessProfileRequest--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __wcxs__UpdateWirelessProfile * SOAP_FMAC6 soap_new___wcxs__UpdateWirelessProfile(struct soap *soap, int n) +{ return soap_instantiate___wcxs__UpdateWirelessProfile(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__UpdateWirelessProfile(struct soap *soap, struct __wcxs__UpdateWirelessProfile *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __wcxs__UpdateWirelessProfile * SOAP_FMAC4 soap_instantiate___wcxs__UpdateWirelessProfile(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___wcxs__UpdateWirelessProfile(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___wcxs__UpdateWirelessProfile, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __wcxs__UpdateWirelessProfile; + if (size) + *size = sizeof(struct __wcxs__UpdateWirelessProfile); + } + else + { cp->ptr = (void*)new struct __wcxs__UpdateWirelessProfile[n]; + if (size) + *size = n * sizeof(struct __wcxs__UpdateWirelessProfile); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __wcxs__UpdateWirelessProfile*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__UpdateWirelessProfile(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __wcxs__UpdateWirelessProfile %p -> %p\n", q, p)); + *(struct __wcxs__UpdateWirelessProfile*)p = *(struct __wcxs__UpdateWirelessProfile*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__RemoveWirelessProfile(struct soap *soap, const struct __wcxs__RemoveWirelessProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_wcxs__RemoveWirelessProfileRequest(soap, &a->wcxs__RemoveWirelessProfileRequest); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__RemoveWirelessProfile(struct soap *soap, struct __wcxs__RemoveWirelessProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->wcxs__RemoveWirelessProfileRequest = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__RemoveWirelessProfile(struct soap *soap, const struct __wcxs__RemoveWirelessProfile *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___wcxs__RemoveWirelessProfile(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__RemoveWirelessProfile(struct soap *soap, const char *tag, int id, const struct __wcxs__RemoveWirelessProfile *a, const char *type) +{ + soap_out_PointerTo_wcxs__RemoveWirelessProfileRequest(soap, "wcxs:RemoveWirelessProfileRequest", -1, &a->wcxs__RemoveWirelessProfileRequest, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __wcxs__RemoveWirelessProfile * SOAP_FMAC4 soap_get___wcxs__RemoveWirelessProfile(struct soap *soap, struct __wcxs__RemoveWirelessProfile *p, const char *tag, const char *type) +{ + if ((p = soap_in___wcxs__RemoveWirelessProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __wcxs__RemoveWirelessProfile * SOAP_FMAC4 soap_in___wcxs__RemoveWirelessProfile(struct soap *soap, const char *tag, struct __wcxs__RemoveWirelessProfile *a, const char *type) +{ + short soap_flag_wcxs__RemoveWirelessProfileRequest = 1; + a = (struct __wcxs__RemoveWirelessProfile *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___wcxs__RemoveWirelessProfile, sizeof(struct __wcxs__RemoveWirelessProfile), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___wcxs__RemoveWirelessProfile(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_wcxs__RemoveWirelessProfileRequest && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_wcxs__RemoveWirelessProfileRequest(soap, "wcxs:RemoveWirelessProfileRequest", &a->wcxs__RemoveWirelessProfileRequest, "")) + { soap_flag_wcxs__RemoveWirelessProfileRequest--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __wcxs__RemoveWirelessProfile * SOAP_FMAC6 soap_new___wcxs__RemoveWirelessProfile(struct soap *soap, int n) +{ return soap_instantiate___wcxs__RemoveWirelessProfile(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__RemoveWirelessProfile(struct soap *soap, struct __wcxs__RemoveWirelessProfile *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __wcxs__RemoveWirelessProfile * SOAP_FMAC4 soap_instantiate___wcxs__RemoveWirelessProfile(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___wcxs__RemoveWirelessProfile(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___wcxs__RemoveWirelessProfile, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __wcxs__RemoveWirelessProfile; + if (size) + *size = sizeof(struct __wcxs__RemoveWirelessProfile); + } + else + { cp->ptr = (void*)new struct __wcxs__RemoveWirelessProfile[n]; + if (size) + *size = n * sizeof(struct __wcxs__RemoveWirelessProfile); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __wcxs__RemoveWirelessProfile*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__RemoveWirelessProfile(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __wcxs__RemoveWirelessProfile %p -> %p\n", q, p)); + *(struct __wcxs__RemoveWirelessProfile*)p = *(struct __wcxs__RemoveWirelessProfile*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__GetWirelessProfile(struct soap *soap, const struct __wcxs__GetWirelessProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_wcxs__GetWirelessProfileRequest(soap, &a->wcxs__GetWirelessProfileRequest); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__GetWirelessProfile(struct soap *soap, struct __wcxs__GetWirelessProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->wcxs__GetWirelessProfileRequest = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__GetWirelessProfile(struct soap *soap, const struct __wcxs__GetWirelessProfile *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___wcxs__GetWirelessProfile(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__GetWirelessProfile(struct soap *soap, const char *tag, int id, const struct __wcxs__GetWirelessProfile *a, const char *type) +{ + soap_out_PointerTo_wcxs__GetWirelessProfileRequest(soap, "wcxs:GetWirelessProfileRequest", -1, &a->wcxs__GetWirelessProfileRequest, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __wcxs__GetWirelessProfile * SOAP_FMAC4 soap_get___wcxs__GetWirelessProfile(struct soap *soap, struct __wcxs__GetWirelessProfile *p, const char *tag, const char *type) +{ + if ((p = soap_in___wcxs__GetWirelessProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __wcxs__GetWirelessProfile * SOAP_FMAC4 soap_in___wcxs__GetWirelessProfile(struct soap *soap, const char *tag, struct __wcxs__GetWirelessProfile *a, const char *type) +{ + short soap_flag_wcxs__GetWirelessProfileRequest = 1; + a = (struct __wcxs__GetWirelessProfile *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___wcxs__GetWirelessProfile, sizeof(struct __wcxs__GetWirelessProfile), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___wcxs__GetWirelessProfile(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_wcxs__GetWirelessProfileRequest && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_wcxs__GetWirelessProfileRequest(soap, "wcxs:GetWirelessProfileRequest", &a->wcxs__GetWirelessProfileRequest, "")) + { soap_flag_wcxs__GetWirelessProfileRequest--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __wcxs__GetWirelessProfile * SOAP_FMAC6 soap_new___wcxs__GetWirelessProfile(struct soap *soap, int n) +{ return soap_instantiate___wcxs__GetWirelessProfile(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__GetWirelessProfile(struct soap *soap, struct __wcxs__GetWirelessProfile *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __wcxs__GetWirelessProfile * SOAP_FMAC4 soap_instantiate___wcxs__GetWirelessProfile(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___wcxs__GetWirelessProfile(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___wcxs__GetWirelessProfile, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __wcxs__GetWirelessProfile; + if (size) + *size = sizeof(struct __wcxs__GetWirelessProfile); + } + else + { cp->ptr = (void*)new struct __wcxs__GetWirelessProfile[n]; + if (size) + *size = n * sizeof(struct __wcxs__GetWirelessProfile); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __wcxs__GetWirelessProfile*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__GetWirelessProfile(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __wcxs__GetWirelessProfile %p -> %p\n", q, p)); + *(struct __wcxs__GetWirelessProfile*)p = *(struct __wcxs__GetWirelessProfile*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___wcxs__AddWirelessProfile(struct soap *soap, const struct __wcxs__AddWirelessProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_wcxs__AddWirelessProfileRequest(soap, &a->wcxs__AddWirelessProfileRequest); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___wcxs__AddWirelessProfile(struct soap *soap, struct __wcxs__AddWirelessProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->wcxs__AddWirelessProfileRequest = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___wcxs__AddWirelessProfile(struct soap *soap, const struct __wcxs__AddWirelessProfile *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___wcxs__AddWirelessProfile(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___wcxs__AddWirelessProfile(struct soap *soap, const char *tag, int id, const struct __wcxs__AddWirelessProfile *a, const char *type) +{ + soap_out_PointerTo_wcxs__AddWirelessProfileRequest(soap, "wcxs:AddWirelessProfileRequest", -1, &a->wcxs__AddWirelessProfileRequest, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __wcxs__AddWirelessProfile * SOAP_FMAC4 soap_get___wcxs__AddWirelessProfile(struct soap *soap, struct __wcxs__AddWirelessProfile *p, const char *tag, const char *type) +{ + if ((p = soap_in___wcxs__AddWirelessProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __wcxs__AddWirelessProfile * SOAP_FMAC4 soap_in___wcxs__AddWirelessProfile(struct soap *soap, const char *tag, struct __wcxs__AddWirelessProfile *a, const char *type) +{ + short soap_flag_wcxs__AddWirelessProfileRequest = 1; + a = (struct __wcxs__AddWirelessProfile *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___wcxs__AddWirelessProfile, sizeof(struct __wcxs__AddWirelessProfile), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___wcxs__AddWirelessProfile(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_wcxs__AddWirelessProfileRequest && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_wcxs__AddWirelessProfileRequest(soap, "wcxs:AddWirelessProfileRequest", &a->wcxs__AddWirelessProfileRequest, "")) + { soap_flag_wcxs__AddWirelessProfileRequest--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __wcxs__AddWirelessProfile * SOAP_FMAC6 soap_new___wcxs__AddWirelessProfile(struct soap *soap, int n) +{ return soap_instantiate___wcxs__AddWirelessProfile(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___wcxs__AddWirelessProfile(struct soap *soap, struct __wcxs__AddWirelessProfile *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __wcxs__AddWirelessProfile * SOAP_FMAC4 soap_instantiate___wcxs__AddWirelessProfile(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___wcxs__AddWirelessProfile(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___wcxs__AddWirelessProfile, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __wcxs__AddWirelessProfile; + if (size) + *size = sizeof(struct __wcxs__AddWirelessProfile); + } + else + { cp->ptr = (void*)new struct __wcxs__AddWirelessProfile[n]; + if (size) + *size = n * sizeof(struct __wcxs__AddWirelessProfile); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __wcxs__AddWirelessProfile*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___wcxs__AddWirelessProfile(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __wcxs__AddWirelessProfile %p -> %p\n", q, p)); + *(struct __wcxs__AddWirelessProfile*)p = *(struct __wcxs__AddWirelessProfile*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tim__SetHighAccuracyTimeSynch(struct soap *soap, const struct __tim__SetHighAccuracyTimeSynch *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_tim__SetHighAccuracyTimeSynch(soap, &a->tim__SetHighAccuracyTimeSynch); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___tim__SetHighAccuracyTimeSynch(struct soap *soap, struct __tim__SetHighAccuracyTimeSynch *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->tim__SetHighAccuracyTimeSynch = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___tim__SetHighAccuracyTimeSynch(struct soap *soap, const struct __tim__SetHighAccuracyTimeSynch *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___tim__SetHighAccuracyTimeSynch(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___tim__SetHighAccuracyTimeSynch(struct soap *soap, const char *tag, int id, const struct __tim__SetHighAccuracyTimeSynch *a, const char *type) +{ + soap_out_PointerTo_tim__SetHighAccuracyTimeSynch(soap, "tim:SetHighAccuracyTimeSynch", -1, &a->tim__SetHighAccuracyTimeSynch, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_get___tim__SetHighAccuracyTimeSynch(struct soap *soap, struct __tim__SetHighAccuracyTimeSynch *p, const char *tag, const char *type) +{ + if ((p = soap_in___tim__SetHighAccuracyTimeSynch(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_in___tim__SetHighAccuracyTimeSynch(struct soap *soap, const char *tag, struct __tim__SetHighAccuracyTimeSynch *a, const char *type) +{ + short soap_flag_tim__SetHighAccuracyTimeSynch = 1; + a = (struct __tim__SetHighAccuracyTimeSynch *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___tim__SetHighAccuracyTimeSynch, sizeof(struct __tim__SetHighAccuracyTimeSynch), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___tim__SetHighAccuracyTimeSynch(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_tim__SetHighAccuracyTimeSynch && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_tim__SetHighAccuracyTimeSynch(soap, "tim:SetHighAccuracyTimeSynch", &a->tim__SetHighAccuracyTimeSynch, "")) + { soap_flag_tim__SetHighAccuracyTimeSynch--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __tim__SetHighAccuracyTimeSynch * SOAP_FMAC6 soap_new___tim__SetHighAccuracyTimeSynch(struct soap *soap, int n) +{ return soap_instantiate___tim__SetHighAccuracyTimeSynch(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___tim__SetHighAccuracyTimeSynch(struct soap *soap, struct __tim__SetHighAccuracyTimeSynch *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __tim__SetHighAccuracyTimeSynch * SOAP_FMAC4 soap_instantiate___tim__SetHighAccuracyTimeSynch(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___tim__SetHighAccuracyTimeSynch(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___tim__SetHighAccuracyTimeSynch, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __tim__SetHighAccuracyTimeSynch; + if (size) + *size = sizeof(struct __tim__SetHighAccuracyTimeSynch); + } + else + { cp->ptr = (void*)new struct __tim__SetHighAccuracyTimeSynch[n]; + if (size) + *size = n * sizeof(struct __tim__SetHighAccuracyTimeSynch); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __tim__SetHighAccuracyTimeSynch*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___tim__SetHighAccuracyTimeSynch(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __tim__SetHighAccuracyTimeSynch %p -> %p\n", q, p)); + *(struct __tim__SetHighAccuracyTimeSynch*)p = *(struct __tim__SetHighAccuracyTimeSynch*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___tim__GetLowAccuracyTimeSynch(struct soap *soap, const struct __tim__GetLowAccuracyTimeSynch *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_tim__GetLowAccuracyTimeSynch(soap, &a->tim__GetLowAccuracyTimeSynch); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___tim__GetLowAccuracyTimeSynch(struct soap *soap, struct __tim__GetLowAccuracyTimeSynch *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->tim__GetLowAccuracyTimeSynch = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___tim__GetLowAccuracyTimeSynch(struct soap *soap, const struct __tim__GetLowAccuracyTimeSynch *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___tim__GetLowAccuracyTimeSynch(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___tim__GetLowAccuracyTimeSynch(struct soap *soap, const char *tag, int id, const struct __tim__GetLowAccuracyTimeSynch *a, const char *type) +{ + soap_out_PointerTo_tim__GetLowAccuracyTimeSynch(soap, "tim:GetLowAccuracyTimeSynch", -1, &a->tim__GetLowAccuracyTimeSynch, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_get___tim__GetLowAccuracyTimeSynch(struct soap *soap, struct __tim__GetLowAccuracyTimeSynch *p, const char *tag, const char *type) +{ + if ((p = soap_in___tim__GetLowAccuracyTimeSynch(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_in___tim__GetLowAccuracyTimeSynch(struct soap *soap, const char *tag, struct __tim__GetLowAccuracyTimeSynch *a, const char *type) +{ + short soap_flag_tim__GetLowAccuracyTimeSynch = 1; + a = (struct __tim__GetLowAccuracyTimeSynch *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___tim__GetLowAccuracyTimeSynch, sizeof(struct __tim__GetLowAccuracyTimeSynch), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___tim__GetLowAccuracyTimeSynch(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_tim__GetLowAccuracyTimeSynch && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_tim__GetLowAccuracyTimeSynch(soap, "tim:GetLowAccuracyTimeSynch", &a->tim__GetLowAccuracyTimeSynch, "")) + { soap_flag_tim__GetLowAccuracyTimeSynch--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __tim__GetLowAccuracyTimeSynch * SOAP_FMAC6 soap_new___tim__GetLowAccuracyTimeSynch(struct soap *soap, int n) +{ return soap_instantiate___tim__GetLowAccuracyTimeSynch(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___tim__GetLowAccuracyTimeSynch(struct soap *soap, struct __tim__GetLowAccuracyTimeSynch *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __tim__GetLowAccuracyTimeSynch * SOAP_FMAC4 soap_instantiate___tim__GetLowAccuracyTimeSynch(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___tim__GetLowAccuracyTimeSynch(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___tim__GetLowAccuracyTimeSynch, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __tim__GetLowAccuracyTimeSynch; + if (size) + *size = sizeof(struct __tim__GetLowAccuracyTimeSynch); + } + else + { cp->ptr = (void*)new struct __tim__GetLowAccuracyTimeSynch[n]; + if (size) + *size = n * sizeof(struct __tim__GetLowAccuracyTimeSynch); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __tim__GetLowAccuracyTimeSynch*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___tim__GetLowAccuracyTimeSynch(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __tim__GetLowAccuracyTimeSynch %p -> %p\n", q, p)); + *(struct __tim__GetLowAccuracyTimeSynch*)p = *(struct __tim__GetLowAccuracyTimeSynch*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__RemoveStorageFpaclEntry(struct soap *soap, const struct __stra__RemoveStorageFpaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__RemoveStorageFpaclEntry(soap, &a->stra__RemoveStorageFpaclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__RemoveStorageFpaclEntry(struct soap *soap, struct __stra__RemoveStorageFpaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__RemoveStorageFpaclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__RemoveStorageFpaclEntry(struct soap *soap, const struct __stra__RemoveStorageFpaclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__RemoveStorageFpaclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__RemoveStorageFpaclEntry(struct soap *soap, const char *tag, int id, const struct __stra__RemoveStorageFpaclEntry *a, const char *type) +{ + soap_out_PointerTo_stra__RemoveStorageFpaclEntry(soap, "stra:RemoveStorageFpaclEntry", -1, &a->stra__RemoveStorageFpaclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_get___stra__RemoveStorageFpaclEntry(struct soap *soap, struct __stra__RemoveStorageFpaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__RemoveStorageFpaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_in___stra__RemoveStorageFpaclEntry(struct soap *soap, const char *tag, struct __stra__RemoveStorageFpaclEntry *a, const char *type) +{ + short soap_flag_stra__RemoveStorageFpaclEntry = 1; + a = (struct __stra__RemoveStorageFpaclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__RemoveStorageFpaclEntry, sizeof(struct __stra__RemoveStorageFpaclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__RemoveStorageFpaclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__RemoveStorageFpaclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__RemoveStorageFpaclEntry(soap, "stra:RemoveStorageFpaclEntry", &a->stra__RemoveStorageFpaclEntry, "")) + { soap_flag_stra__RemoveStorageFpaclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__RemoveStorageFpaclEntry * SOAP_FMAC6 soap_new___stra__RemoveStorageFpaclEntry(struct soap *soap, int n) +{ return soap_instantiate___stra__RemoveStorageFpaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__RemoveStorageFpaclEntry(struct soap *soap, struct __stra__RemoveStorageFpaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__RemoveStorageFpaclEntry * SOAP_FMAC4 soap_instantiate___stra__RemoveStorageFpaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__RemoveStorageFpaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__RemoveStorageFpaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__RemoveStorageFpaclEntry; + if (size) + *size = sizeof(struct __stra__RemoveStorageFpaclEntry); + } + else + { cp->ptr = (void*)new struct __stra__RemoveStorageFpaclEntry[n]; + if (size) + *size = n * sizeof(struct __stra__RemoveStorageFpaclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__RemoveStorageFpaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__RemoveStorageFpaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__RemoveStorageFpaclEntry %p -> %p\n", q, p)); + *(struct __stra__RemoveStorageFpaclEntry*)p = *(struct __stra__RemoveStorageFpaclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__UpdateStorageFpaclEntry(struct soap *soap, const struct __stra__UpdateStorageFpaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__UpdateStorageFpaclEntry(soap, &a->stra__UpdateStorageFpaclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__UpdateStorageFpaclEntry(struct soap *soap, struct __stra__UpdateStorageFpaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__UpdateStorageFpaclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__UpdateStorageFpaclEntry(struct soap *soap, const struct __stra__UpdateStorageFpaclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__UpdateStorageFpaclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__UpdateStorageFpaclEntry(struct soap *soap, const char *tag, int id, const struct __stra__UpdateStorageFpaclEntry *a, const char *type) +{ + soap_out_PointerTo_stra__UpdateStorageFpaclEntry(soap, "stra:UpdateStorageFpaclEntry", -1, &a->stra__UpdateStorageFpaclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_get___stra__UpdateStorageFpaclEntry(struct soap *soap, struct __stra__UpdateStorageFpaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__UpdateStorageFpaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_in___stra__UpdateStorageFpaclEntry(struct soap *soap, const char *tag, struct __stra__UpdateStorageFpaclEntry *a, const char *type) +{ + short soap_flag_stra__UpdateStorageFpaclEntry = 1; + a = (struct __stra__UpdateStorageFpaclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__UpdateStorageFpaclEntry, sizeof(struct __stra__UpdateStorageFpaclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__UpdateStorageFpaclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__UpdateStorageFpaclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__UpdateStorageFpaclEntry(soap, "stra:UpdateStorageFpaclEntry", &a->stra__UpdateStorageFpaclEntry, "")) + { soap_flag_stra__UpdateStorageFpaclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__UpdateStorageFpaclEntry * SOAP_FMAC6 soap_new___stra__UpdateStorageFpaclEntry(struct soap *soap, int n) +{ return soap_instantiate___stra__UpdateStorageFpaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__UpdateStorageFpaclEntry(struct soap *soap, struct __stra__UpdateStorageFpaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__UpdateStorageFpaclEntry * SOAP_FMAC4 soap_instantiate___stra__UpdateStorageFpaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__UpdateStorageFpaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__UpdateStorageFpaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__UpdateStorageFpaclEntry; + if (size) + *size = sizeof(struct __stra__UpdateStorageFpaclEntry); + } + else + { cp->ptr = (void*)new struct __stra__UpdateStorageFpaclEntry[n]; + if (size) + *size = n * sizeof(struct __stra__UpdateStorageFpaclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__UpdateStorageFpaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__UpdateStorageFpaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__UpdateStorageFpaclEntry %p -> %p\n", q, p)); + *(struct __stra__UpdateStorageFpaclEntry*)p = *(struct __stra__UpdateStorageFpaclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__GetStorageAllocEntry(struct soap *soap, const struct __stra__GetStorageAllocEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__GetStorageAllocEntry(soap, &a->stra__GetStorageAllocEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__GetStorageAllocEntry(struct soap *soap, struct __stra__GetStorageAllocEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__GetStorageAllocEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__GetStorageAllocEntry(struct soap *soap, const struct __stra__GetStorageAllocEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__GetStorageAllocEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__GetStorageAllocEntry(struct soap *soap, const char *tag, int id, const struct __stra__GetStorageAllocEntry *a, const char *type) +{ + soap_out_PointerTo_stra__GetStorageAllocEntry(soap, "stra:GetStorageAllocEntry", -1, &a->stra__GetStorageAllocEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__GetStorageAllocEntry * SOAP_FMAC4 soap_get___stra__GetStorageAllocEntry(struct soap *soap, struct __stra__GetStorageAllocEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__GetStorageAllocEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__GetStorageAllocEntry * SOAP_FMAC4 soap_in___stra__GetStorageAllocEntry(struct soap *soap, const char *tag, struct __stra__GetStorageAllocEntry *a, const char *type) +{ + short soap_flag_stra__GetStorageAllocEntry = 1; + a = (struct __stra__GetStorageAllocEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__GetStorageAllocEntry, sizeof(struct __stra__GetStorageAllocEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__GetStorageAllocEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__GetStorageAllocEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__GetStorageAllocEntry(soap, "stra:GetStorageAllocEntry", &a->stra__GetStorageAllocEntry, "")) + { soap_flag_stra__GetStorageAllocEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__GetStorageAllocEntry * SOAP_FMAC6 soap_new___stra__GetStorageAllocEntry(struct soap *soap, int n) +{ return soap_instantiate___stra__GetStorageAllocEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__GetStorageAllocEntry(struct soap *soap, struct __stra__GetStorageAllocEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__GetStorageAllocEntry * SOAP_FMAC4 soap_instantiate___stra__GetStorageAllocEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__GetStorageAllocEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__GetStorageAllocEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__GetStorageAllocEntry; + if (size) + *size = sizeof(struct __stra__GetStorageAllocEntry); + } + else + { cp->ptr = (void*)new struct __stra__GetStorageAllocEntry[n]; + if (size) + *size = n * sizeof(struct __stra__GetStorageAllocEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__GetStorageAllocEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__GetStorageAllocEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__GetStorageAllocEntry %p -> %p\n", q, p)); + *(struct __stra__GetStorageAllocEntry*)p = *(struct __stra__GetStorageAllocEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__EnumerateStorageAllocEntries(struct soap *soap, const struct __stra__EnumerateStorageAllocEntries *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__EnumerateStorageAllocEntries(soap, &a->stra__EnumerateStorageAllocEntries); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__EnumerateStorageAllocEntries(struct soap *soap, struct __stra__EnumerateStorageAllocEntries *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__EnumerateStorageAllocEntries = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__EnumerateStorageAllocEntries(struct soap *soap, const struct __stra__EnumerateStorageAllocEntries *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__EnumerateStorageAllocEntries(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__EnumerateStorageAllocEntries(struct soap *soap, const char *tag, int id, const struct __stra__EnumerateStorageAllocEntries *a, const char *type) +{ + soap_out_PointerTo_stra__EnumerateStorageAllocEntries(soap, "stra:EnumerateStorageAllocEntries", -1, &a->stra__EnumerateStorageAllocEntries, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_get___stra__EnumerateStorageAllocEntries(struct soap *soap, struct __stra__EnumerateStorageAllocEntries *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__EnumerateStorageAllocEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_in___stra__EnumerateStorageAllocEntries(struct soap *soap, const char *tag, struct __stra__EnumerateStorageAllocEntries *a, const char *type) +{ + short soap_flag_stra__EnumerateStorageAllocEntries = 1; + a = (struct __stra__EnumerateStorageAllocEntries *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__EnumerateStorageAllocEntries, sizeof(struct __stra__EnumerateStorageAllocEntries), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__EnumerateStorageAllocEntries(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__EnumerateStorageAllocEntries && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__EnumerateStorageAllocEntries(soap, "stra:EnumerateStorageAllocEntries", &a->stra__EnumerateStorageAllocEntries, "")) + { soap_flag_stra__EnumerateStorageAllocEntries--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__EnumerateStorageAllocEntries * SOAP_FMAC6 soap_new___stra__EnumerateStorageAllocEntries(struct soap *soap, int n) +{ return soap_instantiate___stra__EnumerateStorageAllocEntries(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__EnumerateStorageAllocEntries(struct soap *soap, struct __stra__EnumerateStorageAllocEntries *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__EnumerateStorageAllocEntries * SOAP_FMAC4 soap_instantiate___stra__EnumerateStorageAllocEntries(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__EnumerateStorageAllocEntries(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__EnumerateStorageAllocEntries, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__EnumerateStorageAllocEntries; + if (size) + *size = sizeof(struct __stra__EnumerateStorageAllocEntries); + } + else + { cp->ptr = (void*)new struct __stra__EnumerateStorageAllocEntries[n]; + if (size) + *size = n * sizeof(struct __stra__EnumerateStorageAllocEntries); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__EnumerateStorageAllocEntries*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__EnumerateStorageAllocEntries(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__EnumerateStorageAllocEntries %p -> %p\n", q, p)); + *(struct __stra__EnumerateStorageAllocEntries*)p = *(struct __stra__EnumerateStorageAllocEntries*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AddStorageFpaclEntry(struct soap *soap, const struct __stra__AddStorageFpaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__AddStorageFpaclEntry(soap, &a->stra__AddStorageFpaclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AddStorageFpaclEntry(struct soap *soap, struct __stra__AddStorageFpaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__AddStorageFpaclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AddStorageFpaclEntry(struct soap *soap, const struct __stra__AddStorageFpaclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__AddStorageFpaclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AddStorageFpaclEntry(struct soap *soap, const char *tag, int id, const struct __stra__AddStorageFpaclEntry *a, const char *type) +{ + soap_out_PointerTo_stra__AddStorageFpaclEntry(soap, "stra:AddStorageFpaclEntry", -1, &a->stra__AddStorageFpaclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_get___stra__AddStorageFpaclEntry(struct soap *soap, struct __stra__AddStorageFpaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__AddStorageFpaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_in___stra__AddStorageFpaclEntry(struct soap *soap, const char *tag, struct __stra__AddStorageFpaclEntry *a, const char *type) +{ + short soap_flag_stra__AddStorageFpaclEntry = 1; + a = (struct __stra__AddStorageFpaclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__AddStorageFpaclEntry, sizeof(struct __stra__AddStorageFpaclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__AddStorageFpaclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__AddStorageFpaclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__AddStorageFpaclEntry(soap, "stra:AddStorageFpaclEntry", &a->stra__AddStorageFpaclEntry, "")) + { soap_flag_stra__AddStorageFpaclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__AddStorageFpaclEntry * SOAP_FMAC6 soap_new___stra__AddStorageFpaclEntry(struct soap *soap, int n) +{ return soap_instantiate___stra__AddStorageFpaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AddStorageFpaclEntry(struct soap *soap, struct __stra__AddStorageFpaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__AddStorageFpaclEntry * SOAP_FMAC4 soap_instantiate___stra__AddStorageFpaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__AddStorageFpaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__AddStorageFpaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__AddStorageFpaclEntry; + if (size) + *size = sizeof(struct __stra__AddStorageFpaclEntry); + } + else + { cp->ptr = (void*)new struct __stra__AddStorageFpaclEntry[n]; + if (size) + *size = n * sizeof(struct __stra__AddStorageFpaclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__AddStorageFpaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AddStorageFpaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__AddStorageFpaclEntry %p -> %p\n", q, p)); + *(struct __stra__AddStorageFpaclEntry*)p = *(struct __stra__AddStorageFpaclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__RemoveStorageEaclEntry(struct soap *soap, const struct __stra__RemoveStorageEaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__RemoveStorageEaclEntry(soap, &a->stra__RemoveStorageEaclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__RemoveStorageEaclEntry(struct soap *soap, struct __stra__RemoveStorageEaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__RemoveStorageEaclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__RemoveStorageEaclEntry(struct soap *soap, const struct __stra__RemoveStorageEaclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__RemoveStorageEaclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__RemoveStorageEaclEntry(struct soap *soap, const char *tag, int id, const struct __stra__RemoveStorageEaclEntry *a, const char *type) +{ + soap_out_PointerTo_stra__RemoveStorageEaclEntry(soap, "stra:RemoveStorageEaclEntry", -1, &a->stra__RemoveStorageEaclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_get___stra__RemoveStorageEaclEntry(struct soap *soap, struct __stra__RemoveStorageEaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__RemoveStorageEaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_in___stra__RemoveStorageEaclEntry(struct soap *soap, const char *tag, struct __stra__RemoveStorageEaclEntry *a, const char *type) +{ + short soap_flag_stra__RemoveStorageEaclEntry = 1; + a = (struct __stra__RemoveStorageEaclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__RemoveStorageEaclEntry, sizeof(struct __stra__RemoveStorageEaclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__RemoveStorageEaclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__RemoveStorageEaclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__RemoveStorageEaclEntry(soap, "stra:RemoveStorageEaclEntry", &a->stra__RemoveStorageEaclEntry, "")) + { soap_flag_stra__RemoveStorageEaclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__RemoveStorageEaclEntry * SOAP_FMAC6 soap_new___stra__RemoveStorageEaclEntry(struct soap *soap, int n) +{ return soap_instantiate___stra__RemoveStorageEaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__RemoveStorageEaclEntry(struct soap *soap, struct __stra__RemoveStorageEaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__RemoveStorageEaclEntry * SOAP_FMAC4 soap_instantiate___stra__RemoveStorageEaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__RemoveStorageEaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__RemoveStorageEaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__RemoveStorageEaclEntry; + if (size) + *size = sizeof(struct __stra__RemoveStorageEaclEntry); + } + else + { cp->ptr = (void*)new struct __stra__RemoveStorageEaclEntry[n]; + if (size) + *size = n * sizeof(struct __stra__RemoveStorageEaclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__RemoveStorageEaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__RemoveStorageEaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__RemoveStorageEaclEntry %p -> %p\n", q, p)); + *(struct __stra__RemoveStorageEaclEntry*)p = *(struct __stra__RemoveStorageEaclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__GetStorageEaclEntry(struct soap *soap, const struct __stra__GetStorageEaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__GetStorageEaclEntry(soap, &a->stra__GetStorageEaclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__GetStorageEaclEntry(struct soap *soap, struct __stra__GetStorageEaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__GetStorageEaclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__GetStorageEaclEntry(struct soap *soap, const struct __stra__GetStorageEaclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__GetStorageEaclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__GetStorageEaclEntry(struct soap *soap, const char *tag, int id, const struct __stra__GetStorageEaclEntry *a, const char *type) +{ + soap_out_PointerTo_stra__GetStorageEaclEntry(soap, "stra:GetStorageEaclEntry", -1, &a->stra__GetStorageEaclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__GetStorageEaclEntry * SOAP_FMAC4 soap_get___stra__GetStorageEaclEntry(struct soap *soap, struct __stra__GetStorageEaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__GetStorageEaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__GetStorageEaclEntry * SOAP_FMAC4 soap_in___stra__GetStorageEaclEntry(struct soap *soap, const char *tag, struct __stra__GetStorageEaclEntry *a, const char *type) +{ + short soap_flag_stra__GetStorageEaclEntry = 1; + a = (struct __stra__GetStorageEaclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__GetStorageEaclEntry, sizeof(struct __stra__GetStorageEaclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__GetStorageEaclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__GetStorageEaclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__GetStorageEaclEntry(soap, "stra:GetStorageEaclEntry", &a->stra__GetStorageEaclEntry, "")) + { soap_flag_stra__GetStorageEaclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__GetStorageEaclEntry * SOAP_FMAC6 soap_new___stra__GetStorageEaclEntry(struct soap *soap, int n) +{ return soap_instantiate___stra__GetStorageEaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__GetStorageEaclEntry(struct soap *soap, struct __stra__GetStorageEaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__GetStorageEaclEntry * SOAP_FMAC4 soap_instantiate___stra__GetStorageEaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__GetStorageEaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__GetStorageEaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__GetStorageEaclEntry; + if (size) + *size = sizeof(struct __stra__GetStorageEaclEntry); + } + else + { cp->ptr = (void*)new struct __stra__GetStorageEaclEntry[n]; + if (size) + *size = n * sizeof(struct __stra__GetStorageEaclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__GetStorageEaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__GetStorageEaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__GetStorageEaclEntry %p -> %p\n", q, p)); + *(struct __stra__GetStorageEaclEntry*)p = *(struct __stra__GetStorageEaclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__EnumerateStorageEaclEntries(struct soap *soap, const struct __stra__EnumerateStorageEaclEntries *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__EnumerateStorageEaclEntries(soap, &a->stra__EnumerateStorageEaclEntries); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__EnumerateStorageEaclEntries(struct soap *soap, struct __stra__EnumerateStorageEaclEntries *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__EnumerateStorageEaclEntries = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__EnumerateStorageEaclEntries(struct soap *soap, const struct __stra__EnumerateStorageEaclEntries *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__EnumerateStorageEaclEntries(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__EnumerateStorageEaclEntries(struct soap *soap, const char *tag, int id, const struct __stra__EnumerateStorageEaclEntries *a, const char *type) +{ + soap_out_PointerTo_stra__EnumerateStorageEaclEntries(soap, "stra:EnumerateStorageEaclEntries", -1, &a->stra__EnumerateStorageEaclEntries, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_get___stra__EnumerateStorageEaclEntries(struct soap *soap, struct __stra__EnumerateStorageEaclEntries *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__EnumerateStorageEaclEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_in___stra__EnumerateStorageEaclEntries(struct soap *soap, const char *tag, struct __stra__EnumerateStorageEaclEntries *a, const char *type) +{ + short soap_flag_stra__EnumerateStorageEaclEntries = 1; + a = (struct __stra__EnumerateStorageEaclEntries *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__EnumerateStorageEaclEntries, sizeof(struct __stra__EnumerateStorageEaclEntries), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__EnumerateStorageEaclEntries(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__EnumerateStorageEaclEntries && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__EnumerateStorageEaclEntries(soap, "stra:EnumerateStorageEaclEntries", &a->stra__EnumerateStorageEaclEntries, "")) + { soap_flag_stra__EnumerateStorageEaclEntries--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__EnumerateStorageEaclEntries * SOAP_FMAC6 soap_new___stra__EnumerateStorageEaclEntries(struct soap *soap, int n) +{ return soap_instantiate___stra__EnumerateStorageEaclEntries(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__EnumerateStorageEaclEntries(struct soap *soap, struct __stra__EnumerateStorageEaclEntries *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__EnumerateStorageEaclEntries * SOAP_FMAC4 soap_instantiate___stra__EnumerateStorageEaclEntries(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__EnumerateStorageEaclEntries(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__EnumerateStorageEaclEntries, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__EnumerateStorageEaclEntries; + if (size) + *size = sizeof(struct __stra__EnumerateStorageEaclEntries); + } + else + { cp->ptr = (void*)new struct __stra__EnumerateStorageEaclEntries[n]; + if (size) + *size = n * sizeof(struct __stra__EnumerateStorageEaclEntries); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__EnumerateStorageEaclEntries*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__EnumerateStorageEaclEntries(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__EnumerateStorageEaclEntries %p -> %p\n", q, p)); + *(struct __stra__EnumerateStorageEaclEntries*)p = *(struct __stra__EnumerateStorageEaclEntries*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AddStorageEaclEntry(struct soap *soap, const struct __stra__AddStorageEaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__AddStorageEaclEntry(soap, &a->stra__AddStorageEaclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AddStorageEaclEntry(struct soap *soap, struct __stra__AddStorageEaclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__AddStorageEaclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AddStorageEaclEntry(struct soap *soap, const struct __stra__AddStorageEaclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__AddStorageEaclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AddStorageEaclEntry(struct soap *soap, const char *tag, int id, const struct __stra__AddStorageEaclEntry *a, const char *type) +{ + soap_out_PointerTo_stra__AddStorageEaclEntry(soap, "stra:AddStorageEaclEntry", -1, &a->stra__AddStorageEaclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__AddStorageEaclEntry * SOAP_FMAC4 soap_get___stra__AddStorageEaclEntry(struct soap *soap, struct __stra__AddStorageEaclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__AddStorageEaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__AddStorageEaclEntry * SOAP_FMAC4 soap_in___stra__AddStorageEaclEntry(struct soap *soap, const char *tag, struct __stra__AddStorageEaclEntry *a, const char *type) +{ + short soap_flag_stra__AddStorageEaclEntry = 1; + a = (struct __stra__AddStorageEaclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__AddStorageEaclEntry, sizeof(struct __stra__AddStorageEaclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__AddStorageEaclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__AddStorageEaclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__AddStorageEaclEntry(soap, "stra:AddStorageEaclEntry", &a->stra__AddStorageEaclEntry, "")) + { soap_flag_stra__AddStorageEaclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__AddStorageEaclEntry * SOAP_FMAC6 soap_new___stra__AddStorageEaclEntry(struct soap *soap, int n) +{ return soap_instantiate___stra__AddStorageEaclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AddStorageEaclEntry(struct soap *soap, struct __stra__AddStorageEaclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__AddStorageEaclEntry * SOAP_FMAC4 soap_instantiate___stra__AddStorageEaclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__AddStorageEaclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__AddStorageEaclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__AddStorageEaclEntry; + if (size) + *size = sizeof(struct __stra__AddStorageEaclEntry); + } + else + { cp->ptr = (void*)new struct __stra__AddStorageEaclEntry[n]; + if (size) + *size = n * sizeof(struct __stra__AddStorageEaclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__AddStorageEaclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AddStorageEaclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__AddStorageEaclEntry %p -> %p\n", q, p)); + *(struct __stra__AddStorageEaclEntry*)p = *(struct __stra__AddStorageEaclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AdminRemoveApplication(struct soap *soap, const struct __stra__AdminRemoveApplication *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__AdminRemoveApplication(soap, &a->stra__AdminRemoveApplication); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AdminRemoveApplication(struct soap *soap, struct __stra__AdminRemoveApplication *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__AdminRemoveApplication = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AdminRemoveApplication(struct soap *soap, const struct __stra__AdminRemoveApplication *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__AdminRemoveApplication(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AdminRemoveApplication(struct soap *soap, const char *tag, int id, const struct __stra__AdminRemoveApplication *a, const char *type) +{ + soap_out_PointerTo_stra__AdminRemoveApplication(soap, "stra:AdminRemoveApplication", -1, &a->stra__AdminRemoveApplication, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__AdminRemoveApplication * SOAP_FMAC4 soap_get___stra__AdminRemoveApplication(struct soap *soap, struct __stra__AdminRemoveApplication *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__AdminRemoveApplication(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__AdminRemoveApplication * SOAP_FMAC4 soap_in___stra__AdminRemoveApplication(struct soap *soap, const char *tag, struct __stra__AdminRemoveApplication *a, const char *type) +{ + short soap_flag_stra__AdminRemoveApplication = 1; + a = (struct __stra__AdminRemoveApplication *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__AdminRemoveApplication, sizeof(struct __stra__AdminRemoveApplication), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__AdminRemoveApplication(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__AdminRemoveApplication && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__AdminRemoveApplication(soap, "stra:AdminRemoveApplication", &a->stra__AdminRemoveApplication, "")) + { soap_flag_stra__AdminRemoveApplication--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__AdminRemoveApplication * SOAP_FMAC6 soap_new___stra__AdminRemoveApplication(struct soap *soap, int n) +{ return soap_instantiate___stra__AdminRemoveApplication(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AdminRemoveApplication(struct soap *soap, struct __stra__AdminRemoveApplication *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__AdminRemoveApplication * SOAP_FMAC4 soap_instantiate___stra__AdminRemoveApplication(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__AdminRemoveApplication(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__AdminRemoveApplication, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__AdminRemoveApplication; + if (size) + *size = sizeof(struct __stra__AdminRemoveApplication); + } + else + { cp->ptr = (void*)new struct __stra__AdminRemoveApplication[n]; + if (size) + *size = n * sizeof(struct __stra__AdminRemoveApplication); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__AdminRemoveApplication*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AdminRemoveApplication(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__AdminRemoveApplication %p -> %p\n", q, p)); + *(struct __stra__AdminRemoveApplication*)p = *(struct __stra__AdminRemoveApplication*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AdminGetApplicationAttributes(struct soap *soap, const struct __stra__AdminGetApplicationAttributes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__AdminGetApplicationAttributes(soap, &a->stra__AdminGetApplicationAttributes); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AdminGetApplicationAttributes(struct soap *soap, struct __stra__AdminGetApplicationAttributes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__AdminGetApplicationAttributes = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AdminGetApplicationAttributes(struct soap *soap, const struct __stra__AdminGetApplicationAttributes *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__AdminGetApplicationAttributes(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AdminGetApplicationAttributes(struct soap *soap, const char *tag, int id, const struct __stra__AdminGetApplicationAttributes *a, const char *type) +{ + soap_out_PointerTo_stra__AdminGetApplicationAttributes(soap, "stra:AdminGetApplicationAttributes", -1, &a->stra__AdminGetApplicationAttributes, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_get___stra__AdminGetApplicationAttributes(struct soap *soap, struct __stra__AdminGetApplicationAttributes *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__AdminGetApplicationAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_in___stra__AdminGetApplicationAttributes(struct soap *soap, const char *tag, struct __stra__AdminGetApplicationAttributes *a, const char *type) +{ + short soap_flag_stra__AdminGetApplicationAttributes = 1; + a = (struct __stra__AdminGetApplicationAttributes *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__AdminGetApplicationAttributes, sizeof(struct __stra__AdminGetApplicationAttributes), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__AdminGetApplicationAttributes(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__AdminGetApplicationAttributes && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__AdminGetApplicationAttributes(soap, "stra:AdminGetApplicationAttributes", &a->stra__AdminGetApplicationAttributes, "")) + { soap_flag_stra__AdminGetApplicationAttributes--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__AdminGetApplicationAttributes * SOAP_FMAC6 soap_new___stra__AdminGetApplicationAttributes(struct soap *soap, int n) +{ return soap_instantiate___stra__AdminGetApplicationAttributes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AdminGetApplicationAttributes(struct soap *soap, struct __stra__AdminGetApplicationAttributes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__AdminGetApplicationAttributes * SOAP_FMAC4 soap_instantiate___stra__AdminGetApplicationAttributes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__AdminGetApplicationAttributes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__AdminGetApplicationAttributes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__AdminGetApplicationAttributes; + if (size) + *size = sizeof(struct __stra__AdminGetApplicationAttributes); + } + else + { cp->ptr = (void*)new struct __stra__AdminGetApplicationAttributes[n]; + if (size) + *size = n * sizeof(struct __stra__AdminGetApplicationAttributes); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__AdminGetApplicationAttributes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AdminGetApplicationAttributes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__AdminGetApplicationAttributes %p -> %p\n", q, p)); + *(struct __stra__AdminGetApplicationAttributes*)p = *(struct __stra__AdminGetApplicationAttributes*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__AdminGetRegisteredApplications(struct soap *soap, const struct __stra__AdminGetRegisteredApplications *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__AdminGetRegisteredApplications(soap, &a->stra__AdminGetRegisteredApplications); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__AdminGetRegisteredApplications(struct soap *soap, struct __stra__AdminGetRegisteredApplications *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__AdminGetRegisteredApplications = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__AdminGetRegisteredApplications(struct soap *soap, const struct __stra__AdminGetRegisteredApplications *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__AdminGetRegisteredApplications(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__AdminGetRegisteredApplications(struct soap *soap, const char *tag, int id, const struct __stra__AdminGetRegisteredApplications *a, const char *type) +{ + soap_out_PointerTo_stra__AdminGetRegisteredApplications(soap, "stra:AdminGetRegisteredApplications", -1, &a->stra__AdminGetRegisteredApplications, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_get___stra__AdminGetRegisteredApplications(struct soap *soap, struct __stra__AdminGetRegisteredApplications *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__AdminGetRegisteredApplications(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_in___stra__AdminGetRegisteredApplications(struct soap *soap, const char *tag, struct __stra__AdminGetRegisteredApplications *a, const char *type) +{ + short soap_flag_stra__AdminGetRegisteredApplications = 1; + a = (struct __stra__AdminGetRegisteredApplications *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__AdminGetRegisteredApplications, sizeof(struct __stra__AdminGetRegisteredApplications), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__AdminGetRegisteredApplications(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__AdminGetRegisteredApplications && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__AdminGetRegisteredApplications(soap, "stra:AdminGetRegisteredApplications", &a->stra__AdminGetRegisteredApplications, "")) + { soap_flag_stra__AdminGetRegisteredApplications--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__AdminGetRegisteredApplications * SOAP_FMAC6 soap_new___stra__AdminGetRegisteredApplications(struct soap *soap, int n) +{ return soap_instantiate___stra__AdminGetRegisteredApplications(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__AdminGetRegisteredApplications(struct soap *soap, struct __stra__AdminGetRegisteredApplications *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__AdminGetRegisteredApplications * SOAP_FMAC4 soap_instantiate___stra__AdminGetRegisteredApplications(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__AdminGetRegisteredApplications(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__AdminGetRegisteredApplications, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__AdminGetRegisteredApplications; + if (size) + *size = sizeof(struct __stra__AdminGetRegisteredApplications); + } + else + { cp->ptr = (void*)new struct __stra__AdminGetRegisteredApplications[n]; + if (size) + *size = n * sizeof(struct __stra__AdminGetRegisteredApplications); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__AdminGetRegisteredApplications*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__AdminGetRegisteredApplications(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__AdminGetRegisteredApplications %p -> %p\n", q, p)); + *(struct __stra__AdminGetRegisteredApplications*)p = *(struct __stra__AdminGetRegisteredApplications*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__SetGlobalStorageAttributes(struct soap *soap, const struct __stra__SetGlobalStorageAttributes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__SetGlobalStorageAttributes(soap, &a->stra__SetGlobalStorageAttributes); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__SetGlobalStorageAttributes(struct soap *soap, struct __stra__SetGlobalStorageAttributes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__SetGlobalStorageAttributes = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__SetGlobalStorageAttributes(struct soap *soap, const struct __stra__SetGlobalStorageAttributes *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__SetGlobalStorageAttributes(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__SetGlobalStorageAttributes(struct soap *soap, const char *tag, int id, const struct __stra__SetGlobalStorageAttributes *a, const char *type) +{ + soap_out_PointerTo_stra__SetGlobalStorageAttributes(soap, "stra:SetGlobalStorageAttributes", -1, &a->stra__SetGlobalStorageAttributes, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_get___stra__SetGlobalStorageAttributes(struct soap *soap, struct __stra__SetGlobalStorageAttributes *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__SetGlobalStorageAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_in___stra__SetGlobalStorageAttributes(struct soap *soap, const char *tag, struct __stra__SetGlobalStorageAttributes *a, const char *type) +{ + short soap_flag_stra__SetGlobalStorageAttributes = 1; + a = (struct __stra__SetGlobalStorageAttributes *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__SetGlobalStorageAttributes, sizeof(struct __stra__SetGlobalStorageAttributes), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__SetGlobalStorageAttributes(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__SetGlobalStorageAttributes && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__SetGlobalStorageAttributes(soap, "stra:SetGlobalStorageAttributes", &a->stra__SetGlobalStorageAttributes, "")) + { soap_flag_stra__SetGlobalStorageAttributes--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__SetGlobalStorageAttributes * SOAP_FMAC6 soap_new___stra__SetGlobalStorageAttributes(struct soap *soap, int n) +{ return soap_instantiate___stra__SetGlobalStorageAttributes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__SetGlobalStorageAttributes(struct soap *soap, struct __stra__SetGlobalStorageAttributes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__SetGlobalStorageAttributes * SOAP_FMAC4 soap_instantiate___stra__SetGlobalStorageAttributes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__SetGlobalStorageAttributes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__SetGlobalStorageAttributes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__SetGlobalStorageAttributes; + if (size) + *size = sizeof(struct __stra__SetGlobalStorageAttributes); + } + else + { cp->ptr = (void*)new struct __stra__SetGlobalStorageAttributes[n]; + if (size) + *size = n * sizeof(struct __stra__SetGlobalStorageAttributes); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__SetGlobalStorageAttributes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__SetGlobalStorageAttributes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__SetGlobalStorageAttributes %p -> %p\n", q, p)); + *(struct __stra__SetGlobalStorageAttributes*)p = *(struct __stra__SetGlobalStorageAttributes*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___stra__GetGlobalStorageAttributes(struct soap *soap, const struct __stra__GetGlobalStorageAttributes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_stra__GetGlobalStorageAttributes(soap, &a->stra__GetGlobalStorageAttributes); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___stra__GetGlobalStorageAttributes(struct soap *soap, struct __stra__GetGlobalStorageAttributes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->stra__GetGlobalStorageAttributes = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___stra__GetGlobalStorageAttributes(struct soap *soap, const struct __stra__GetGlobalStorageAttributes *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___stra__GetGlobalStorageAttributes(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___stra__GetGlobalStorageAttributes(struct soap *soap, const char *tag, int id, const struct __stra__GetGlobalStorageAttributes *a, const char *type) +{ + soap_out_PointerTo_stra__GetGlobalStorageAttributes(soap, "stra:GetGlobalStorageAttributes", -1, &a->stra__GetGlobalStorageAttributes, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_get___stra__GetGlobalStorageAttributes(struct soap *soap, struct __stra__GetGlobalStorageAttributes *p, const char *tag, const char *type) +{ + if ((p = soap_in___stra__GetGlobalStorageAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_in___stra__GetGlobalStorageAttributes(struct soap *soap, const char *tag, struct __stra__GetGlobalStorageAttributes *a, const char *type) +{ + short soap_flag_stra__GetGlobalStorageAttributes = 1; + a = (struct __stra__GetGlobalStorageAttributes *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___stra__GetGlobalStorageAttributes, sizeof(struct __stra__GetGlobalStorageAttributes), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___stra__GetGlobalStorageAttributes(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_stra__GetGlobalStorageAttributes && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_stra__GetGlobalStorageAttributes(soap, "stra:GetGlobalStorageAttributes", &a->stra__GetGlobalStorageAttributes, "")) + { soap_flag_stra__GetGlobalStorageAttributes--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __stra__GetGlobalStorageAttributes * SOAP_FMAC6 soap_new___stra__GetGlobalStorageAttributes(struct soap *soap, int n) +{ return soap_instantiate___stra__GetGlobalStorageAttributes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___stra__GetGlobalStorageAttributes(struct soap *soap, struct __stra__GetGlobalStorageAttributes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __stra__GetGlobalStorageAttributes * SOAP_FMAC4 soap_instantiate___stra__GetGlobalStorageAttributes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___stra__GetGlobalStorageAttributes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___stra__GetGlobalStorageAttributes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __stra__GetGlobalStorageAttributes; + if (size) + *size = sizeof(struct __stra__GetGlobalStorageAttributes); + } + else + { cp->ptr = (void*)new struct __stra__GetGlobalStorageAttributes[n]; + if (size) + *size = n * sizeof(struct __stra__GetGlobalStorageAttributes); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __stra__GetGlobalStorageAttributes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___stra__GetGlobalStorageAttributes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __stra__GetGlobalStorageAttributes %p -> %p\n", q, p)); + *(struct __stra__GetGlobalStorageAttributes*)p = *(struct __stra__GetGlobalStorageAttributes*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___str__ExecuteStorageOperation(struct soap *soap, const struct __str__ExecuteStorageOperation *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_str__ExecuteStorageOperation(soap, &a->str__ExecuteStorageOperation); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___str__ExecuteStorageOperation(struct soap *soap, struct __str__ExecuteStorageOperation *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->str__ExecuteStorageOperation = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___str__ExecuteStorageOperation(struct soap *soap, const struct __str__ExecuteStorageOperation *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___str__ExecuteStorageOperation(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___str__ExecuteStorageOperation(struct soap *soap, const char *tag, int id, const struct __str__ExecuteStorageOperation *a, const char *type) +{ + soap_out_PointerTo_str__ExecuteStorageOperation(soap, "str:ExecuteStorageOperation", -1, &a->str__ExecuteStorageOperation, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __str__ExecuteStorageOperation * SOAP_FMAC4 soap_get___str__ExecuteStorageOperation(struct soap *soap, struct __str__ExecuteStorageOperation *p, const char *tag, const char *type) +{ + if ((p = soap_in___str__ExecuteStorageOperation(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __str__ExecuteStorageOperation * SOAP_FMAC4 soap_in___str__ExecuteStorageOperation(struct soap *soap, const char *tag, struct __str__ExecuteStorageOperation *a, const char *type) +{ + short soap_flag_str__ExecuteStorageOperation = 1; + a = (struct __str__ExecuteStorageOperation *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___str__ExecuteStorageOperation, sizeof(struct __str__ExecuteStorageOperation), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___str__ExecuteStorageOperation(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_str__ExecuteStorageOperation && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_str__ExecuteStorageOperation(soap, "str:ExecuteStorageOperation", &a->str__ExecuteStorageOperation, "")) + { soap_flag_str__ExecuteStorageOperation--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __str__ExecuteStorageOperation * SOAP_FMAC6 soap_new___str__ExecuteStorageOperation(struct soap *soap, int n) +{ return soap_instantiate___str__ExecuteStorageOperation(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___str__ExecuteStorageOperation(struct soap *soap, struct __str__ExecuteStorageOperation *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __str__ExecuteStorageOperation * SOAP_FMAC4 soap_instantiate___str__ExecuteStorageOperation(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___str__ExecuteStorageOperation(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___str__ExecuteStorageOperation, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __str__ExecuteStorageOperation; + if (size) + *size = sizeof(struct __str__ExecuteStorageOperation); + } + else + { cp->ptr = (void*)new struct __str__ExecuteStorageOperation[n]; + if (size) + *size = n * sizeof(struct __str__ExecuteStorageOperation); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __str__ExecuteStorageOperation*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___str__ExecuteStorageOperation(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __str__ExecuteStorageOperation %p -> %p\n", q, p)); + *(struct __str__ExecuteStorageOperation*)p = *(struct __str__ExecuteStorageOperation*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetAclEnabledState(struct soap *soap, const struct __sai__GetAclEnabledState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetAclEnabledState(soap, &a->sai__GetAclEnabledState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetAclEnabledState(struct soap *soap, struct __sai__GetAclEnabledState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetAclEnabledState = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetAclEnabledState(struct soap *soap, const struct __sai__GetAclEnabledState *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetAclEnabledState(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetAclEnabledState(struct soap *soap, const char *tag, int id, const struct __sai__GetAclEnabledState *a, const char *type) +{ + soap_out_PointerTo_sai__GetAclEnabledState(soap, "sai:GetAclEnabledState", -1, &a->sai__GetAclEnabledState, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetAclEnabledState * SOAP_FMAC4 soap_get___sai__GetAclEnabledState(struct soap *soap, struct __sai__GetAclEnabledState *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetAclEnabledState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetAclEnabledState * SOAP_FMAC4 soap_in___sai__GetAclEnabledState(struct soap *soap, const char *tag, struct __sai__GetAclEnabledState *a, const char *type) +{ + short soap_flag_sai__GetAclEnabledState = 1; + a = (struct __sai__GetAclEnabledState *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetAclEnabledState, sizeof(struct __sai__GetAclEnabledState), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetAclEnabledState(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetAclEnabledState && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetAclEnabledState(soap, "sai:GetAclEnabledState", &a->sai__GetAclEnabledState, "")) + { soap_flag_sai__GetAclEnabledState--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetAclEnabledState * SOAP_FMAC6 soap_new___sai__GetAclEnabledState(struct soap *soap, int n) +{ return soap_instantiate___sai__GetAclEnabledState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetAclEnabledState(struct soap *soap, struct __sai__GetAclEnabledState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetAclEnabledState * SOAP_FMAC4 soap_instantiate___sai__GetAclEnabledState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetAclEnabledState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetAclEnabledState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetAclEnabledState; + if (size) + *size = sizeof(struct __sai__GetAclEnabledState); + } + else + { cp->ptr = (void*)new struct __sai__GetAclEnabledState[n]; + if (size) + *size = n * sizeof(struct __sai__GetAclEnabledState); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetAclEnabledState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetAclEnabledState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetAclEnabledState %p -> %p\n", q, p)); + *(struct __sai__GetAclEnabledState*)p = *(struct __sai__GetAclEnabledState*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetAclEnabledState(struct soap *soap, const struct __sai__SetAclEnabledState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetAclEnabledState(soap, &a->sai__SetAclEnabledState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetAclEnabledState(struct soap *soap, struct __sai__SetAclEnabledState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetAclEnabledState = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetAclEnabledState(struct soap *soap, const struct __sai__SetAclEnabledState *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetAclEnabledState(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetAclEnabledState(struct soap *soap, const char *tag, int id, const struct __sai__SetAclEnabledState *a, const char *type) +{ + soap_out_PointerTo_sai__SetAclEnabledState(soap, "sai:SetAclEnabledState", -1, &a->sai__SetAclEnabledState, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetAclEnabledState * SOAP_FMAC4 soap_get___sai__SetAclEnabledState(struct soap *soap, struct __sai__SetAclEnabledState *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetAclEnabledState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetAclEnabledState * SOAP_FMAC4 soap_in___sai__SetAclEnabledState(struct soap *soap, const char *tag, struct __sai__SetAclEnabledState *a, const char *type) +{ + short soap_flag_sai__SetAclEnabledState = 1; + a = (struct __sai__SetAclEnabledState *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetAclEnabledState, sizeof(struct __sai__SetAclEnabledState), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetAclEnabledState(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetAclEnabledState && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetAclEnabledState(soap, "sai:SetAclEnabledState", &a->sai__SetAclEnabledState, "")) + { soap_flag_sai__SetAclEnabledState--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetAclEnabledState * SOAP_FMAC6 soap_new___sai__SetAclEnabledState(struct soap *soap, int n) +{ return soap_instantiate___sai__SetAclEnabledState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetAclEnabledState(struct soap *soap, struct __sai__SetAclEnabledState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetAclEnabledState * SOAP_FMAC4 soap_instantiate___sai__SetAclEnabledState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetAclEnabledState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetAclEnabledState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetAclEnabledState; + if (size) + *size = sizeof(struct __sai__SetAclEnabledState); + } + else + { cp->ptr = (void*)new struct __sai__SetAclEnabledState[n]; + if (size) + *size = n * sizeof(struct __sai__SetAclEnabledState); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetAclEnabledState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetAclEnabledState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetAclEnabledState %p -> %p\n", q, p)); + *(struct __sai__SetAclEnabledState*)p = *(struct __sai__SetAclEnabledState*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetConfigurationServerFQDN(struct soap *soap, const struct __sai__SetConfigurationServerFQDN *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetConfigurationServerFQDN(soap, &a->sai__SetConfigurationServerFQDN); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetConfigurationServerFQDN(struct soap *soap, struct __sai__SetConfigurationServerFQDN *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetConfigurationServerFQDN = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetConfigurationServerFQDN(struct soap *soap, const struct __sai__SetConfigurationServerFQDN *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetConfigurationServerFQDN(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetConfigurationServerFQDN(struct soap *soap, const char *tag, int id, const struct __sai__SetConfigurationServerFQDN *a, const char *type) +{ + soap_out_PointerTo_sai__SetConfigurationServerFQDN(soap, "sai:SetConfigurationServerFQDN", -1, &a->sai__SetConfigurationServerFQDN, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_get___sai__SetConfigurationServerFQDN(struct soap *soap, struct __sai__SetConfigurationServerFQDN *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetConfigurationServerFQDN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_in___sai__SetConfigurationServerFQDN(struct soap *soap, const char *tag, struct __sai__SetConfigurationServerFQDN *a, const char *type) +{ + short soap_flag_sai__SetConfigurationServerFQDN = 1; + a = (struct __sai__SetConfigurationServerFQDN *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetConfigurationServerFQDN, sizeof(struct __sai__SetConfigurationServerFQDN), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetConfigurationServerFQDN(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetConfigurationServerFQDN && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetConfigurationServerFQDN(soap, "sai:SetConfigurationServerFQDN", &a->sai__SetConfigurationServerFQDN, "")) + { soap_flag_sai__SetConfigurationServerFQDN--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetConfigurationServerFQDN * SOAP_FMAC6 soap_new___sai__SetConfigurationServerFQDN(struct soap *soap, int n) +{ return soap_instantiate___sai__SetConfigurationServerFQDN(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetConfigurationServerFQDN(struct soap *soap, struct __sai__SetConfigurationServerFQDN *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetConfigurationServerFQDN * SOAP_FMAC4 soap_instantiate___sai__SetConfigurationServerFQDN(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetConfigurationServerFQDN(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetConfigurationServerFQDN, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetConfigurationServerFQDN; + if (size) + *size = sizeof(struct __sai__SetConfigurationServerFQDN); + } + else + { cp->ptr = (void*)new struct __sai__SetConfigurationServerFQDN[n]; + if (size) + *size = n * sizeof(struct __sai__SetConfigurationServerFQDN); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetConfigurationServerFQDN*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetConfigurationServerFQDN(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetConfigurationServerFQDN %p -> %p\n", q, p)); + *(struct __sai__SetConfigurationServerFQDN*)p = *(struct __sai__SetConfigurationServerFQDN*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetConfigurationServerFQDN(struct soap *soap, const struct __sai__GetConfigurationServerFQDN *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetConfigurationServerFQDN(soap, &a->sai__GetConfigurationServerFQDN); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetConfigurationServerFQDN(struct soap *soap, struct __sai__GetConfigurationServerFQDN *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetConfigurationServerFQDN = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetConfigurationServerFQDN(struct soap *soap, const struct __sai__GetConfigurationServerFQDN *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetConfigurationServerFQDN(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetConfigurationServerFQDN(struct soap *soap, const char *tag, int id, const struct __sai__GetConfigurationServerFQDN *a, const char *type) +{ + soap_out_PointerTo_sai__GetConfigurationServerFQDN(soap, "sai:GetConfigurationServerFQDN", -1, &a->sai__GetConfigurationServerFQDN, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_get___sai__GetConfigurationServerFQDN(struct soap *soap, struct __sai__GetConfigurationServerFQDN *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetConfigurationServerFQDN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_in___sai__GetConfigurationServerFQDN(struct soap *soap, const char *tag, struct __sai__GetConfigurationServerFQDN *a, const char *type) +{ + short soap_flag_sai__GetConfigurationServerFQDN = 1; + a = (struct __sai__GetConfigurationServerFQDN *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetConfigurationServerFQDN, sizeof(struct __sai__GetConfigurationServerFQDN), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetConfigurationServerFQDN(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetConfigurationServerFQDN && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetConfigurationServerFQDN(soap, "sai:GetConfigurationServerFQDN", &a->sai__GetConfigurationServerFQDN, "")) + { soap_flag_sai__GetConfigurationServerFQDN--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetConfigurationServerFQDN * SOAP_FMAC6 soap_new___sai__GetConfigurationServerFQDN(struct soap *soap, int n) +{ return soap_instantiate___sai__GetConfigurationServerFQDN(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetConfigurationServerFQDN(struct soap *soap, struct __sai__GetConfigurationServerFQDN *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetConfigurationServerFQDN * SOAP_FMAC4 soap_instantiate___sai__GetConfigurationServerFQDN(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetConfigurationServerFQDN(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetConfigurationServerFQDN, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetConfigurationServerFQDN; + if (size) + *size = sizeof(struct __sai__GetConfigurationServerFQDN); + } + else + { cp->ptr = (void*)new struct __sai__GetConfigurationServerFQDN[n]; + if (size) + *size = n * sizeof(struct __sai__GetConfigurationServerFQDN); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetConfigurationServerFQDN*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetConfigurationServerFQDN(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetConfigurationServerFQDN %p -> %p\n", q, p)); + *(struct __sai__GetConfigurationServerFQDN*)p = *(struct __sai__GetConfigurationServerFQDN*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnableVpnRouting(struct soap *soap, const struct __sai__EnableVpnRouting *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__EnableVpnRouting(soap, &a->sai__EnableVpnRouting); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnableVpnRouting(struct soap *soap, struct __sai__EnableVpnRouting *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__EnableVpnRouting = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnableVpnRouting(struct soap *soap, const struct __sai__EnableVpnRouting *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__EnableVpnRouting(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnableVpnRouting(struct soap *soap, const char *tag, int id, const struct __sai__EnableVpnRouting *a, const char *type) +{ + soap_out_PointerTo_sai__EnableVpnRouting(soap, "sai:EnableVpnRouting", -1, &a->sai__EnableVpnRouting, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__EnableVpnRouting * SOAP_FMAC4 soap_get___sai__EnableVpnRouting(struct soap *soap, struct __sai__EnableVpnRouting *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__EnableVpnRouting(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__EnableVpnRouting * SOAP_FMAC4 soap_in___sai__EnableVpnRouting(struct soap *soap, const char *tag, struct __sai__EnableVpnRouting *a, const char *type) +{ + short soap_flag_sai__EnableVpnRouting = 1; + a = (struct __sai__EnableVpnRouting *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__EnableVpnRouting, sizeof(struct __sai__EnableVpnRouting), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__EnableVpnRouting(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__EnableVpnRouting && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__EnableVpnRouting(soap, "sai:EnableVpnRouting", &a->sai__EnableVpnRouting, "")) + { soap_flag_sai__EnableVpnRouting--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__EnableVpnRouting * SOAP_FMAC6 soap_new___sai__EnableVpnRouting(struct soap *soap, int n) +{ return soap_instantiate___sai__EnableVpnRouting(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnableVpnRouting(struct soap *soap, struct __sai__EnableVpnRouting *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__EnableVpnRouting * SOAP_FMAC4 soap_instantiate___sai__EnableVpnRouting(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__EnableVpnRouting(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__EnableVpnRouting, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__EnableVpnRouting; + if (size) + *size = sizeof(struct __sai__EnableVpnRouting); + } + else + { cp->ptr = (void*)new struct __sai__EnableVpnRouting[n]; + if (size) + *size = n * sizeof(struct __sai__EnableVpnRouting); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__EnableVpnRouting*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnableVpnRouting(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__EnableVpnRouting %p -> %p\n", q, p)); + *(struct __sai__EnableVpnRouting*)p = *(struct __sai__EnableVpnRouting*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTLSCredentials(struct soap *soap, const struct __sai__GetTLSCredentials *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetTLSCredentials(soap, &a->sai__GetTLSCredentials); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTLSCredentials(struct soap *soap, struct __sai__GetTLSCredentials *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetTLSCredentials = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTLSCredentials(struct soap *soap, const struct __sai__GetTLSCredentials *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetTLSCredentials(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTLSCredentials(struct soap *soap, const char *tag, int id, const struct __sai__GetTLSCredentials *a, const char *type) +{ + soap_out_PointerTo_sai__GetTLSCredentials(soap, "sai:GetTLSCredentials", -1, &a->sai__GetTLSCredentials, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetTLSCredentials * SOAP_FMAC4 soap_get___sai__GetTLSCredentials(struct soap *soap, struct __sai__GetTLSCredentials *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetTLSCredentials(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetTLSCredentials * SOAP_FMAC4 soap_in___sai__GetTLSCredentials(struct soap *soap, const char *tag, struct __sai__GetTLSCredentials *a, const char *type) +{ + short soap_flag_sai__GetTLSCredentials = 1; + a = (struct __sai__GetTLSCredentials *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetTLSCredentials, sizeof(struct __sai__GetTLSCredentials), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetTLSCredentials(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetTLSCredentials && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetTLSCredentials(soap, "sai:GetTLSCredentials", &a->sai__GetTLSCredentials, "")) + { soap_flag_sai__GetTLSCredentials--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetTLSCredentials * SOAP_FMAC6 soap_new___sai__GetTLSCredentials(struct soap *soap, int n) +{ return soap_instantiate___sai__GetTLSCredentials(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTLSCredentials(struct soap *soap, struct __sai__GetTLSCredentials *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetTLSCredentials * SOAP_FMAC4 soap_instantiate___sai__GetTLSCredentials(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetTLSCredentials(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetTLSCredentials, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetTLSCredentials; + if (size) + *size = sizeof(struct __sai__GetTLSCredentials); + } + else + { cp->ptr = (void*)new struct __sai__GetTLSCredentials[n]; + if (size) + *size = n * sizeof(struct __sai__GetTLSCredentials); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetTLSCredentials*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTLSCredentials(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetTLSCredentials %p -> %p\n", q, p)); + *(struct __sai__GetTLSCredentials*)p = *(struct __sai__GetTLSCredentials*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTLSCredentials(struct soap *soap, const struct __sai__SetTLSCredentials *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetTLSCredentials(soap, &a->sai__SetTLSCredentials); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTLSCredentials(struct soap *soap, struct __sai__SetTLSCredentials *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetTLSCredentials = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTLSCredentials(struct soap *soap, const struct __sai__SetTLSCredentials *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetTLSCredentials(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTLSCredentials(struct soap *soap, const char *tag, int id, const struct __sai__SetTLSCredentials *a, const char *type) +{ + soap_out_PointerTo_sai__SetTLSCredentials(soap, "sai:SetTLSCredentials", -1, &a->sai__SetTLSCredentials, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetTLSCredentials * SOAP_FMAC4 soap_get___sai__SetTLSCredentials(struct soap *soap, struct __sai__SetTLSCredentials *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetTLSCredentials(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetTLSCredentials * SOAP_FMAC4 soap_in___sai__SetTLSCredentials(struct soap *soap, const char *tag, struct __sai__SetTLSCredentials *a, const char *type) +{ + short soap_flag_sai__SetTLSCredentials = 1; + a = (struct __sai__SetTLSCredentials *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetTLSCredentials, sizeof(struct __sai__SetTLSCredentials), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetTLSCredentials(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetTLSCredentials && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetTLSCredentials(soap, "sai:SetTLSCredentials", &a->sai__SetTLSCredentials, "")) + { soap_flag_sai__SetTLSCredentials--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetTLSCredentials * SOAP_FMAC6 soap_new___sai__SetTLSCredentials(struct soap *soap, int n) +{ return soap_instantiate___sai__SetTLSCredentials(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTLSCredentials(struct soap *soap, struct __sai__SetTLSCredentials *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetTLSCredentials * SOAP_FMAC4 soap_instantiate___sai__SetTLSCredentials(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetTLSCredentials(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetTLSCredentials, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetTLSCredentials; + if (size) + *size = sizeof(struct __sai__SetTLSCredentials); + } + else + { cp->ptr = (void*)new struct __sai__SetTLSCredentials[n]; + if (size) + *size = n * sizeof(struct __sai__SetTLSCredentials); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetTLSCredentials*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTLSCredentials(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetTLSCredentials %p -> %p\n", q, p)); + *(struct __sai__SetTLSCredentials*)p = *(struct __sai__SetTLSCredentials*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreUpdateCertificate(struct soap *soap, const struct __sai__CertStoreUpdateCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreUpdateCertificate(soap, &a->sai__CertStoreUpdateCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreUpdateCertificate(struct soap *soap, struct __sai__CertStoreUpdateCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreUpdateCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreUpdateCertificate(struct soap *soap, const struct __sai__CertStoreUpdateCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreUpdateCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreUpdateCertificate(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreUpdateCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreUpdateCertificate(soap, "sai:CertStoreUpdateCertificate", -1, &a->sai__CertStoreUpdateCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_get___sai__CertStoreUpdateCertificate(struct soap *soap, struct __sai__CertStoreUpdateCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreUpdateCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_in___sai__CertStoreUpdateCertificate(struct soap *soap, const char *tag, struct __sai__CertStoreUpdateCertificate *a, const char *type) +{ + short soap_flag_sai__CertStoreUpdateCertificate = 1; + a = (struct __sai__CertStoreUpdateCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreUpdateCertificate, sizeof(struct __sai__CertStoreUpdateCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreUpdateCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreUpdateCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreUpdateCertificate(soap, "sai:CertStoreUpdateCertificate", &a->sai__CertStoreUpdateCertificate, "")) + { soap_flag_sai__CertStoreUpdateCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreUpdateCertificate * SOAP_FMAC6 soap_new___sai__CertStoreUpdateCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreUpdateCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreUpdateCertificate(struct soap *soap, struct __sai__CertStoreUpdateCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreUpdateCertificate * SOAP_FMAC4 soap_instantiate___sai__CertStoreUpdateCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreUpdateCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreUpdateCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreUpdateCertificate; + if (size) + *size = sizeof(struct __sai__CertStoreUpdateCertificate); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreUpdateCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreUpdateCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreUpdateCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreUpdateCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreUpdateCertificate %p -> %p\n", q, p)); + *(struct __sai__CertStoreUpdateCertificate*)p = *(struct __sai__CertStoreUpdateCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreGetPKCS10Request(struct soap *soap, const struct __sai__CertStoreGetPKCS10Request *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreGetPKCS10Request(soap, &a->sai__CertStoreGetPKCS10Request); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreGetPKCS10Request(struct soap *soap, struct __sai__CertStoreGetPKCS10Request *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreGetPKCS10Request = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreGetPKCS10Request(struct soap *soap, const struct __sai__CertStoreGetPKCS10Request *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreGetPKCS10Request(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreGetPKCS10Request(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreGetPKCS10Request *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreGetPKCS10Request(soap, "sai:CertStoreGetPKCS10Request", -1, &a->sai__CertStoreGetPKCS10Request, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_get___sai__CertStoreGetPKCS10Request(struct soap *soap, struct __sai__CertStoreGetPKCS10Request *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreGetPKCS10Request(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_in___sai__CertStoreGetPKCS10Request(struct soap *soap, const char *tag, struct __sai__CertStoreGetPKCS10Request *a, const char *type) +{ + short soap_flag_sai__CertStoreGetPKCS10Request = 1; + a = (struct __sai__CertStoreGetPKCS10Request *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreGetPKCS10Request, sizeof(struct __sai__CertStoreGetPKCS10Request), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreGetPKCS10Request(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreGetPKCS10Request && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreGetPKCS10Request(soap, "sai:CertStoreGetPKCS10Request", &a->sai__CertStoreGetPKCS10Request, "")) + { soap_flag_sai__CertStoreGetPKCS10Request--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreGetPKCS10Request * SOAP_FMAC6 soap_new___sai__CertStoreGetPKCS10Request(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreGetPKCS10Request(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreGetPKCS10Request(struct soap *soap, struct __sai__CertStoreGetPKCS10Request *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreGetPKCS10Request * SOAP_FMAC4 soap_instantiate___sai__CertStoreGetPKCS10Request(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreGetPKCS10Request(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreGetPKCS10Request, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreGetPKCS10Request; + if (size) + *size = sizeof(struct __sai__CertStoreGetPKCS10Request); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreGetPKCS10Request[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreGetPKCS10Request); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreGetPKCS10Request*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreGetPKCS10Request(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreGetPKCS10Request %p -> %p\n", q, p)); + *(struct __sai__CertStoreGetPKCS10Request*)p = *(struct __sai__CertStoreGetPKCS10Request*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreRemoveCertificate(struct soap *soap, const struct __sai__CertStoreRemoveCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreRemoveCertificate(soap, &a->sai__CertStoreRemoveCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreRemoveCertificate(struct soap *soap, struct __sai__CertStoreRemoveCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreRemoveCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreRemoveCertificate(struct soap *soap, const struct __sai__CertStoreRemoveCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreRemoveCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreRemoveCertificate(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreRemoveCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreRemoveCertificate(soap, "sai:CertStoreRemoveCertificate", -1, &a->sai__CertStoreRemoveCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_get___sai__CertStoreRemoveCertificate(struct soap *soap, struct __sai__CertStoreRemoveCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreRemoveCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_in___sai__CertStoreRemoveCertificate(struct soap *soap, const char *tag, struct __sai__CertStoreRemoveCertificate *a, const char *type) +{ + short soap_flag_sai__CertStoreRemoveCertificate = 1; + a = (struct __sai__CertStoreRemoveCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreRemoveCertificate, sizeof(struct __sai__CertStoreRemoveCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreRemoveCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreRemoveCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreRemoveCertificate(soap, "sai:CertStoreRemoveCertificate", &a->sai__CertStoreRemoveCertificate, "")) + { soap_flag_sai__CertStoreRemoveCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreRemoveCertificate * SOAP_FMAC6 soap_new___sai__CertStoreRemoveCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreRemoveCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreRemoveCertificate(struct soap *soap, struct __sai__CertStoreRemoveCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreRemoveCertificate * SOAP_FMAC4 soap_instantiate___sai__CertStoreRemoveCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreRemoveCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreRemoveCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreRemoveCertificate; + if (size) + *size = sizeof(struct __sai__CertStoreRemoveCertificate); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreRemoveCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreRemoveCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreRemoveCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreRemoveCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreRemoveCertificate %p -> %p\n", q, p)); + *(struct __sai__CertStoreRemoveCertificate*)p = *(struct __sai__CertStoreRemoveCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreEnumerateCertificates(struct soap *soap, const struct __sai__CertStoreEnumerateCertificates *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreEnumerateCertificates(soap, &a->sai__CertStoreEnumerateCertificates); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreEnumerateCertificates(struct soap *soap, struct __sai__CertStoreEnumerateCertificates *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreEnumerateCertificates = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreEnumerateCertificates(struct soap *soap, const struct __sai__CertStoreEnumerateCertificates *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreEnumerateCertificates(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreEnumerateCertificates(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreEnumerateCertificates *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreEnumerateCertificates(soap, "sai:CertStoreEnumerateCertificates", -1, &a->sai__CertStoreEnumerateCertificates, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_get___sai__CertStoreEnumerateCertificates(struct soap *soap, struct __sai__CertStoreEnumerateCertificates *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreEnumerateCertificates(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_in___sai__CertStoreEnumerateCertificates(struct soap *soap, const char *tag, struct __sai__CertStoreEnumerateCertificates *a, const char *type) +{ + short soap_flag_sai__CertStoreEnumerateCertificates = 1; + a = (struct __sai__CertStoreEnumerateCertificates *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreEnumerateCertificates, sizeof(struct __sai__CertStoreEnumerateCertificates), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreEnumerateCertificates(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreEnumerateCertificates && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreEnumerateCertificates(soap, "sai:CertStoreEnumerateCertificates", &a->sai__CertStoreEnumerateCertificates, "")) + { soap_flag_sai__CertStoreEnumerateCertificates--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreEnumerateCertificates * SOAP_FMAC6 soap_new___sai__CertStoreEnumerateCertificates(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreEnumerateCertificates(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreEnumerateCertificates(struct soap *soap, struct __sai__CertStoreEnumerateCertificates *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreEnumerateCertificates * SOAP_FMAC4 soap_instantiate___sai__CertStoreEnumerateCertificates(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreEnumerateCertificates(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreEnumerateCertificates, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreEnumerateCertificates; + if (size) + *size = sizeof(struct __sai__CertStoreEnumerateCertificates); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreEnumerateCertificates[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreEnumerateCertificates); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreEnumerateCertificates*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreEnumerateCertificates(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreEnumerateCertificates %p -> %p\n", q, p)); + *(struct __sai__CertStoreEnumerateCertificates*)p = *(struct __sai__CertStoreEnumerateCertificates*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreGetCertificate(struct soap *soap, const struct __sai__CertStoreGetCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreGetCertificate(soap, &a->sai__CertStoreGetCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreGetCertificate(struct soap *soap, struct __sai__CertStoreGetCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreGetCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreGetCertificate(struct soap *soap, const struct __sai__CertStoreGetCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreGetCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreGetCertificate(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreGetCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreGetCertificate(soap, "sai:CertStoreGetCertificate", -1, &a->sai__CertStoreGetCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreGetCertificate * SOAP_FMAC4 soap_get___sai__CertStoreGetCertificate(struct soap *soap, struct __sai__CertStoreGetCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreGetCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreGetCertificate * SOAP_FMAC4 soap_in___sai__CertStoreGetCertificate(struct soap *soap, const char *tag, struct __sai__CertStoreGetCertificate *a, const char *type) +{ + short soap_flag_sai__CertStoreGetCertificate = 1; + a = (struct __sai__CertStoreGetCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreGetCertificate, sizeof(struct __sai__CertStoreGetCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreGetCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreGetCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreGetCertificate(soap, "sai:CertStoreGetCertificate", &a->sai__CertStoreGetCertificate, "")) + { soap_flag_sai__CertStoreGetCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreGetCertificate * SOAP_FMAC6 soap_new___sai__CertStoreGetCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreGetCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreGetCertificate(struct soap *soap, struct __sai__CertStoreGetCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreGetCertificate * SOAP_FMAC4 soap_instantiate___sai__CertStoreGetCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreGetCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreGetCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreGetCertificate; + if (size) + *size = sizeof(struct __sai__CertStoreGetCertificate); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreGetCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreGetCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreGetCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreGetCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreGetCertificate %p -> %p\n", q, p)); + *(struct __sai__CertStoreGetCertificate*)p = *(struct __sai__CertStoreGetCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreAddCertificate(struct soap *soap, const struct __sai__CertStoreAddCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreAddCertificate(soap, &a->sai__CertStoreAddCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreAddCertificate(struct soap *soap, struct __sai__CertStoreAddCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreAddCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreAddCertificate(struct soap *soap, const struct __sai__CertStoreAddCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreAddCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreAddCertificate(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreAddCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreAddCertificate(soap, "sai:CertStoreAddCertificate", -1, &a->sai__CertStoreAddCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreAddCertificate * SOAP_FMAC4 soap_get___sai__CertStoreAddCertificate(struct soap *soap, struct __sai__CertStoreAddCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreAddCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreAddCertificate * SOAP_FMAC4 soap_in___sai__CertStoreAddCertificate(struct soap *soap, const char *tag, struct __sai__CertStoreAddCertificate *a, const char *type) +{ + short soap_flag_sai__CertStoreAddCertificate = 1; + a = (struct __sai__CertStoreAddCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreAddCertificate, sizeof(struct __sai__CertStoreAddCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreAddCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreAddCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreAddCertificate(soap, "sai:CertStoreAddCertificate", &a->sai__CertStoreAddCertificate, "")) + { soap_flag_sai__CertStoreAddCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreAddCertificate * SOAP_FMAC6 soap_new___sai__CertStoreAddCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreAddCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreAddCertificate(struct soap *soap, struct __sai__CertStoreAddCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreAddCertificate * SOAP_FMAC4 soap_instantiate___sai__CertStoreAddCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreAddCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreAddCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreAddCertificate; + if (size) + *size = sizeof(struct __sai__CertStoreAddCertificate); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreAddCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreAddCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreAddCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreAddCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreAddCertificate %p -> %p\n", q, p)); + *(struct __sai__CertStoreAddCertificate*)p = *(struct __sai__CertStoreAddCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreRemoveKey(struct soap *soap, const struct __sai__CertStoreRemoveKey *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreRemoveKey(soap, &a->sai__CertStoreRemoveKey); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreRemoveKey(struct soap *soap, struct __sai__CertStoreRemoveKey *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreRemoveKey = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreRemoveKey(struct soap *soap, const struct __sai__CertStoreRemoveKey *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreRemoveKey(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreRemoveKey(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreRemoveKey *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreRemoveKey(soap, "sai:CertStoreRemoveKey", -1, &a->sai__CertStoreRemoveKey, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreRemoveKey * SOAP_FMAC4 soap_get___sai__CertStoreRemoveKey(struct soap *soap, struct __sai__CertStoreRemoveKey *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreRemoveKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreRemoveKey * SOAP_FMAC4 soap_in___sai__CertStoreRemoveKey(struct soap *soap, const char *tag, struct __sai__CertStoreRemoveKey *a, const char *type) +{ + short soap_flag_sai__CertStoreRemoveKey = 1; + a = (struct __sai__CertStoreRemoveKey *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreRemoveKey, sizeof(struct __sai__CertStoreRemoveKey), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreRemoveKey(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreRemoveKey && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreRemoveKey(soap, "sai:CertStoreRemoveKey", &a->sai__CertStoreRemoveKey, "")) + { soap_flag_sai__CertStoreRemoveKey--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreRemoveKey * SOAP_FMAC6 soap_new___sai__CertStoreRemoveKey(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreRemoveKey(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreRemoveKey(struct soap *soap, struct __sai__CertStoreRemoveKey *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreRemoveKey * SOAP_FMAC4 soap_instantiate___sai__CertStoreRemoveKey(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreRemoveKey(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreRemoveKey, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreRemoveKey; + if (size) + *size = sizeof(struct __sai__CertStoreRemoveKey); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreRemoveKey[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreRemoveKey); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreRemoveKey*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreRemoveKey(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreRemoveKey %p -> %p\n", q, p)); + *(struct __sai__CertStoreRemoveKey*)p = *(struct __sai__CertStoreRemoveKey*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreGetKey(struct soap *soap, const struct __sai__CertStoreGetKey *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreGetKey(soap, &a->sai__CertStoreGetKey); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreGetKey(struct soap *soap, struct __sai__CertStoreGetKey *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreGetKey = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreGetKey(struct soap *soap, const struct __sai__CertStoreGetKey *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreGetKey(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreGetKey(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreGetKey *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreGetKey(soap, "sai:CertStoreGetKey", -1, &a->sai__CertStoreGetKey, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreGetKey * SOAP_FMAC4 soap_get___sai__CertStoreGetKey(struct soap *soap, struct __sai__CertStoreGetKey *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreGetKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreGetKey * SOAP_FMAC4 soap_in___sai__CertStoreGetKey(struct soap *soap, const char *tag, struct __sai__CertStoreGetKey *a, const char *type) +{ + short soap_flag_sai__CertStoreGetKey = 1; + a = (struct __sai__CertStoreGetKey *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreGetKey, sizeof(struct __sai__CertStoreGetKey), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreGetKey(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreGetKey && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreGetKey(soap, "sai:CertStoreGetKey", &a->sai__CertStoreGetKey, "")) + { soap_flag_sai__CertStoreGetKey--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreGetKey * SOAP_FMAC6 soap_new___sai__CertStoreGetKey(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreGetKey(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreGetKey(struct soap *soap, struct __sai__CertStoreGetKey *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreGetKey * SOAP_FMAC4 soap_instantiate___sai__CertStoreGetKey(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreGetKey(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreGetKey, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreGetKey; + if (size) + *size = sizeof(struct __sai__CertStoreGetKey); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreGetKey[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreGetKey); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreGetKey*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreGetKey(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreGetKey %p -> %p\n", q, p)); + *(struct __sai__CertStoreGetKey*)p = *(struct __sai__CertStoreGetKey*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreEnumerateKeys(struct soap *soap, const struct __sai__CertStoreEnumerateKeys *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreEnumerateKeys(soap, &a->sai__CertStoreEnumerateKeys); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreEnumerateKeys(struct soap *soap, struct __sai__CertStoreEnumerateKeys *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreEnumerateKeys = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreEnumerateKeys(struct soap *soap, const struct __sai__CertStoreEnumerateKeys *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreEnumerateKeys(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreEnumerateKeys(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreEnumerateKeys *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreEnumerateKeys(soap, "sai:CertStoreEnumerateKeys", -1, &a->sai__CertStoreEnumerateKeys, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_get___sai__CertStoreEnumerateKeys(struct soap *soap, struct __sai__CertStoreEnumerateKeys *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreEnumerateKeys(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_in___sai__CertStoreEnumerateKeys(struct soap *soap, const char *tag, struct __sai__CertStoreEnumerateKeys *a, const char *type) +{ + short soap_flag_sai__CertStoreEnumerateKeys = 1; + a = (struct __sai__CertStoreEnumerateKeys *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreEnumerateKeys, sizeof(struct __sai__CertStoreEnumerateKeys), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreEnumerateKeys(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreEnumerateKeys && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreEnumerateKeys(soap, "sai:CertStoreEnumerateKeys", &a->sai__CertStoreEnumerateKeys, "")) + { soap_flag_sai__CertStoreEnumerateKeys--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreEnumerateKeys * SOAP_FMAC6 soap_new___sai__CertStoreEnumerateKeys(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreEnumerateKeys(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreEnumerateKeys(struct soap *soap, struct __sai__CertStoreEnumerateKeys *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreEnumerateKeys * SOAP_FMAC4 soap_instantiate___sai__CertStoreEnumerateKeys(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreEnumerateKeys(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreEnumerateKeys, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreEnumerateKeys; + if (size) + *size = sizeof(struct __sai__CertStoreEnumerateKeys); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreEnumerateKeys[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreEnumerateKeys); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreEnumerateKeys*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreEnumerateKeys(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreEnumerateKeys %p -> %p\n", q, p)); + *(struct __sai__CertStoreEnumerateKeys*)p = *(struct __sai__CertStoreEnumerateKeys*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CertStoreAddKey(struct soap *soap, const struct __sai__CertStoreAddKey *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CertStoreAddKey(soap, &a->sai__CertStoreAddKey); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CertStoreAddKey(struct soap *soap, struct __sai__CertStoreAddKey *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CertStoreAddKey = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CertStoreAddKey(struct soap *soap, const struct __sai__CertStoreAddKey *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CertStoreAddKey(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CertStoreAddKey(struct soap *soap, const char *tag, int id, const struct __sai__CertStoreAddKey *a, const char *type) +{ + soap_out_PointerTo_sai__CertStoreAddKey(soap, "sai:CertStoreAddKey", -1, &a->sai__CertStoreAddKey, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CertStoreAddKey * SOAP_FMAC4 soap_get___sai__CertStoreAddKey(struct soap *soap, struct __sai__CertStoreAddKey *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CertStoreAddKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CertStoreAddKey * SOAP_FMAC4 soap_in___sai__CertStoreAddKey(struct soap *soap, const char *tag, struct __sai__CertStoreAddKey *a, const char *type) +{ + short soap_flag_sai__CertStoreAddKey = 1; + a = (struct __sai__CertStoreAddKey *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CertStoreAddKey, sizeof(struct __sai__CertStoreAddKey), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CertStoreAddKey(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CertStoreAddKey && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CertStoreAddKey(soap, "sai:CertStoreAddKey", &a->sai__CertStoreAddKey, "")) + { soap_flag_sai__CertStoreAddKey--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CertStoreAddKey * SOAP_FMAC6 soap_new___sai__CertStoreAddKey(struct soap *soap, int n) +{ return soap_instantiate___sai__CertStoreAddKey(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CertStoreAddKey(struct soap *soap, struct __sai__CertStoreAddKey *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CertStoreAddKey * SOAP_FMAC4 soap_instantiate___sai__CertStoreAddKey(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CertStoreAddKey(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CertStoreAddKey, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CertStoreAddKey; + if (size) + *size = sizeof(struct __sai__CertStoreAddKey); + } + else + { cp->ptr = (void*)new struct __sai__CertStoreAddKey[n]; + if (size) + *size = n * sizeof(struct __sai__CertStoreAddKey); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CertStoreAddKey*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CertStoreAddKey(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CertStoreAddKey %p -> %p\n", q, p)); + *(struct __sai__CertStoreAddKey*)p = *(struct __sai__CertStoreAddKey*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetGlobalPowerPolicy(struct soap *soap, const struct __sai__GetGlobalPowerPolicy *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetGlobalPowerPolicy(soap, &a->sai__GetGlobalPowerPolicy); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetGlobalPowerPolicy(struct soap *soap, struct __sai__GetGlobalPowerPolicy *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetGlobalPowerPolicy = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetGlobalPowerPolicy(struct soap *soap, const struct __sai__GetGlobalPowerPolicy *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetGlobalPowerPolicy(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetGlobalPowerPolicy(struct soap *soap, const char *tag, int id, const struct __sai__GetGlobalPowerPolicy *a, const char *type) +{ + soap_out_PointerTo_sai__GetGlobalPowerPolicy(soap, "sai:GetGlobalPowerPolicy", -1, &a->sai__GetGlobalPowerPolicy, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_get___sai__GetGlobalPowerPolicy(struct soap *soap, struct __sai__GetGlobalPowerPolicy *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetGlobalPowerPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_in___sai__GetGlobalPowerPolicy(struct soap *soap, const char *tag, struct __sai__GetGlobalPowerPolicy *a, const char *type) +{ + short soap_flag_sai__GetGlobalPowerPolicy = 1; + a = (struct __sai__GetGlobalPowerPolicy *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetGlobalPowerPolicy, sizeof(struct __sai__GetGlobalPowerPolicy), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetGlobalPowerPolicy(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetGlobalPowerPolicy && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetGlobalPowerPolicy(soap, "sai:GetGlobalPowerPolicy", &a->sai__GetGlobalPowerPolicy, "")) + { soap_flag_sai__GetGlobalPowerPolicy--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetGlobalPowerPolicy * SOAP_FMAC6 soap_new___sai__GetGlobalPowerPolicy(struct soap *soap, int n) +{ return soap_instantiate___sai__GetGlobalPowerPolicy(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetGlobalPowerPolicy(struct soap *soap, struct __sai__GetGlobalPowerPolicy *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetGlobalPowerPolicy * SOAP_FMAC4 soap_instantiate___sai__GetGlobalPowerPolicy(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetGlobalPowerPolicy(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetGlobalPowerPolicy, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetGlobalPowerPolicy; + if (size) + *size = sizeof(struct __sai__GetGlobalPowerPolicy); + } + else + { cp->ptr = (void*)new struct __sai__GetGlobalPowerPolicy[n]; + if (size) + *size = n * sizeof(struct __sai__GetGlobalPowerPolicy); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetGlobalPowerPolicy*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetGlobalPowerPolicy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetGlobalPowerPolicy %p -> %p\n", q, p)); + *(struct __sai__GetGlobalPowerPolicy*)p = *(struct __sai__GetGlobalPowerPolicy*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetGlobalPowerPolicy(struct soap *soap, const struct __sai__SetGlobalPowerPolicy *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetGlobalPowerPolicy(soap, &a->sai__SetGlobalPowerPolicy); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetGlobalPowerPolicy(struct soap *soap, struct __sai__SetGlobalPowerPolicy *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetGlobalPowerPolicy = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetGlobalPowerPolicy(struct soap *soap, const struct __sai__SetGlobalPowerPolicy *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetGlobalPowerPolicy(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetGlobalPowerPolicy(struct soap *soap, const char *tag, int id, const struct __sai__SetGlobalPowerPolicy *a, const char *type) +{ + soap_out_PointerTo_sai__SetGlobalPowerPolicy(soap, "sai:SetGlobalPowerPolicy", -1, &a->sai__SetGlobalPowerPolicy, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_get___sai__SetGlobalPowerPolicy(struct soap *soap, struct __sai__SetGlobalPowerPolicy *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetGlobalPowerPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_in___sai__SetGlobalPowerPolicy(struct soap *soap, const char *tag, struct __sai__SetGlobalPowerPolicy *a, const char *type) +{ + short soap_flag_sai__SetGlobalPowerPolicy = 1; + a = (struct __sai__SetGlobalPowerPolicy *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetGlobalPowerPolicy, sizeof(struct __sai__SetGlobalPowerPolicy), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetGlobalPowerPolicy(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetGlobalPowerPolicy && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetGlobalPowerPolicy(soap, "sai:SetGlobalPowerPolicy", &a->sai__SetGlobalPowerPolicy, "")) + { soap_flag_sai__SetGlobalPowerPolicy--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetGlobalPowerPolicy * SOAP_FMAC6 soap_new___sai__SetGlobalPowerPolicy(struct soap *soap, int n) +{ return soap_instantiate___sai__SetGlobalPowerPolicy(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetGlobalPowerPolicy(struct soap *soap, struct __sai__SetGlobalPowerPolicy *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetGlobalPowerPolicy * SOAP_FMAC4 soap_instantiate___sai__SetGlobalPowerPolicy(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetGlobalPowerPolicy(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetGlobalPowerPolicy, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetGlobalPowerPolicy; + if (size) + *size = sizeof(struct __sai__SetGlobalPowerPolicy); + } + else + { cp->ptr = (void*)new struct __sai__SetGlobalPowerPolicy[n]; + if (size) + *size = n * sizeof(struct __sai__SetGlobalPowerPolicy); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetGlobalPowerPolicy*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetGlobalPowerPolicy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetGlobalPowerPolicy %p -> %p\n", q, p)); + *(struct __sai__SetGlobalPowerPolicy*)p = *(struct __sai__SetGlobalPowerPolicy*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetActivePowerPackage(struct soap *soap, const struct __sai__SetActivePowerPackage *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetActivePowerPackage(soap, &a->sai__SetActivePowerPackage); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetActivePowerPackage(struct soap *soap, struct __sai__SetActivePowerPackage *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetActivePowerPackage = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetActivePowerPackage(struct soap *soap, const struct __sai__SetActivePowerPackage *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetActivePowerPackage(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetActivePowerPackage(struct soap *soap, const char *tag, int id, const struct __sai__SetActivePowerPackage *a, const char *type) +{ + soap_out_PointerTo_sai__SetActivePowerPackage(soap, "sai:SetActivePowerPackage", -1, &a->sai__SetActivePowerPackage, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetActivePowerPackage * SOAP_FMAC4 soap_get___sai__SetActivePowerPackage(struct soap *soap, struct __sai__SetActivePowerPackage *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetActivePowerPackage(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetActivePowerPackage * SOAP_FMAC4 soap_in___sai__SetActivePowerPackage(struct soap *soap, const char *tag, struct __sai__SetActivePowerPackage *a, const char *type) +{ + short soap_flag_sai__SetActivePowerPackage = 1; + a = (struct __sai__SetActivePowerPackage *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetActivePowerPackage, sizeof(struct __sai__SetActivePowerPackage), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetActivePowerPackage(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetActivePowerPackage && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetActivePowerPackage(soap, "sai:SetActivePowerPackage", &a->sai__SetActivePowerPackage, "")) + { soap_flag_sai__SetActivePowerPackage--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetActivePowerPackage * SOAP_FMAC6 soap_new___sai__SetActivePowerPackage(struct soap *soap, int n) +{ return soap_instantiate___sai__SetActivePowerPackage(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetActivePowerPackage(struct soap *soap, struct __sai__SetActivePowerPackage *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetActivePowerPackage * SOAP_FMAC4 soap_instantiate___sai__SetActivePowerPackage(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetActivePowerPackage(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetActivePowerPackage, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetActivePowerPackage; + if (size) + *size = sizeof(struct __sai__SetActivePowerPackage); + } + else + { cp->ptr = (void*)new struct __sai__SetActivePowerPackage[n]; + if (size) + *size = n * sizeof(struct __sai__SetActivePowerPackage); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetActivePowerPackage*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetActivePowerPackage(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetActivePowerPackage %p -> %p\n", q, p)); + *(struct __sai__SetActivePowerPackage*)p = *(struct __sai__SetActivePowerPackage*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetActivePowerPackage(struct soap *soap, const struct __sai__GetActivePowerPackage *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetActivePowerPackage(soap, &a->sai__GetActivePowerPackage); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetActivePowerPackage(struct soap *soap, struct __sai__GetActivePowerPackage *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetActivePowerPackage = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetActivePowerPackage(struct soap *soap, const struct __sai__GetActivePowerPackage *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetActivePowerPackage(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetActivePowerPackage(struct soap *soap, const char *tag, int id, const struct __sai__GetActivePowerPackage *a, const char *type) +{ + soap_out_PointerTo_sai__GetActivePowerPackage(soap, "sai:GetActivePowerPackage", -1, &a->sai__GetActivePowerPackage, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetActivePowerPackage * SOAP_FMAC4 soap_get___sai__GetActivePowerPackage(struct soap *soap, struct __sai__GetActivePowerPackage *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetActivePowerPackage(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetActivePowerPackage * SOAP_FMAC4 soap_in___sai__GetActivePowerPackage(struct soap *soap, const char *tag, struct __sai__GetActivePowerPackage *a, const char *type) +{ + short soap_flag_sai__GetActivePowerPackage = 1; + a = (struct __sai__GetActivePowerPackage *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetActivePowerPackage, sizeof(struct __sai__GetActivePowerPackage), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetActivePowerPackage(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetActivePowerPackage && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetActivePowerPackage(soap, "sai:GetActivePowerPackage", &a->sai__GetActivePowerPackage, "")) + { soap_flag_sai__GetActivePowerPackage--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetActivePowerPackage * SOAP_FMAC6 soap_new___sai__GetActivePowerPackage(struct soap *soap, int n) +{ return soap_instantiate___sai__GetActivePowerPackage(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetActivePowerPackage(struct soap *soap, struct __sai__GetActivePowerPackage *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetActivePowerPackage * SOAP_FMAC4 soap_instantiate___sai__GetActivePowerPackage(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetActivePowerPackage(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetActivePowerPackage, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetActivePowerPackage; + if (size) + *size = sizeof(struct __sai__GetActivePowerPackage); + } + else + { cp->ptr = (void*)new struct __sai__GetActivePowerPackage[n]; + if (size) + *size = n * sizeof(struct __sai__GetActivePowerPackage); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetActivePowerPackage*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetActivePowerPackage(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetActivePowerPackage %p -> %p\n", q, p)); + *(struct __sai__GetActivePowerPackage*)p = *(struct __sai__GetActivePowerPackage*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetPowerPackage(struct soap *soap, const struct __sai__GetPowerPackage *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetPowerPackage(soap, &a->sai__GetPowerPackage); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetPowerPackage(struct soap *soap, struct __sai__GetPowerPackage *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetPowerPackage = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetPowerPackage(struct soap *soap, const struct __sai__GetPowerPackage *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetPowerPackage(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetPowerPackage(struct soap *soap, const char *tag, int id, const struct __sai__GetPowerPackage *a, const char *type) +{ + soap_out_PointerTo_sai__GetPowerPackage(soap, "sai:GetPowerPackage", -1, &a->sai__GetPowerPackage, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetPowerPackage * SOAP_FMAC4 soap_get___sai__GetPowerPackage(struct soap *soap, struct __sai__GetPowerPackage *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetPowerPackage(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetPowerPackage * SOAP_FMAC4 soap_in___sai__GetPowerPackage(struct soap *soap, const char *tag, struct __sai__GetPowerPackage *a, const char *type) +{ + short soap_flag_sai__GetPowerPackage = 1; + a = (struct __sai__GetPowerPackage *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetPowerPackage, sizeof(struct __sai__GetPowerPackage), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetPowerPackage(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetPowerPackage && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetPowerPackage(soap, "sai:GetPowerPackage", &a->sai__GetPowerPackage, "")) + { soap_flag_sai__GetPowerPackage--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetPowerPackage * SOAP_FMAC6 soap_new___sai__GetPowerPackage(struct soap *soap, int n) +{ return soap_instantiate___sai__GetPowerPackage(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetPowerPackage(struct soap *soap, struct __sai__GetPowerPackage *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetPowerPackage * SOAP_FMAC4 soap_instantiate___sai__GetPowerPackage(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetPowerPackage(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetPowerPackage, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetPowerPackage; + if (size) + *size = sizeof(struct __sai__GetPowerPackage); + } + else + { cp->ptr = (void*)new struct __sai__GetPowerPackage[n]; + if (size) + *size = n * sizeof(struct __sai__GetPowerPackage); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetPowerPackage*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetPowerPackage(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetPowerPackage %p -> %p\n", q, p)); + *(struct __sai__GetPowerPackage*)p = *(struct __sai__GetPowerPackage*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnumeratePowerPackages(struct soap *soap, const struct __sai__EnumeratePowerPackages *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__EnumeratePowerPackages(soap, &a->sai__EnumeratePowerPackages); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnumeratePowerPackages(struct soap *soap, struct __sai__EnumeratePowerPackages *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__EnumeratePowerPackages = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnumeratePowerPackages(struct soap *soap, const struct __sai__EnumeratePowerPackages *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__EnumeratePowerPackages(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnumeratePowerPackages(struct soap *soap, const char *tag, int id, const struct __sai__EnumeratePowerPackages *a, const char *type) +{ + soap_out_PointerTo_sai__EnumeratePowerPackages(soap, "sai:EnumeratePowerPackages", -1, &a->sai__EnumeratePowerPackages, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__EnumeratePowerPackages * SOAP_FMAC4 soap_get___sai__EnumeratePowerPackages(struct soap *soap, struct __sai__EnumeratePowerPackages *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__EnumeratePowerPackages(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__EnumeratePowerPackages * SOAP_FMAC4 soap_in___sai__EnumeratePowerPackages(struct soap *soap, const char *tag, struct __sai__EnumeratePowerPackages *a, const char *type) +{ + short soap_flag_sai__EnumeratePowerPackages = 1; + a = (struct __sai__EnumeratePowerPackages *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__EnumeratePowerPackages, sizeof(struct __sai__EnumeratePowerPackages), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__EnumeratePowerPackages(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__EnumeratePowerPackages && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__EnumeratePowerPackages(soap, "sai:EnumeratePowerPackages", &a->sai__EnumeratePowerPackages, "")) + { soap_flag_sai__EnumeratePowerPackages--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__EnumeratePowerPackages * SOAP_FMAC6 soap_new___sai__EnumeratePowerPackages(struct soap *soap, int n) +{ return soap_instantiate___sai__EnumeratePowerPackages(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnumeratePowerPackages(struct soap *soap, struct __sai__EnumeratePowerPackages *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__EnumeratePowerPackages * SOAP_FMAC4 soap_instantiate___sai__EnumeratePowerPackages(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__EnumeratePowerPackages(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__EnumeratePowerPackages, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__EnumeratePowerPackages; + if (size) + *size = sizeof(struct __sai__EnumeratePowerPackages); + } + else + { cp->ptr = (void*)new struct __sai__EnumeratePowerPackages[n]; + if (size) + *size = n * sizeof(struct __sai__EnumeratePowerPackages); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__EnumeratePowerPackages*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnumeratePowerPackages(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__EnumeratePowerPackages %p -> %p\n", q, p)); + *(struct __sai__EnumeratePowerPackages*)p = *(struct __sai__EnumeratePowerPackages*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetEnvironmentDetection(struct soap *soap, const struct __sai__GetEnvironmentDetection *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetEnvironmentDetection(soap, &a->sai__GetEnvironmentDetection); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetEnvironmentDetection(struct soap *soap, struct __sai__GetEnvironmentDetection *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetEnvironmentDetection = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetEnvironmentDetection(struct soap *soap, const struct __sai__GetEnvironmentDetection *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetEnvironmentDetection(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetEnvironmentDetection(struct soap *soap, const char *tag, int id, const struct __sai__GetEnvironmentDetection *a, const char *type) +{ + soap_out_PointerTo_sai__GetEnvironmentDetection(soap, "sai:GetEnvironmentDetection", -1, &a->sai__GetEnvironmentDetection, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetEnvironmentDetection * SOAP_FMAC4 soap_get___sai__GetEnvironmentDetection(struct soap *soap, struct __sai__GetEnvironmentDetection *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetEnvironmentDetection(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetEnvironmentDetection * SOAP_FMAC4 soap_in___sai__GetEnvironmentDetection(struct soap *soap, const char *tag, struct __sai__GetEnvironmentDetection *a, const char *type) +{ + short soap_flag_sai__GetEnvironmentDetection = 1; + a = (struct __sai__GetEnvironmentDetection *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetEnvironmentDetection, sizeof(struct __sai__GetEnvironmentDetection), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetEnvironmentDetection(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetEnvironmentDetection && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetEnvironmentDetection(soap, "sai:GetEnvironmentDetection", &a->sai__GetEnvironmentDetection, "")) + { soap_flag_sai__GetEnvironmentDetection--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetEnvironmentDetection * SOAP_FMAC6 soap_new___sai__GetEnvironmentDetection(struct soap *soap, int n) +{ return soap_instantiate___sai__GetEnvironmentDetection(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetEnvironmentDetection(struct soap *soap, struct __sai__GetEnvironmentDetection *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetEnvironmentDetection * SOAP_FMAC4 soap_instantiate___sai__GetEnvironmentDetection(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetEnvironmentDetection(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetEnvironmentDetection, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetEnvironmentDetection; + if (size) + *size = sizeof(struct __sai__GetEnvironmentDetection); + } + else + { cp->ptr = (void*)new struct __sai__GetEnvironmentDetection[n]; + if (size) + *size = n * sizeof(struct __sai__GetEnvironmentDetection); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetEnvironmentDetection*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetEnvironmentDetection(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetEnvironmentDetection %p -> %p\n", q, p)); + *(struct __sai__GetEnvironmentDetection*)p = *(struct __sai__GetEnvironmentDetection*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetEnvironmentDetection(struct soap *soap, const struct __sai__SetEnvironmentDetection *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetEnvironmentDetection(soap, &a->sai__SetEnvironmentDetection); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetEnvironmentDetection(struct soap *soap, struct __sai__SetEnvironmentDetection *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetEnvironmentDetection = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetEnvironmentDetection(struct soap *soap, const struct __sai__SetEnvironmentDetection *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetEnvironmentDetection(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetEnvironmentDetection(struct soap *soap, const char *tag, int id, const struct __sai__SetEnvironmentDetection *a, const char *type) +{ + soap_out_PointerTo_sai__SetEnvironmentDetection(soap, "sai:SetEnvironmentDetection", -1, &a->sai__SetEnvironmentDetection, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetEnvironmentDetection * SOAP_FMAC4 soap_get___sai__SetEnvironmentDetection(struct soap *soap, struct __sai__SetEnvironmentDetection *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetEnvironmentDetection(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetEnvironmentDetection * SOAP_FMAC4 soap_in___sai__SetEnvironmentDetection(struct soap *soap, const char *tag, struct __sai__SetEnvironmentDetection *a, const char *type) +{ + short soap_flag_sai__SetEnvironmentDetection = 1; + a = (struct __sai__SetEnvironmentDetection *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetEnvironmentDetection, sizeof(struct __sai__SetEnvironmentDetection), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetEnvironmentDetection(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetEnvironmentDetection && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetEnvironmentDetection(soap, "sai:SetEnvironmentDetection", &a->sai__SetEnvironmentDetection, "")) + { soap_flag_sai__SetEnvironmentDetection--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetEnvironmentDetection * SOAP_FMAC6 soap_new___sai__SetEnvironmentDetection(struct soap *soap, int n) +{ return soap_instantiate___sai__SetEnvironmentDetection(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetEnvironmentDetection(struct soap *soap, struct __sai__SetEnvironmentDetection *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetEnvironmentDetection * SOAP_FMAC4 soap_instantiate___sai__SetEnvironmentDetection(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetEnvironmentDetection(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetEnvironmentDetection, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetEnvironmentDetection; + if (size) + *size = sizeof(struct __sai__SetEnvironmentDetection); + } + else + { cp->ptr = (void*)new struct __sai__SetEnvironmentDetection[n]; + if (size) + *size = n * sizeof(struct __sai__SetEnvironmentDetection); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetEnvironmentDetection*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetEnvironmentDetection(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetEnvironmentDetection %p -> %p\n", q, p)); + *(struct __sai__SetEnvironmentDetection*)p = *(struct __sai__SetEnvironmentDetection*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetRealmAuthOptions(struct soap *soap, const struct __sai__SetRealmAuthOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetRealmAuthOptions(soap, &a->sai__SetRealmAuthOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetRealmAuthOptions(struct soap *soap, struct __sai__SetRealmAuthOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetRealmAuthOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetRealmAuthOptions(struct soap *soap, const struct __sai__SetRealmAuthOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetRealmAuthOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetRealmAuthOptions(struct soap *soap, const char *tag, int id, const struct __sai__SetRealmAuthOptions *a, const char *type) +{ + soap_out_PointerTo_sai__SetRealmAuthOptions(soap, "sai:SetRealmAuthOptions", -1, &a->sai__SetRealmAuthOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetRealmAuthOptions * SOAP_FMAC4 soap_get___sai__SetRealmAuthOptions(struct soap *soap, struct __sai__SetRealmAuthOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetRealmAuthOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetRealmAuthOptions * SOAP_FMAC4 soap_in___sai__SetRealmAuthOptions(struct soap *soap, const char *tag, struct __sai__SetRealmAuthOptions *a, const char *type) +{ + short soap_flag_sai__SetRealmAuthOptions = 1; + a = (struct __sai__SetRealmAuthOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetRealmAuthOptions, sizeof(struct __sai__SetRealmAuthOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetRealmAuthOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetRealmAuthOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetRealmAuthOptions(soap, "sai:SetRealmAuthOptions", &a->sai__SetRealmAuthOptions, "")) + { soap_flag_sai__SetRealmAuthOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetRealmAuthOptions * SOAP_FMAC6 soap_new___sai__SetRealmAuthOptions(struct soap *soap, int n) +{ return soap_instantiate___sai__SetRealmAuthOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetRealmAuthOptions(struct soap *soap, struct __sai__SetRealmAuthOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetRealmAuthOptions * SOAP_FMAC4 soap_instantiate___sai__SetRealmAuthOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetRealmAuthOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetRealmAuthOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetRealmAuthOptions; + if (size) + *size = sizeof(struct __sai__SetRealmAuthOptions); + } + else + { cp->ptr = (void*)new struct __sai__SetRealmAuthOptions[n]; + if (size) + *size = n * sizeof(struct __sai__SetRealmAuthOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetRealmAuthOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetRealmAuthOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetRealmAuthOptions %p -> %p\n", q, p)); + *(struct __sai__SetRealmAuthOptions*)p = *(struct __sai__SetRealmAuthOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetRealmAuthOptions(struct soap *soap, const struct __sai__GetRealmAuthOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetRealmAuthOptions(soap, &a->sai__GetRealmAuthOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetRealmAuthOptions(struct soap *soap, struct __sai__GetRealmAuthOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetRealmAuthOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetRealmAuthOptions(struct soap *soap, const struct __sai__GetRealmAuthOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetRealmAuthOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetRealmAuthOptions(struct soap *soap, const char *tag, int id, const struct __sai__GetRealmAuthOptions *a, const char *type) +{ + soap_out_PointerTo_sai__GetRealmAuthOptions(soap, "sai:GetRealmAuthOptions", -1, &a->sai__GetRealmAuthOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetRealmAuthOptions * SOAP_FMAC4 soap_get___sai__GetRealmAuthOptions(struct soap *soap, struct __sai__GetRealmAuthOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetRealmAuthOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetRealmAuthOptions * SOAP_FMAC4 soap_in___sai__GetRealmAuthOptions(struct soap *soap, const char *tag, struct __sai__GetRealmAuthOptions *a, const char *type) +{ + short soap_flag_sai__GetRealmAuthOptions = 1; + a = (struct __sai__GetRealmAuthOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetRealmAuthOptions, sizeof(struct __sai__GetRealmAuthOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetRealmAuthOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetRealmAuthOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetRealmAuthOptions(soap, "sai:GetRealmAuthOptions", &a->sai__GetRealmAuthOptions, "")) + { soap_flag_sai__GetRealmAuthOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetRealmAuthOptions * SOAP_FMAC6 soap_new___sai__GetRealmAuthOptions(struct soap *soap, int n) +{ return soap_instantiate___sai__GetRealmAuthOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetRealmAuthOptions(struct soap *soap, struct __sai__GetRealmAuthOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetRealmAuthOptions * SOAP_FMAC4 soap_instantiate___sai__GetRealmAuthOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetRealmAuthOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetRealmAuthOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetRealmAuthOptions; + if (size) + *size = sizeof(struct __sai__GetRealmAuthOptions); + } + else + { cp->ptr = (void*)new struct __sai__GetRealmAuthOptions[n]; + if (size) + *size = n * sizeof(struct __sai__GetRealmAuthOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetRealmAuthOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetRealmAuthOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetRealmAuthOptions %p -> %p\n", q, p)); + *(struct __sai__GetRealmAuthOptions*)p = *(struct __sai__GetRealmAuthOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__ExtendProvisioningPeriod(struct soap *soap, const struct __sai__ExtendProvisioningPeriod *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__ExtendProvisioningPeriod(soap, &a->sai__ExtendProvisioningPeriod); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__ExtendProvisioningPeriod(struct soap *soap, struct __sai__ExtendProvisioningPeriod *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__ExtendProvisioningPeriod = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__ExtendProvisioningPeriod(struct soap *soap, const struct __sai__ExtendProvisioningPeriod *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__ExtendProvisioningPeriod(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__ExtendProvisioningPeriod(struct soap *soap, const char *tag, int id, const struct __sai__ExtendProvisioningPeriod *a, const char *type) +{ + soap_out_PointerTo_sai__ExtendProvisioningPeriod(soap, "sai:ExtendProvisioningPeriod", -1, &a->sai__ExtendProvisioningPeriod, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_get___sai__ExtendProvisioningPeriod(struct soap *soap, struct __sai__ExtendProvisioningPeriod *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__ExtendProvisioningPeriod(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_in___sai__ExtendProvisioningPeriod(struct soap *soap, const char *tag, struct __sai__ExtendProvisioningPeriod *a, const char *type) +{ + short soap_flag_sai__ExtendProvisioningPeriod = 1; + a = (struct __sai__ExtendProvisioningPeriod *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__ExtendProvisioningPeriod, sizeof(struct __sai__ExtendProvisioningPeriod), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__ExtendProvisioningPeriod(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__ExtendProvisioningPeriod && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__ExtendProvisioningPeriod(soap, "sai:ExtendProvisioningPeriod", &a->sai__ExtendProvisioningPeriod, "")) + { soap_flag_sai__ExtendProvisioningPeriod--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__ExtendProvisioningPeriod * SOAP_FMAC6 soap_new___sai__ExtendProvisioningPeriod(struct soap *soap, int n) +{ return soap_instantiate___sai__ExtendProvisioningPeriod(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__ExtendProvisioningPeriod(struct soap *soap, struct __sai__ExtendProvisioningPeriod *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__ExtendProvisioningPeriod * SOAP_FMAC4 soap_instantiate___sai__ExtendProvisioningPeriod(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__ExtendProvisioningPeriod(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__ExtendProvisioningPeriod, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__ExtendProvisioningPeriod; + if (size) + *size = sizeof(struct __sai__ExtendProvisioningPeriod); + } + else + { cp->ptr = (void*)new struct __sai__ExtendProvisioningPeriod[n]; + if (size) + *size = n * sizeof(struct __sai__ExtendProvisioningPeriod); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__ExtendProvisioningPeriod*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__ExtendProvisioningPeriod(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__ExtendProvisioningPeriod %p -> %p\n", q, p)); + *(struct __sai__ExtendProvisioningPeriod*)p = *(struct __sai__ExtendProvisioningPeriod*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetProvisioningPID(struct soap *soap, const struct __sai__GetProvisioningPID *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetProvisioningPID(soap, &a->sai__GetProvisioningPID); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetProvisioningPID(struct soap *soap, struct __sai__GetProvisioningPID *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetProvisioningPID = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetProvisioningPID(struct soap *soap, const struct __sai__GetProvisioningPID *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetProvisioningPID(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetProvisioningPID(struct soap *soap, const char *tag, int id, const struct __sai__GetProvisioningPID *a, const char *type) +{ + soap_out_PointerTo_sai__GetProvisioningPID(soap, "sai:GetProvisioningPID", -1, &a->sai__GetProvisioningPID, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetProvisioningPID * SOAP_FMAC4 soap_get___sai__GetProvisioningPID(struct soap *soap, struct __sai__GetProvisioningPID *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetProvisioningPID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetProvisioningPID * SOAP_FMAC4 soap_in___sai__GetProvisioningPID(struct soap *soap, const char *tag, struct __sai__GetProvisioningPID *a, const char *type) +{ + short soap_flag_sai__GetProvisioningPID = 1; + a = (struct __sai__GetProvisioningPID *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetProvisioningPID, sizeof(struct __sai__GetProvisioningPID), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetProvisioningPID(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetProvisioningPID && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetProvisioningPID(soap, "sai:GetProvisioningPID", &a->sai__GetProvisioningPID, "")) + { soap_flag_sai__GetProvisioningPID--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetProvisioningPID * SOAP_FMAC6 soap_new___sai__GetProvisioningPID(struct soap *soap, int n) +{ return soap_instantiate___sai__GetProvisioningPID(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetProvisioningPID(struct soap *soap, struct __sai__GetProvisioningPID *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetProvisioningPID * SOAP_FMAC4 soap_instantiate___sai__GetProvisioningPID(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetProvisioningPID(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetProvisioningPID, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetProvisioningPID; + if (size) + *size = sizeof(struct __sai__GetProvisioningPID); + } + else + { cp->ptr = (void*)new struct __sai__GetProvisioningPID[n]; + if (size) + *size = n * sizeof(struct __sai__GetProvisioningPID); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetProvisioningPID*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetProvisioningPID(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetProvisioningPID %p -> %p\n", q, p)); + *(struct __sai__GetProvisioningPID*)p = *(struct __sai__GetProvisioningPID*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetProvisioningAuditRecord(struct soap *soap, const struct __sai__GetProvisioningAuditRecord *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetProvisioningAuditRecord(soap, &a->sai__GetProvisioningAuditRecord); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetProvisioningAuditRecord(struct soap *soap, struct __sai__GetProvisioningAuditRecord *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetProvisioningAuditRecord = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetProvisioningAuditRecord(struct soap *soap, const struct __sai__GetProvisioningAuditRecord *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetProvisioningAuditRecord(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetProvisioningAuditRecord(struct soap *soap, const char *tag, int id, const struct __sai__GetProvisioningAuditRecord *a, const char *type) +{ + soap_out_PointerTo_sai__GetProvisioningAuditRecord(soap, "sai:GetProvisioningAuditRecord", -1, &a->sai__GetProvisioningAuditRecord, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_get___sai__GetProvisioningAuditRecord(struct soap *soap, struct __sai__GetProvisioningAuditRecord *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetProvisioningAuditRecord(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_in___sai__GetProvisioningAuditRecord(struct soap *soap, const char *tag, struct __sai__GetProvisioningAuditRecord *a, const char *type) +{ + short soap_flag_sai__GetProvisioningAuditRecord = 1; + a = (struct __sai__GetProvisioningAuditRecord *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetProvisioningAuditRecord, sizeof(struct __sai__GetProvisioningAuditRecord), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetProvisioningAuditRecord(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetProvisioningAuditRecord && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetProvisioningAuditRecord(soap, "sai:GetProvisioningAuditRecord", &a->sai__GetProvisioningAuditRecord, "")) + { soap_flag_sai__GetProvisioningAuditRecord--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetProvisioningAuditRecord * SOAP_FMAC6 soap_new___sai__GetProvisioningAuditRecord(struct soap *soap, int n) +{ return soap_instantiate___sai__GetProvisioningAuditRecord(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetProvisioningAuditRecord(struct soap *soap, struct __sai__GetProvisioningAuditRecord *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetProvisioningAuditRecord * SOAP_FMAC4 soap_instantiate___sai__GetProvisioningAuditRecord(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetProvisioningAuditRecord(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetProvisioningAuditRecord, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetProvisioningAuditRecord; + if (size) + *size = sizeof(struct __sai__GetProvisioningAuditRecord); + } + else + { cp->ptr = (void*)new struct __sai__GetProvisioningAuditRecord[n]; + if (size) + *size = n * sizeof(struct __sai__GetProvisioningAuditRecord); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetProvisioningAuditRecord*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetProvisioningAuditRecord(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetProvisioningAuditRecord %p -> %p\n", q, p)); + *(struct __sai__GetProvisioningAuditRecord*)p = *(struct __sai__GetProvisioningAuditRecord*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetZeroTouchConfigurationMode(struct soap *soap, const struct __sai__SetZeroTouchConfigurationMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetZeroTouchConfigurationMode(soap, &a->sai__SetZeroTouchConfigurationMode); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetZeroTouchConfigurationMode(struct soap *soap, struct __sai__SetZeroTouchConfigurationMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetZeroTouchConfigurationMode = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetZeroTouchConfigurationMode(struct soap *soap, const struct __sai__SetZeroTouchConfigurationMode *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetZeroTouchConfigurationMode(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetZeroTouchConfigurationMode(struct soap *soap, const char *tag, int id, const struct __sai__SetZeroTouchConfigurationMode *a, const char *type) +{ + soap_out_PointerTo_sai__SetZeroTouchConfigurationMode(soap, "sai:SetZeroTouchConfigurationMode", -1, &a->sai__SetZeroTouchConfigurationMode, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_get___sai__SetZeroTouchConfigurationMode(struct soap *soap, struct __sai__SetZeroTouchConfigurationMode *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetZeroTouchConfigurationMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_in___sai__SetZeroTouchConfigurationMode(struct soap *soap, const char *tag, struct __sai__SetZeroTouchConfigurationMode *a, const char *type) +{ + short soap_flag_sai__SetZeroTouchConfigurationMode = 1; + a = (struct __sai__SetZeroTouchConfigurationMode *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetZeroTouchConfigurationMode, sizeof(struct __sai__SetZeroTouchConfigurationMode), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetZeroTouchConfigurationMode(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetZeroTouchConfigurationMode && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetZeroTouchConfigurationMode(soap, "sai:SetZeroTouchConfigurationMode", &a->sai__SetZeroTouchConfigurationMode, "")) + { soap_flag_sai__SetZeroTouchConfigurationMode--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetZeroTouchConfigurationMode * SOAP_FMAC6 soap_new___sai__SetZeroTouchConfigurationMode(struct soap *soap, int n) +{ return soap_instantiate___sai__SetZeroTouchConfigurationMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetZeroTouchConfigurationMode(struct soap *soap, struct __sai__SetZeroTouchConfigurationMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetZeroTouchConfigurationMode * SOAP_FMAC4 soap_instantiate___sai__SetZeroTouchConfigurationMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetZeroTouchConfigurationMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetZeroTouchConfigurationMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetZeroTouchConfigurationMode; + if (size) + *size = sizeof(struct __sai__SetZeroTouchConfigurationMode); + } + else + { cp->ptr = (void*)new struct __sai__SetZeroTouchConfigurationMode[n]; + if (size) + *size = n * sizeof(struct __sai__SetZeroTouchConfigurationMode); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetZeroTouchConfigurationMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetZeroTouchConfigurationMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetZeroTouchConfigurationMode %p -> %p\n", q, p)); + *(struct __sai__SetZeroTouchConfigurationMode*)p = *(struct __sai__SetZeroTouchConfigurationMode*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetZeroTouchConfigurationMode(struct soap *soap, const struct __sai__GetZeroTouchConfigurationMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetZeroTouchConfigurationMode(soap, &a->sai__GetZeroTouchConfigurationMode); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetZeroTouchConfigurationMode(struct soap *soap, struct __sai__GetZeroTouchConfigurationMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetZeroTouchConfigurationMode = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetZeroTouchConfigurationMode(struct soap *soap, const struct __sai__GetZeroTouchConfigurationMode *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetZeroTouchConfigurationMode(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetZeroTouchConfigurationMode(struct soap *soap, const char *tag, int id, const struct __sai__GetZeroTouchConfigurationMode *a, const char *type) +{ + soap_out_PointerTo_sai__GetZeroTouchConfigurationMode(soap, "sai:GetZeroTouchConfigurationMode", -1, &a->sai__GetZeroTouchConfigurationMode, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_get___sai__GetZeroTouchConfigurationMode(struct soap *soap, struct __sai__GetZeroTouchConfigurationMode *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetZeroTouchConfigurationMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_in___sai__GetZeroTouchConfigurationMode(struct soap *soap, const char *tag, struct __sai__GetZeroTouchConfigurationMode *a, const char *type) +{ + short soap_flag_sai__GetZeroTouchConfigurationMode = 1; + a = (struct __sai__GetZeroTouchConfigurationMode *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetZeroTouchConfigurationMode, sizeof(struct __sai__GetZeroTouchConfigurationMode), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetZeroTouchConfigurationMode(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetZeroTouchConfigurationMode && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetZeroTouchConfigurationMode(soap, "sai:GetZeroTouchConfigurationMode", &a->sai__GetZeroTouchConfigurationMode, "")) + { soap_flag_sai__GetZeroTouchConfigurationMode--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetZeroTouchConfigurationMode * SOAP_FMAC6 soap_new___sai__GetZeroTouchConfigurationMode(struct soap *soap, int n) +{ return soap_instantiate___sai__GetZeroTouchConfigurationMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetZeroTouchConfigurationMode(struct soap *soap, struct __sai__GetZeroTouchConfigurationMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetZeroTouchConfigurationMode * SOAP_FMAC4 soap_instantiate___sai__GetZeroTouchConfigurationMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetZeroTouchConfigurationMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetZeroTouchConfigurationMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetZeroTouchConfigurationMode; + if (size) + *size = sizeof(struct __sai__GetZeroTouchConfigurationMode); + } + else + { cp->ptr = (void*)new struct __sai__GetZeroTouchConfigurationMode[n]; + if (size) + *size = n * sizeof(struct __sai__GetZeroTouchConfigurationMode); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetZeroTouchConfigurationMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetZeroTouchConfigurationMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetZeroTouchConfigurationMode %p -> %p\n", q, p)); + *(struct __sai__GetZeroTouchConfigurationMode*)p = *(struct __sai__GetZeroTouchConfigurationMode*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnableCertificateHashEntry(struct soap *soap, const struct __sai__EnableCertificateHashEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__EnableCertificateHashEntry(soap, &a->sai__EnableCertificateHashEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnableCertificateHashEntry(struct soap *soap, struct __sai__EnableCertificateHashEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__EnableCertificateHashEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnableCertificateHashEntry(struct soap *soap, const struct __sai__EnableCertificateHashEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__EnableCertificateHashEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnableCertificateHashEntry(struct soap *soap, const char *tag, int id, const struct __sai__EnableCertificateHashEntry *a, const char *type) +{ + soap_out_PointerTo_sai__EnableCertificateHashEntry(soap, "sai:EnableCertificateHashEntry", -1, &a->sai__EnableCertificateHashEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_get___sai__EnableCertificateHashEntry(struct soap *soap, struct __sai__EnableCertificateHashEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__EnableCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_in___sai__EnableCertificateHashEntry(struct soap *soap, const char *tag, struct __sai__EnableCertificateHashEntry *a, const char *type) +{ + short soap_flag_sai__EnableCertificateHashEntry = 1; + a = (struct __sai__EnableCertificateHashEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__EnableCertificateHashEntry, sizeof(struct __sai__EnableCertificateHashEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__EnableCertificateHashEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__EnableCertificateHashEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__EnableCertificateHashEntry(soap, "sai:EnableCertificateHashEntry", &a->sai__EnableCertificateHashEntry, "")) + { soap_flag_sai__EnableCertificateHashEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__EnableCertificateHashEntry * SOAP_FMAC6 soap_new___sai__EnableCertificateHashEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__EnableCertificateHashEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnableCertificateHashEntry(struct soap *soap, struct __sai__EnableCertificateHashEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__EnableCertificateHashEntry * SOAP_FMAC4 soap_instantiate___sai__EnableCertificateHashEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__EnableCertificateHashEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__EnableCertificateHashEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__EnableCertificateHashEntry; + if (size) + *size = sizeof(struct __sai__EnableCertificateHashEntry); + } + else + { cp->ptr = (void*)new struct __sai__EnableCertificateHashEntry[n]; + if (size) + *size = n * sizeof(struct __sai__EnableCertificateHashEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__EnableCertificateHashEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnableCertificateHashEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__EnableCertificateHashEntry %p -> %p\n", q, p)); + *(struct __sai__EnableCertificateHashEntry*)p = *(struct __sai__EnableCertificateHashEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__DeleteCertificateHashEntry(struct soap *soap, const struct __sai__DeleteCertificateHashEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__DeleteCertificateHashEntry(soap, &a->sai__DeleteCertificateHashEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__DeleteCertificateHashEntry(struct soap *soap, struct __sai__DeleteCertificateHashEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__DeleteCertificateHashEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__DeleteCertificateHashEntry(struct soap *soap, const struct __sai__DeleteCertificateHashEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__DeleteCertificateHashEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__DeleteCertificateHashEntry(struct soap *soap, const char *tag, int id, const struct __sai__DeleteCertificateHashEntry *a, const char *type) +{ + soap_out_PointerTo_sai__DeleteCertificateHashEntry(soap, "sai:DeleteCertificateHashEntry", -1, &a->sai__DeleteCertificateHashEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_get___sai__DeleteCertificateHashEntry(struct soap *soap, struct __sai__DeleteCertificateHashEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__DeleteCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_in___sai__DeleteCertificateHashEntry(struct soap *soap, const char *tag, struct __sai__DeleteCertificateHashEntry *a, const char *type) +{ + short soap_flag_sai__DeleteCertificateHashEntry = 1; + a = (struct __sai__DeleteCertificateHashEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__DeleteCertificateHashEntry, sizeof(struct __sai__DeleteCertificateHashEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__DeleteCertificateHashEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__DeleteCertificateHashEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__DeleteCertificateHashEntry(soap, "sai:DeleteCertificateHashEntry", &a->sai__DeleteCertificateHashEntry, "")) + { soap_flag_sai__DeleteCertificateHashEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__DeleteCertificateHashEntry * SOAP_FMAC6 soap_new___sai__DeleteCertificateHashEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__DeleteCertificateHashEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__DeleteCertificateHashEntry(struct soap *soap, struct __sai__DeleteCertificateHashEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__DeleteCertificateHashEntry * SOAP_FMAC4 soap_instantiate___sai__DeleteCertificateHashEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__DeleteCertificateHashEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__DeleteCertificateHashEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__DeleteCertificateHashEntry; + if (size) + *size = sizeof(struct __sai__DeleteCertificateHashEntry); + } + else + { cp->ptr = (void*)new struct __sai__DeleteCertificateHashEntry[n]; + if (size) + *size = n * sizeof(struct __sai__DeleteCertificateHashEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__DeleteCertificateHashEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__DeleteCertificateHashEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__DeleteCertificateHashEntry %p -> %p\n", q, p)); + *(struct __sai__DeleteCertificateHashEntry*)p = *(struct __sai__DeleteCertificateHashEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__AddCertificateHashEntry(struct soap *soap, const struct __sai__AddCertificateHashEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__AddCertificateHashEntry(soap, &a->sai__AddCertificateHashEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__AddCertificateHashEntry(struct soap *soap, struct __sai__AddCertificateHashEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__AddCertificateHashEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__AddCertificateHashEntry(struct soap *soap, const struct __sai__AddCertificateHashEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__AddCertificateHashEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__AddCertificateHashEntry(struct soap *soap, const char *tag, int id, const struct __sai__AddCertificateHashEntry *a, const char *type) +{ + soap_out_PointerTo_sai__AddCertificateHashEntry(soap, "sai:AddCertificateHashEntry", -1, &a->sai__AddCertificateHashEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__AddCertificateHashEntry * SOAP_FMAC4 soap_get___sai__AddCertificateHashEntry(struct soap *soap, struct __sai__AddCertificateHashEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__AddCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__AddCertificateHashEntry * SOAP_FMAC4 soap_in___sai__AddCertificateHashEntry(struct soap *soap, const char *tag, struct __sai__AddCertificateHashEntry *a, const char *type) +{ + short soap_flag_sai__AddCertificateHashEntry = 1; + a = (struct __sai__AddCertificateHashEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__AddCertificateHashEntry, sizeof(struct __sai__AddCertificateHashEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__AddCertificateHashEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__AddCertificateHashEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__AddCertificateHashEntry(soap, "sai:AddCertificateHashEntry", &a->sai__AddCertificateHashEntry, "")) + { soap_flag_sai__AddCertificateHashEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__AddCertificateHashEntry * SOAP_FMAC6 soap_new___sai__AddCertificateHashEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__AddCertificateHashEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__AddCertificateHashEntry(struct soap *soap, struct __sai__AddCertificateHashEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__AddCertificateHashEntry * SOAP_FMAC4 soap_instantiate___sai__AddCertificateHashEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__AddCertificateHashEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__AddCertificateHashEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__AddCertificateHashEntry; + if (size) + *size = sizeof(struct __sai__AddCertificateHashEntry); + } + else + { cp->ptr = (void*)new struct __sai__AddCertificateHashEntry[n]; + if (size) + *size = n * sizeof(struct __sai__AddCertificateHashEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__AddCertificateHashEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__AddCertificateHashEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__AddCertificateHashEntry %p -> %p\n", q, p)); + *(struct __sai__AddCertificateHashEntry*)p = *(struct __sai__AddCertificateHashEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetCertificateHashEntry(struct soap *soap, const struct __sai__GetCertificateHashEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetCertificateHashEntry(soap, &a->sai__GetCertificateHashEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetCertificateHashEntry(struct soap *soap, struct __sai__GetCertificateHashEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetCertificateHashEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetCertificateHashEntry(struct soap *soap, const struct __sai__GetCertificateHashEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetCertificateHashEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetCertificateHashEntry(struct soap *soap, const char *tag, int id, const struct __sai__GetCertificateHashEntry *a, const char *type) +{ + soap_out_PointerTo_sai__GetCertificateHashEntry(soap, "sai:GetCertificateHashEntry", -1, &a->sai__GetCertificateHashEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetCertificateHashEntry * SOAP_FMAC4 soap_get___sai__GetCertificateHashEntry(struct soap *soap, struct __sai__GetCertificateHashEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetCertificateHashEntry * SOAP_FMAC4 soap_in___sai__GetCertificateHashEntry(struct soap *soap, const char *tag, struct __sai__GetCertificateHashEntry *a, const char *type) +{ + short soap_flag_sai__GetCertificateHashEntry = 1; + a = (struct __sai__GetCertificateHashEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetCertificateHashEntry, sizeof(struct __sai__GetCertificateHashEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetCertificateHashEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetCertificateHashEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetCertificateHashEntry(soap, "sai:GetCertificateHashEntry", &a->sai__GetCertificateHashEntry, "")) + { soap_flag_sai__GetCertificateHashEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetCertificateHashEntry * SOAP_FMAC6 soap_new___sai__GetCertificateHashEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__GetCertificateHashEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetCertificateHashEntry(struct soap *soap, struct __sai__GetCertificateHashEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetCertificateHashEntry * SOAP_FMAC4 soap_instantiate___sai__GetCertificateHashEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetCertificateHashEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetCertificateHashEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetCertificateHashEntry; + if (size) + *size = sizeof(struct __sai__GetCertificateHashEntry); + } + else + { cp->ptr = (void*)new struct __sai__GetCertificateHashEntry[n]; + if (size) + *size = n * sizeof(struct __sai__GetCertificateHashEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetCertificateHashEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetCertificateHashEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetCertificateHashEntry %p -> %p\n", q, p)); + *(struct __sai__GetCertificateHashEntry*)p = *(struct __sai__GetCertificateHashEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnumerateCertificateHashEntries(struct soap *soap, const struct __sai__EnumerateCertificateHashEntries *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__EnumerateCertificateHashEntries(soap, &a->sai__EnumerateCertificateHashEntries); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnumerateCertificateHashEntries(struct soap *soap, struct __sai__EnumerateCertificateHashEntries *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__EnumerateCertificateHashEntries = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnumerateCertificateHashEntries(struct soap *soap, const struct __sai__EnumerateCertificateHashEntries *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__EnumerateCertificateHashEntries(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnumerateCertificateHashEntries(struct soap *soap, const char *tag, int id, const struct __sai__EnumerateCertificateHashEntries *a, const char *type) +{ + soap_out_PointerTo_sai__EnumerateCertificateHashEntries(soap, "sai:EnumerateCertificateHashEntries", -1, &a->sai__EnumerateCertificateHashEntries, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_get___sai__EnumerateCertificateHashEntries(struct soap *soap, struct __sai__EnumerateCertificateHashEntries *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__EnumerateCertificateHashEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_in___sai__EnumerateCertificateHashEntries(struct soap *soap, const char *tag, struct __sai__EnumerateCertificateHashEntries *a, const char *type) +{ + short soap_flag_sai__EnumerateCertificateHashEntries = 1; + a = (struct __sai__EnumerateCertificateHashEntries *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__EnumerateCertificateHashEntries, sizeof(struct __sai__EnumerateCertificateHashEntries), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__EnumerateCertificateHashEntries(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__EnumerateCertificateHashEntries && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__EnumerateCertificateHashEntries(soap, "sai:EnumerateCertificateHashEntries", &a->sai__EnumerateCertificateHashEntries, "")) + { soap_flag_sai__EnumerateCertificateHashEntries--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__EnumerateCertificateHashEntries * SOAP_FMAC6 soap_new___sai__EnumerateCertificateHashEntries(struct soap *soap, int n) +{ return soap_instantiate___sai__EnumerateCertificateHashEntries(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnumerateCertificateHashEntries(struct soap *soap, struct __sai__EnumerateCertificateHashEntries *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__EnumerateCertificateHashEntries * SOAP_FMAC4 soap_instantiate___sai__EnumerateCertificateHashEntries(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__EnumerateCertificateHashEntries(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__EnumerateCertificateHashEntries, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__EnumerateCertificateHashEntries; + if (size) + *size = sizeof(struct __sai__EnumerateCertificateHashEntries); + } + else + { cp->ptr = (void*)new struct __sai__EnumerateCertificateHashEntries[n]; + if (size) + *size = n * sizeof(struct __sai__EnumerateCertificateHashEntries); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__EnumerateCertificateHashEntries*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnumerateCertificateHashEntries(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__EnumerateCertificateHashEntries %p -> %p\n", q, p)); + *(struct __sai__EnumerateCertificateHashEntries*)p = *(struct __sai__EnumerateCertificateHashEntries*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetProvisioningServerOTP(struct soap *soap, const struct __sai__GetProvisioningServerOTP *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetProvisioningServerOTP(soap, &a->sai__GetProvisioningServerOTP); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetProvisioningServerOTP(struct soap *soap, struct __sai__GetProvisioningServerOTP *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetProvisioningServerOTP = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetProvisioningServerOTP(struct soap *soap, const struct __sai__GetProvisioningServerOTP *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetProvisioningServerOTP(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetProvisioningServerOTP(struct soap *soap, const char *tag, int id, const struct __sai__GetProvisioningServerOTP *a, const char *type) +{ + soap_out_PointerTo_sai__GetProvisioningServerOTP(soap, "sai:GetProvisioningServerOTP", -1, &a->sai__GetProvisioningServerOTP, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_get___sai__GetProvisioningServerOTP(struct soap *soap, struct __sai__GetProvisioningServerOTP *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetProvisioningServerOTP(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_in___sai__GetProvisioningServerOTP(struct soap *soap, const char *tag, struct __sai__GetProvisioningServerOTP *a, const char *type) +{ + short soap_flag_sai__GetProvisioningServerOTP = 1; + a = (struct __sai__GetProvisioningServerOTP *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetProvisioningServerOTP, sizeof(struct __sai__GetProvisioningServerOTP), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetProvisioningServerOTP(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetProvisioningServerOTP && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetProvisioningServerOTP(soap, "sai:GetProvisioningServerOTP", &a->sai__GetProvisioningServerOTP, "")) + { soap_flag_sai__GetProvisioningServerOTP--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetProvisioningServerOTP * SOAP_FMAC6 soap_new___sai__GetProvisioningServerOTP(struct soap *soap, int n) +{ return soap_instantiate___sai__GetProvisioningServerOTP(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetProvisioningServerOTP(struct soap *soap, struct __sai__GetProvisioningServerOTP *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetProvisioningServerOTP * SOAP_FMAC4 soap_instantiate___sai__GetProvisioningServerOTP(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetProvisioningServerOTP(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetProvisioningServerOTP, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetProvisioningServerOTP; + if (size) + *size = sizeof(struct __sai__GetProvisioningServerOTP); + } + else + { cp->ptr = (void*)new struct __sai__GetProvisioningServerOTP[n]; + if (size) + *size = n * sizeof(struct __sai__GetProvisioningServerOTP); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetProvisioningServerOTP*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetProvisioningServerOTP(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetProvisioningServerOTP %p -> %p\n", q, p)); + *(struct __sai__GetProvisioningServerOTP*)p = *(struct __sai__GetProvisioningServerOTP*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetProvisioningServerOTP(struct soap *soap, const struct __sai__SetProvisioningServerOTP *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetProvisioningServerOTP(soap, &a->sai__SetProvisioningServerOTP); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetProvisioningServerOTP(struct soap *soap, struct __sai__SetProvisioningServerOTP *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetProvisioningServerOTP = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetProvisioningServerOTP(struct soap *soap, const struct __sai__SetProvisioningServerOTP *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetProvisioningServerOTP(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetProvisioningServerOTP(struct soap *soap, const char *tag, int id, const struct __sai__SetProvisioningServerOTP *a, const char *type) +{ + soap_out_PointerTo_sai__SetProvisioningServerOTP(soap, "sai:SetProvisioningServerOTP", -1, &a->sai__SetProvisioningServerOTP, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_get___sai__SetProvisioningServerOTP(struct soap *soap, struct __sai__SetProvisioningServerOTP *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetProvisioningServerOTP(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_in___sai__SetProvisioningServerOTP(struct soap *soap, const char *tag, struct __sai__SetProvisioningServerOTP *a, const char *type) +{ + short soap_flag_sai__SetProvisioningServerOTP = 1; + a = (struct __sai__SetProvisioningServerOTP *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetProvisioningServerOTP, sizeof(struct __sai__SetProvisioningServerOTP), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetProvisioningServerOTP(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetProvisioningServerOTP && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetProvisioningServerOTP(soap, "sai:SetProvisioningServerOTP", &a->sai__SetProvisioningServerOTP, "")) + { soap_flag_sai__SetProvisioningServerOTP--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetProvisioningServerOTP * SOAP_FMAC6 soap_new___sai__SetProvisioningServerOTP(struct soap *soap, int n) +{ return soap_instantiate___sai__SetProvisioningServerOTP(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetProvisioningServerOTP(struct soap *soap, struct __sai__SetProvisioningServerOTP *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetProvisioningServerOTP * SOAP_FMAC4 soap_instantiate___sai__SetProvisioningServerOTP(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetProvisioningServerOTP(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetProvisioningServerOTP, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetProvisioningServerOTP; + if (size) + *size = sizeof(struct __sai__SetProvisioningServerOTP); + } + else + { cp->ptr = (void*)new struct __sai__SetProvisioningServerOTP[n]; + if (size) + *size = n * sizeof(struct __sai__SetProvisioningServerOTP); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetProvisioningServerOTP*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetProvisioningServerOTP(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetProvisioningServerOTP %p -> %p\n", q, p)); + *(struct __sai__SetProvisioningServerOTP*)p = *(struct __sai__SetProvisioningServerOTP*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetMEBxPassword(struct soap *soap, const struct __sai__SetMEBxPassword *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetMEBxPassword(soap, &a->sai__SetMEBxPassword); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetMEBxPassword(struct soap *soap, struct __sai__SetMEBxPassword *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetMEBxPassword = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetMEBxPassword(struct soap *soap, const struct __sai__SetMEBxPassword *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetMEBxPassword(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetMEBxPassword(struct soap *soap, const char *tag, int id, const struct __sai__SetMEBxPassword *a, const char *type) +{ + soap_out_PointerTo_sai__SetMEBxPassword(soap, "sai:SetMEBxPassword", -1, &a->sai__SetMEBxPassword, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetMEBxPassword * SOAP_FMAC4 soap_get___sai__SetMEBxPassword(struct soap *soap, struct __sai__SetMEBxPassword *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetMEBxPassword(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetMEBxPassword * SOAP_FMAC4 soap_in___sai__SetMEBxPassword(struct soap *soap, const char *tag, struct __sai__SetMEBxPassword *a, const char *type) +{ + short soap_flag_sai__SetMEBxPassword = 1; + a = (struct __sai__SetMEBxPassword *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetMEBxPassword, sizeof(struct __sai__SetMEBxPassword), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetMEBxPassword(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetMEBxPassword && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetMEBxPassword(soap, "sai:SetMEBxPassword", &a->sai__SetMEBxPassword, "")) + { soap_flag_sai__SetMEBxPassword--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetMEBxPassword * SOAP_FMAC6 soap_new___sai__SetMEBxPassword(struct soap *soap, int n) +{ return soap_instantiate___sai__SetMEBxPassword(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetMEBxPassword(struct soap *soap, struct __sai__SetMEBxPassword *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetMEBxPassword * SOAP_FMAC4 soap_instantiate___sai__SetMEBxPassword(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetMEBxPassword(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetMEBxPassword, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetMEBxPassword; + if (size) + *size = sizeof(struct __sai__SetMEBxPassword); + } + else + { cp->ptr = (void*)new struct __sai__SetMEBxPassword[n]; + if (size) + *size = n * sizeof(struct __sai__SetMEBxPassword); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetMEBxPassword*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetMEBxPassword(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetMEBxPassword %p -> %p\n", q, p)); + *(struct __sai__SetMEBxPassword*)p = *(struct __sai__SetMEBxPassword*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__PartialUnprovision(struct soap *soap, const struct __sai__PartialUnprovision *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__PartialUnprovision(soap, &a->sai__PartialUnprovision); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__PartialUnprovision(struct soap *soap, struct __sai__PartialUnprovision *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__PartialUnprovision = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__PartialUnprovision(struct soap *soap, const struct __sai__PartialUnprovision *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__PartialUnprovision(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__PartialUnprovision(struct soap *soap, const char *tag, int id, const struct __sai__PartialUnprovision *a, const char *type) +{ + soap_out_PointerTo_sai__PartialUnprovision(soap, "sai:PartialUnprovision", -1, &a->sai__PartialUnprovision, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__PartialUnprovision * SOAP_FMAC4 soap_get___sai__PartialUnprovision(struct soap *soap, struct __sai__PartialUnprovision *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__PartialUnprovision(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__PartialUnprovision * SOAP_FMAC4 soap_in___sai__PartialUnprovision(struct soap *soap, const char *tag, struct __sai__PartialUnprovision *a, const char *type) +{ + short soap_flag_sai__PartialUnprovision = 1; + a = (struct __sai__PartialUnprovision *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__PartialUnprovision, sizeof(struct __sai__PartialUnprovision), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__PartialUnprovision(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__PartialUnprovision && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__PartialUnprovision(soap, "sai:PartialUnprovision", &a->sai__PartialUnprovision, "")) + { soap_flag_sai__PartialUnprovision--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__PartialUnprovision * SOAP_FMAC6 soap_new___sai__PartialUnprovision(struct soap *soap, int n) +{ return soap_instantiate___sai__PartialUnprovision(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__PartialUnprovision(struct soap *soap, struct __sai__PartialUnprovision *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__PartialUnprovision * SOAP_FMAC4 soap_instantiate___sai__PartialUnprovision(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__PartialUnprovision(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__PartialUnprovision, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__PartialUnprovision; + if (size) + *size = sizeof(struct __sai__PartialUnprovision); + } + else + { cp->ptr = (void*)new struct __sai__PartialUnprovision[n]; + if (size) + *size = n * sizeof(struct __sai__PartialUnprovision); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__PartialUnprovision*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__PartialUnprovision(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__PartialUnprovision %p -> %p\n", q, p)); + *(struct __sai__PartialUnprovision*)p = *(struct __sai__PartialUnprovision*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTLSPSK(struct soap *soap, const struct __sai__SetTLSPSK *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetTLSPSK(soap, &a->sai__SetTLSPSK); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTLSPSK(struct soap *soap, struct __sai__SetTLSPSK *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetTLSPSK = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTLSPSK(struct soap *soap, const struct __sai__SetTLSPSK *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetTLSPSK(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTLSPSK(struct soap *soap, const char *tag, int id, const struct __sai__SetTLSPSK *a, const char *type) +{ + soap_out_PointerTo_sai__SetTLSPSK(soap, "sai:SetTLSPSK", -1, &a->sai__SetTLSPSK, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetTLSPSK * SOAP_FMAC4 soap_get___sai__SetTLSPSK(struct soap *soap, struct __sai__SetTLSPSK *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetTLSPSK(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetTLSPSK * SOAP_FMAC4 soap_in___sai__SetTLSPSK(struct soap *soap, const char *tag, struct __sai__SetTLSPSK *a, const char *type) +{ + short soap_flag_sai__SetTLSPSK = 1; + a = (struct __sai__SetTLSPSK *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetTLSPSK, sizeof(struct __sai__SetTLSPSK), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetTLSPSK(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetTLSPSK && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetTLSPSK(soap, "sai:SetTLSPSK", &a->sai__SetTLSPSK, "")) + { soap_flag_sai__SetTLSPSK--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetTLSPSK * SOAP_FMAC6 soap_new___sai__SetTLSPSK(struct soap *soap, int n) +{ return soap_instantiate___sai__SetTLSPSK(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTLSPSK(struct soap *soap, struct __sai__SetTLSPSK *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetTLSPSK * SOAP_FMAC4 soap_instantiate___sai__SetTLSPSK(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetTLSPSK(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetTLSPSK, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetTLSPSK; + if (size) + *size = sizeof(struct __sai__SetTLSPSK); + } + else + { cp->ptr = (void*)new struct __sai__SetTLSPSK[n]; + if (size) + *size = n * sizeof(struct __sai__SetTLSPSK); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetTLSPSK*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTLSPSK(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetTLSPSK %p -> %p\n", q, p)); + *(struct __sai__SetTLSPSK*)p = *(struct __sai__SetTLSPSK*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetPowerSavingOptions(struct soap *soap, const struct __sai__GetPowerSavingOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetPowerSavingOptions(soap, &a->sai__GetPowerSavingOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetPowerSavingOptions(struct soap *soap, struct __sai__GetPowerSavingOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetPowerSavingOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetPowerSavingOptions(struct soap *soap, const struct __sai__GetPowerSavingOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetPowerSavingOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetPowerSavingOptions(struct soap *soap, const char *tag, int id, const struct __sai__GetPowerSavingOptions *a, const char *type) +{ + soap_out_PointerTo_sai__GetPowerSavingOptions(soap, "sai:GetPowerSavingOptions", -1, &a->sai__GetPowerSavingOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetPowerSavingOptions * SOAP_FMAC4 soap_get___sai__GetPowerSavingOptions(struct soap *soap, struct __sai__GetPowerSavingOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetPowerSavingOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetPowerSavingOptions * SOAP_FMAC4 soap_in___sai__GetPowerSavingOptions(struct soap *soap, const char *tag, struct __sai__GetPowerSavingOptions *a, const char *type) +{ + short soap_flag_sai__GetPowerSavingOptions = 1; + a = (struct __sai__GetPowerSavingOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetPowerSavingOptions, sizeof(struct __sai__GetPowerSavingOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetPowerSavingOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetPowerSavingOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetPowerSavingOptions(soap, "sai:GetPowerSavingOptions", &a->sai__GetPowerSavingOptions, "")) + { soap_flag_sai__GetPowerSavingOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetPowerSavingOptions * SOAP_FMAC6 soap_new___sai__GetPowerSavingOptions(struct soap *soap, int n) +{ return soap_instantiate___sai__GetPowerSavingOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetPowerSavingOptions(struct soap *soap, struct __sai__GetPowerSavingOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetPowerSavingOptions * SOAP_FMAC4 soap_instantiate___sai__GetPowerSavingOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetPowerSavingOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetPowerSavingOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetPowerSavingOptions; + if (size) + *size = sizeof(struct __sai__GetPowerSavingOptions); + } + else + { cp->ptr = (void*)new struct __sai__GetPowerSavingOptions[n]; + if (size) + *size = n * sizeof(struct __sai__GetPowerSavingOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetPowerSavingOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetPowerSavingOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetPowerSavingOptions %p -> %p\n", q, p)); + *(struct __sai__GetPowerSavingOptions*)p = *(struct __sai__GetPowerSavingOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetPowerSavingOptions(struct soap *soap, const struct __sai__SetPowerSavingOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetPowerSavingOptions(soap, &a->sai__SetPowerSavingOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetPowerSavingOptions(struct soap *soap, struct __sai__SetPowerSavingOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetPowerSavingOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetPowerSavingOptions(struct soap *soap, const struct __sai__SetPowerSavingOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetPowerSavingOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetPowerSavingOptions(struct soap *soap, const char *tag, int id, const struct __sai__SetPowerSavingOptions *a, const char *type) +{ + soap_out_PointerTo_sai__SetPowerSavingOptions(soap, "sai:SetPowerSavingOptions", -1, &a->sai__SetPowerSavingOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetPowerSavingOptions * SOAP_FMAC4 soap_get___sai__SetPowerSavingOptions(struct soap *soap, struct __sai__SetPowerSavingOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetPowerSavingOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetPowerSavingOptions * SOAP_FMAC4 soap_in___sai__SetPowerSavingOptions(struct soap *soap, const char *tag, struct __sai__SetPowerSavingOptions *a, const char *type) +{ + short soap_flag_sai__SetPowerSavingOptions = 1; + a = (struct __sai__SetPowerSavingOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetPowerSavingOptions, sizeof(struct __sai__SetPowerSavingOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetPowerSavingOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetPowerSavingOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetPowerSavingOptions(soap, "sai:SetPowerSavingOptions", &a->sai__SetPowerSavingOptions, "")) + { soap_flag_sai__SetPowerSavingOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetPowerSavingOptions * SOAP_FMAC6 soap_new___sai__SetPowerSavingOptions(struct soap *soap, int n) +{ return soap_instantiate___sai__SetPowerSavingOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetPowerSavingOptions(struct soap *soap, struct __sai__SetPowerSavingOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetPowerSavingOptions * SOAP_FMAC4 soap_instantiate___sai__SetPowerSavingOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetPowerSavingOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetPowerSavingOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetPowerSavingOptions; + if (size) + *size = sizeof(struct __sai__SetPowerSavingOptions); + } + else + { cp->ptr = (void*)new struct __sai__SetPowerSavingOptions[n]; + if (size) + *size = n * sizeof(struct __sai__SetPowerSavingOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetPowerSavingOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetPowerSavingOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetPowerSavingOptions %p -> %p\n", q, p)); + *(struct __sai__SetPowerSavingOptions*)p = *(struct __sai__SetPowerSavingOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetPkiCapabilities(struct soap *soap, const struct __sai__GetPkiCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetPkiCapabilities(soap, &a->sai__GetPkiCapabilities); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetPkiCapabilities(struct soap *soap, struct __sai__GetPkiCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetPkiCapabilities = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetPkiCapabilities(struct soap *soap, const struct __sai__GetPkiCapabilities *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetPkiCapabilities(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetPkiCapabilities(struct soap *soap, const char *tag, int id, const struct __sai__GetPkiCapabilities *a, const char *type) +{ + soap_out_PointerTo_sai__GetPkiCapabilities(soap, "sai:GetPkiCapabilities", -1, &a->sai__GetPkiCapabilities, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetPkiCapabilities * SOAP_FMAC4 soap_get___sai__GetPkiCapabilities(struct soap *soap, struct __sai__GetPkiCapabilities *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetPkiCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetPkiCapabilities * SOAP_FMAC4 soap_in___sai__GetPkiCapabilities(struct soap *soap, const char *tag, struct __sai__GetPkiCapabilities *a, const char *type) +{ + short soap_flag_sai__GetPkiCapabilities = 1; + a = (struct __sai__GetPkiCapabilities *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetPkiCapabilities, sizeof(struct __sai__GetPkiCapabilities), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetPkiCapabilities(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetPkiCapabilities && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetPkiCapabilities(soap, "sai:GetPkiCapabilities", &a->sai__GetPkiCapabilities, "")) + { soap_flag_sai__GetPkiCapabilities--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetPkiCapabilities * SOAP_FMAC6 soap_new___sai__GetPkiCapabilities(struct soap *soap, int n) +{ return soap_instantiate___sai__GetPkiCapabilities(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetPkiCapabilities(struct soap *soap, struct __sai__GetPkiCapabilities *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetPkiCapabilities * SOAP_FMAC4 soap_instantiate___sai__GetPkiCapabilities(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetPkiCapabilities(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetPkiCapabilities, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetPkiCapabilities; + if (size) + *size = sizeof(struct __sai__GetPkiCapabilities); + } + else + { cp->ptr = (void*)new struct __sai__GetPkiCapabilities[n]; + if (size) + *size = n * sizeof(struct __sai__GetPkiCapabilities); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetPkiCapabilities*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetPkiCapabilities(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetPkiCapabilities %p -> %p\n", q, p)); + *(struct __sai__GetPkiCapabilities*)p = *(struct __sai__GetPkiCapabilities*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetServerCertificateReq(struct soap *soap, const struct __sai__GetServerCertificateReq *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetServerCertificateReq(soap, &a->sai__GetServerCertificateReq); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetServerCertificateReq(struct soap *soap, struct __sai__GetServerCertificateReq *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetServerCertificateReq = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetServerCertificateReq(struct soap *soap, const struct __sai__GetServerCertificateReq *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetServerCertificateReq(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetServerCertificateReq(struct soap *soap, const char *tag, int id, const struct __sai__GetServerCertificateReq *a, const char *type) +{ + soap_out_PointerTo_sai__GetServerCertificateReq(soap, "sai:GetServerCertificateReq", -1, &a->sai__GetServerCertificateReq, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetServerCertificateReq * SOAP_FMAC4 soap_get___sai__GetServerCertificateReq(struct soap *soap, struct __sai__GetServerCertificateReq *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetServerCertificateReq(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetServerCertificateReq * SOAP_FMAC4 soap_in___sai__GetServerCertificateReq(struct soap *soap, const char *tag, struct __sai__GetServerCertificateReq *a, const char *type) +{ + short soap_flag_sai__GetServerCertificateReq = 1; + a = (struct __sai__GetServerCertificateReq *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetServerCertificateReq, sizeof(struct __sai__GetServerCertificateReq), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetServerCertificateReq(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetServerCertificateReq && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetServerCertificateReq(soap, "sai:GetServerCertificateReq", &a->sai__GetServerCertificateReq, "")) + { soap_flag_sai__GetServerCertificateReq--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetServerCertificateReq * SOAP_FMAC6 soap_new___sai__GetServerCertificateReq(struct soap *soap, int n) +{ return soap_instantiate___sai__GetServerCertificateReq(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetServerCertificateReq(struct soap *soap, struct __sai__GetServerCertificateReq *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetServerCertificateReq * SOAP_FMAC4 soap_instantiate___sai__GetServerCertificateReq(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetServerCertificateReq(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetServerCertificateReq, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetServerCertificateReq; + if (size) + *size = sizeof(struct __sai__GetServerCertificateReq); + } + else + { cp->ptr = (void*)new struct __sai__GetServerCertificateReq[n]; + if (size) + *size = n * sizeof(struct __sai__GetServerCertificateReq); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetServerCertificateReq*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetServerCertificateReq(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetServerCertificateReq %p -> %p\n", q, p)); + *(struct __sai__GetServerCertificateReq*)p = *(struct __sai__GetServerCertificateReq*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetCRL(struct soap *soap, const struct __sai__GetCRL *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetCRL(soap, &a->sai__GetCRL); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetCRL(struct soap *soap, struct __sai__GetCRL *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetCRL = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetCRL(struct soap *soap, const struct __sai__GetCRL *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetCRL(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetCRL(struct soap *soap, const char *tag, int id, const struct __sai__GetCRL *a, const char *type) +{ + soap_out_PointerTo_sai__GetCRL(soap, "sai:GetCRL", -1, &a->sai__GetCRL, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetCRL * SOAP_FMAC4 soap_get___sai__GetCRL(struct soap *soap, struct __sai__GetCRL *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetCRL(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetCRL * SOAP_FMAC4 soap_in___sai__GetCRL(struct soap *soap, const char *tag, struct __sai__GetCRL *a, const char *type) +{ + short soap_flag_sai__GetCRL = 1; + a = (struct __sai__GetCRL *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetCRL, sizeof(struct __sai__GetCRL), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetCRL(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetCRL && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetCRL(soap, "sai:GetCRL", &a->sai__GetCRL, "")) + { soap_flag_sai__GetCRL--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetCRL * SOAP_FMAC6 soap_new___sai__GetCRL(struct soap *soap, int n) +{ return soap_instantiate___sai__GetCRL(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetCRL(struct soap *soap, struct __sai__GetCRL *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetCRL * SOAP_FMAC4 soap_instantiate___sai__GetCRL(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetCRL(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetCRL, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetCRL; + if (size) + *size = sizeof(struct __sai__GetCRL); + } + else + { cp->ptr = (void*)new struct __sai__GetCRL[n]; + if (size) + *size = n * sizeof(struct __sai__GetCRL); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetCRL*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetCRL(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetCRL %p -> %p\n", q, p)); + *(struct __sai__GetCRL*)p = *(struct __sai__GetCRL*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetCRL(struct soap *soap, const struct __sai__SetCRL *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetCRL(soap, &a->sai__SetCRL); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetCRL(struct soap *soap, struct __sai__SetCRL *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetCRL = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetCRL(struct soap *soap, const struct __sai__SetCRL *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetCRL(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetCRL(struct soap *soap, const char *tag, int id, const struct __sai__SetCRL *a, const char *type) +{ + soap_out_PointerTo_sai__SetCRL(soap, "sai:SetCRL", -1, &a->sai__SetCRL, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetCRL * SOAP_FMAC4 soap_get___sai__SetCRL(struct soap *soap, struct __sai__SetCRL *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetCRL(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetCRL * SOAP_FMAC4 soap_in___sai__SetCRL(struct soap *soap, const char *tag, struct __sai__SetCRL *a, const char *type) +{ + short soap_flag_sai__SetCRL = 1; + a = (struct __sai__SetCRL *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetCRL, sizeof(struct __sai__SetCRL), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetCRL(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetCRL && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetCRL(soap, "sai:SetCRL", &a->sai__SetCRL, "")) + { soap_flag_sai__SetCRL--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetCRL * SOAP_FMAC6 soap_new___sai__SetCRL(struct soap *soap, int n) +{ return soap_instantiate___sai__SetCRL(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetCRL(struct soap *soap, struct __sai__SetCRL *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetCRL * SOAP_FMAC4 soap_instantiate___sai__SetCRL(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetCRL(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetCRL, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetCRL; + if (size) + *size = sizeof(struct __sai__SetCRL); + } + else + { cp->ptr = (void*)new struct __sai__SetCRL[n]; + if (size) + *size = n * sizeof(struct __sai__SetCRL); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetCRL*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetCRL(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetCRL %p -> %p\n", q, p)); + *(struct __sai__SetCRL*)p = *(struct __sai__SetCRL*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTrustedFqdnCN(struct soap *soap, const struct __sai__GetTrustedFqdnCN *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetTrustedFqdnCN(soap, &a->sai__GetTrustedFqdnCN); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTrustedFqdnCN(struct soap *soap, struct __sai__GetTrustedFqdnCN *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetTrustedFqdnCN = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTrustedFqdnCN(struct soap *soap, const struct __sai__GetTrustedFqdnCN *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetTrustedFqdnCN(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTrustedFqdnCN(struct soap *soap, const char *tag, int id, const struct __sai__GetTrustedFqdnCN *a, const char *type) +{ + soap_out_PointerTo_sai__GetTrustedFqdnCN(soap, "sai:GetTrustedFqdnCN", -1, &a->sai__GetTrustedFqdnCN, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_get___sai__GetTrustedFqdnCN(struct soap *soap, struct __sai__GetTrustedFqdnCN *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetTrustedFqdnCN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_in___sai__GetTrustedFqdnCN(struct soap *soap, const char *tag, struct __sai__GetTrustedFqdnCN *a, const char *type) +{ + short soap_flag_sai__GetTrustedFqdnCN = 1; + a = (struct __sai__GetTrustedFqdnCN *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetTrustedFqdnCN, sizeof(struct __sai__GetTrustedFqdnCN), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetTrustedFqdnCN(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetTrustedFqdnCN && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetTrustedFqdnCN(soap, "sai:GetTrustedFqdnCN", &a->sai__GetTrustedFqdnCN, "")) + { soap_flag_sai__GetTrustedFqdnCN--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetTrustedFqdnCN * SOAP_FMAC6 soap_new___sai__GetTrustedFqdnCN(struct soap *soap, int n) +{ return soap_instantiate___sai__GetTrustedFqdnCN(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTrustedFqdnCN(struct soap *soap, struct __sai__GetTrustedFqdnCN *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetTrustedFqdnCN * SOAP_FMAC4 soap_instantiate___sai__GetTrustedFqdnCN(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetTrustedFqdnCN(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetTrustedFqdnCN, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetTrustedFqdnCN; + if (size) + *size = sizeof(struct __sai__GetTrustedFqdnCN); + } + else + { cp->ptr = (void*)new struct __sai__GetTrustedFqdnCN[n]; + if (size) + *size = n * sizeof(struct __sai__GetTrustedFqdnCN); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetTrustedFqdnCN*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTrustedFqdnCN(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetTrustedFqdnCN %p -> %p\n", q, p)); + *(struct __sai__GetTrustedFqdnCN*)p = *(struct __sai__GetTrustedFqdnCN*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTrustedFqdnCN(struct soap *soap, const struct __sai__SetTrustedFqdnCN *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetTrustedFqdnCN(soap, &a->sai__SetTrustedFqdnCN); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTrustedFqdnCN(struct soap *soap, struct __sai__SetTrustedFqdnCN *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetTrustedFqdnCN = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTrustedFqdnCN(struct soap *soap, const struct __sai__SetTrustedFqdnCN *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetTrustedFqdnCN(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTrustedFqdnCN(struct soap *soap, const char *tag, int id, const struct __sai__SetTrustedFqdnCN *a, const char *type) +{ + soap_out_PointerTo_sai__SetTrustedFqdnCN(soap, "sai:SetTrustedFqdnCN", -1, &a->sai__SetTrustedFqdnCN, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_get___sai__SetTrustedFqdnCN(struct soap *soap, struct __sai__SetTrustedFqdnCN *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetTrustedFqdnCN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_in___sai__SetTrustedFqdnCN(struct soap *soap, const char *tag, struct __sai__SetTrustedFqdnCN *a, const char *type) +{ + short soap_flag_sai__SetTrustedFqdnCN = 1; + a = (struct __sai__SetTrustedFqdnCN *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetTrustedFqdnCN, sizeof(struct __sai__SetTrustedFqdnCN), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetTrustedFqdnCN(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetTrustedFqdnCN && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetTrustedFqdnCN(soap, "sai:SetTrustedFqdnCN", &a->sai__SetTrustedFqdnCN, "")) + { soap_flag_sai__SetTrustedFqdnCN--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetTrustedFqdnCN * SOAP_FMAC6 soap_new___sai__SetTrustedFqdnCN(struct soap *soap, int n) +{ return soap_instantiate___sai__SetTrustedFqdnCN(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTrustedFqdnCN(struct soap *soap, struct __sai__SetTrustedFqdnCN *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetTrustedFqdnCN * SOAP_FMAC4 soap_instantiate___sai__SetTrustedFqdnCN(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetTrustedFqdnCN(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetTrustedFqdnCN, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetTrustedFqdnCN; + if (size) + *size = sizeof(struct __sai__SetTrustedFqdnCN); + } + else + { cp->ptr = (void*)new struct __sai__SetTrustedFqdnCN[n]; + if (size) + *size = n * sizeof(struct __sai__SetTrustedFqdnCN); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetTrustedFqdnCN*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTrustedFqdnCN(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetTrustedFqdnCN %p -> %p\n", q, p)); + *(struct __sai__SetTrustedFqdnCN*)p = *(struct __sai__SetTrustedFqdnCN*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnumerateTrustedRootCertificates(struct soap *soap, const struct __sai__EnumerateTrustedRootCertificates *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__EnumerateTrustedRootCertificates(soap, &a->sai__EnumerateTrustedRootCertificates); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnumerateTrustedRootCertificates(struct soap *soap, struct __sai__EnumerateTrustedRootCertificates *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__EnumerateTrustedRootCertificates = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnumerateTrustedRootCertificates(struct soap *soap, const struct __sai__EnumerateTrustedRootCertificates *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__EnumerateTrustedRootCertificates(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnumerateTrustedRootCertificates(struct soap *soap, const char *tag, int id, const struct __sai__EnumerateTrustedRootCertificates *a, const char *type) +{ + soap_out_PointerTo_sai__EnumerateTrustedRootCertificates(soap, "sai:EnumerateTrustedRootCertificates", -1, &a->sai__EnumerateTrustedRootCertificates, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_get___sai__EnumerateTrustedRootCertificates(struct soap *soap, struct __sai__EnumerateTrustedRootCertificates *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__EnumerateTrustedRootCertificates(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_in___sai__EnumerateTrustedRootCertificates(struct soap *soap, const char *tag, struct __sai__EnumerateTrustedRootCertificates *a, const char *type) +{ + short soap_flag_sai__EnumerateTrustedRootCertificates = 1; + a = (struct __sai__EnumerateTrustedRootCertificates *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__EnumerateTrustedRootCertificates, sizeof(struct __sai__EnumerateTrustedRootCertificates), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__EnumerateTrustedRootCertificates(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__EnumerateTrustedRootCertificates && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__EnumerateTrustedRootCertificates(soap, "sai:EnumerateTrustedRootCertificates", &a->sai__EnumerateTrustedRootCertificates, "")) + { soap_flag_sai__EnumerateTrustedRootCertificates--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__EnumerateTrustedRootCertificates * SOAP_FMAC6 soap_new___sai__EnumerateTrustedRootCertificates(struct soap *soap, int n) +{ return soap_instantiate___sai__EnumerateTrustedRootCertificates(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnumerateTrustedRootCertificates(struct soap *soap, struct __sai__EnumerateTrustedRootCertificates *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__EnumerateTrustedRootCertificates * SOAP_FMAC4 soap_instantiate___sai__EnumerateTrustedRootCertificates(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__EnumerateTrustedRootCertificates(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__EnumerateTrustedRootCertificates, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__EnumerateTrustedRootCertificates; + if (size) + *size = sizeof(struct __sai__EnumerateTrustedRootCertificates); + } + else + { cp->ptr = (void*)new struct __sai__EnumerateTrustedRootCertificates[n]; + if (size) + *size = n * sizeof(struct __sai__EnumerateTrustedRootCertificates); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__EnumerateTrustedRootCertificates*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnumerateTrustedRootCertificates(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__EnumerateTrustedRootCertificates %p -> %p\n", q, p)); + *(struct __sai__EnumerateTrustedRootCertificates*)p = *(struct __sai__EnumerateTrustedRootCertificates*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__DeleteTrustedRootCertificate(struct soap *soap, const struct __sai__DeleteTrustedRootCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__DeleteTrustedRootCertificate(soap, &a->sai__DeleteTrustedRootCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__DeleteTrustedRootCertificate(struct soap *soap, struct __sai__DeleteTrustedRootCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__DeleteTrustedRootCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__DeleteTrustedRootCertificate(struct soap *soap, const struct __sai__DeleteTrustedRootCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__DeleteTrustedRootCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__DeleteTrustedRootCertificate(struct soap *soap, const char *tag, int id, const struct __sai__DeleteTrustedRootCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__DeleteTrustedRootCertificate(soap, "sai:DeleteTrustedRootCertificate", -1, &a->sai__DeleteTrustedRootCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_get___sai__DeleteTrustedRootCertificate(struct soap *soap, struct __sai__DeleteTrustedRootCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__DeleteTrustedRootCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_in___sai__DeleteTrustedRootCertificate(struct soap *soap, const char *tag, struct __sai__DeleteTrustedRootCertificate *a, const char *type) +{ + short soap_flag_sai__DeleteTrustedRootCertificate = 1; + a = (struct __sai__DeleteTrustedRootCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__DeleteTrustedRootCertificate, sizeof(struct __sai__DeleteTrustedRootCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__DeleteTrustedRootCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__DeleteTrustedRootCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__DeleteTrustedRootCertificate(soap, "sai:DeleteTrustedRootCertificate", &a->sai__DeleteTrustedRootCertificate, "")) + { soap_flag_sai__DeleteTrustedRootCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__DeleteTrustedRootCertificate * SOAP_FMAC6 soap_new___sai__DeleteTrustedRootCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__DeleteTrustedRootCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__DeleteTrustedRootCertificate(struct soap *soap, struct __sai__DeleteTrustedRootCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__DeleteTrustedRootCertificate * SOAP_FMAC4 soap_instantiate___sai__DeleteTrustedRootCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__DeleteTrustedRootCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__DeleteTrustedRootCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__DeleteTrustedRootCertificate; + if (size) + *size = sizeof(struct __sai__DeleteTrustedRootCertificate); + } + else + { cp->ptr = (void*)new struct __sai__DeleteTrustedRootCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__DeleteTrustedRootCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__DeleteTrustedRootCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__DeleteTrustedRootCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__DeleteTrustedRootCertificate %p -> %p\n", q, p)); + *(struct __sai__DeleteTrustedRootCertificate*)p = *(struct __sai__DeleteTrustedRootCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTrustedRootCertificate(struct soap *soap, const struct __sai__GetTrustedRootCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetTrustedRootCertificate(soap, &a->sai__GetTrustedRootCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTrustedRootCertificate(struct soap *soap, struct __sai__GetTrustedRootCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetTrustedRootCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTrustedRootCertificate(struct soap *soap, const struct __sai__GetTrustedRootCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetTrustedRootCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTrustedRootCertificate(struct soap *soap, const char *tag, int id, const struct __sai__GetTrustedRootCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__GetTrustedRootCertificate(soap, "sai:GetTrustedRootCertificate", -1, &a->sai__GetTrustedRootCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_get___sai__GetTrustedRootCertificate(struct soap *soap, struct __sai__GetTrustedRootCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetTrustedRootCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_in___sai__GetTrustedRootCertificate(struct soap *soap, const char *tag, struct __sai__GetTrustedRootCertificate *a, const char *type) +{ + short soap_flag_sai__GetTrustedRootCertificate = 1; + a = (struct __sai__GetTrustedRootCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetTrustedRootCertificate, sizeof(struct __sai__GetTrustedRootCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetTrustedRootCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetTrustedRootCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetTrustedRootCertificate(soap, "sai:GetTrustedRootCertificate", &a->sai__GetTrustedRootCertificate, "")) + { soap_flag_sai__GetTrustedRootCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetTrustedRootCertificate * SOAP_FMAC6 soap_new___sai__GetTrustedRootCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__GetTrustedRootCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTrustedRootCertificate(struct soap *soap, struct __sai__GetTrustedRootCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetTrustedRootCertificate * SOAP_FMAC4 soap_instantiate___sai__GetTrustedRootCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetTrustedRootCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetTrustedRootCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetTrustedRootCertificate; + if (size) + *size = sizeof(struct __sai__GetTrustedRootCertificate); + } + else + { cp->ptr = (void*)new struct __sai__GetTrustedRootCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__GetTrustedRootCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetTrustedRootCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTrustedRootCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetTrustedRootCertificate %p -> %p\n", q, p)); + *(struct __sai__GetTrustedRootCertificate*)p = *(struct __sai__GetTrustedRootCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__AddTrustedRootCertificate(struct soap *soap, const struct __sai__AddTrustedRootCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__AddTrustedRootCertificate(soap, &a->sai__AddTrustedRootCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__AddTrustedRootCertificate(struct soap *soap, struct __sai__AddTrustedRootCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__AddTrustedRootCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__AddTrustedRootCertificate(struct soap *soap, const struct __sai__AddTrustedRootCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__AddTrustedRootCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__AddTrustedRootCertificate(struct soap *soap, const char *tag, int id, const struct __sai__AddTrustedRootCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__AddTrustedRootCertificate(soap, "sai:AddTrustedRootCertificate", -1, &a->sai__AddTrustedRootCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_get___sai__AddTrustedRootCertificate(struct soap *soap, struct __sai__AddTrustedRootCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__AddTrustedRootCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_in___sai__AddTrustedRootCertificate(struct soap *soap, const char *tag, struct __sai__AddTrustedRootCertificate *a, const char *type) +{ + short soap_flag_sai__AddTrustedRootCertificate = 1; + a = (struct __sai__AddTrustedRootCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__AddTrustedRootCertificate, sizeof(struct __sai__AddTrustedRootCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__AddTrustedRootCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__AddTrustedRootCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__AddTrustedRootCertificate(soap, "sai:AddTrustedRootCertificate", &a->sai__AddTrustedRootCertificate, "")) + { soap_flag_sai__AddTrustedRootCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__AddTrustedRootCertificate * SOAP_FMAC6 soap_new___sai__AddTrustedRootCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__AddTrustedRootCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__AddTrustedRootCertificate(struct soap *soap, struct __sai__AddTrustedRootCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__AddTrustedRootCertificate * SOAP_FMAC4 soap_instantiate___sai__AddTrustedRootCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__AddTrustedRootCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__AddTrustedRootCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__AddTrustedRootCertificate; + if (size) + *size = sizeof(struct __sai__AddTrustedRootCertificate); + } + else + { cp->ptr = (void*)new struct __sai__AddTrustedRootCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__AddTrustedRootCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__AddTrustedRootCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__AddTrustedRootCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__AddTrustedRootCertificate %p -> %p\n", q, p)); + *(struct __sai__AddTrustedRootCertificate*)p = *(struct __sai__AddTrustedRootCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTlsOptions(struct soap *soap, const struct __sai__GetTlsOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetTlsOptions(soap, &a->sai__GetTlsOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTlsOptions(struct soap *soap, struct __sai__GetTlsOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetTlsOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTlsOptions(struct soap *soap, const struct __sai__GetTlsOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetTlsOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTlsOptions(struct soap *soap, const char *tag, int id, const struct __sai__GetTlsOptions *a, const char *type) +{ + soap_out_PointerTo_sai__GetTlsOptions(soap, "sai:GetTlsOptions", -1, &a->sai__GetTlsOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetTlsOptions * SOAP_FMAC4 soap_get___sai__GetTlsOptions(struct soap *soap, struct __sai__GetTlsOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetTlsOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetTlsOptions * SOAP_FMAC4 soap_in___sai__GetTlsOptions(struct soap *soap, const char *tag, struct __sai__GetTlsOptions *a, const char *type) +{ + short soap_flag_sai__GetTlsOptions = 1; + a = (struct __sai__GetTlsOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetTlsOptions, sizeof(struct __sai__GetTlsOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetTlsOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetTlsOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetTlsOptions(soap, "sai:GetTlsOptions", &a->sai__GetTlsOptions, "")) + { soap_flag_sai__GetTlsOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetTlsOptions * SOAP_FMAC6 soap_new___sai__GetTlsOptions(struct soap *soap, int n) +{ return soap_instantiate___sai__GetTlsOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTlsOptions(struct soap *soap, struct __sai__GetTlsOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetTlsOptions * SOAP_FMAC4 soap_instantiate___sai__GetTlsOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetTlsOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetTlsOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetTlsOptions; + if (size) + *size = sizeof(struct __sai__GetTlsOptions); + } + else + { cp->ptr = (void*)new struct __sai__GetTlsOptions[n]; + if (size) + *size = n * sizeof(struct __sai__GetTlsOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetTlsOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTlsOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetTlsOptions %p -> %p\n", q, p)); + *(struct __sai__GetTlsOptions*)p = *(struct __sai__GetTlsOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTlsOptions(struct soap *soap, const struct __sai__SetTlsOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetTlsOptions(soap, &a->sai__SetTlsOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTlsOptions(struct soap *soap, struct __sai__SetTlsOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetTlsOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTlsOptions(struct soap *soap, const struct __sai__SetTlsOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetTlsOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTlsOptions(struct soap *soap, const char *tag, int id, const struct __sai__SetTlsOptions *a, const char *type) +{ + soap_out_PointerTo_sai__SetTlsOptions(soap, "sai:SetTlsOptions", -1, &a->sai__SetTlsOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetTlsOptions * SOAP_FMAC4 soap_get___sai__SetTlsOptions(struct soap *soap, struct __sai__SetTlsOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetTlsOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetTlsOptions * SOAP_FMAC4 soap_in___sai__SetTlsOptions(struct soap *soap, const char *tag, struct __sai__SetTlsOptions *a, const char *type) +{ + short soap_flag_sai__SetTlsOptions = 1; + a = (struct __sai__SetTlsOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetTlsOptions, sizeof(struct __sai__SetTlsOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetTlsOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetTlsOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetTlsOptions(soap, "sai:SetTlsOptions", &a->sai__SetTlsOptions, "")) + { soap_flag_sai__SetTlsOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetTlsOptions * SOAP_FMAC6 soap_new___sai__SetTlsOptions(struct soap *soap, int n) +{ return soap_instantiate___sai__SetTlsOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTlsOptions(struct soap *soap, struct __sai__SetTlsOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetTlsOptions * SOAP_FMAC4 soap_instantiate___sai__SetTlsOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetTlsOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetTlsOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetTlsOptions; + if (size) + *size = sizeof(struct __sai__SetTlsOptions); + } + else + { cp->ptr = (void*)new struct __sai__SetTlsOptions[n]; + if (size) + *size = n * sizeof(struct __sai__SetTlsOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetTlsOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTlsOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetTlsOptions %p -> %p\n", q, p)); + *(struct __sai__SetTlsOptions*)p = *(struct __sai__SetTlsOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetEnabledInterfaces(struct soap *soap, const struct __sai__GetEnabledInterfaces *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetEnabledInterfaces(soap, &a->sai__GetEnabledInterfaces); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetEnabledInterfaces(struct soap *soap, struct __sai__GetEnabledInterfaces *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetEnabledInterfaces = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetEnabledInterfaces(struct soap *soap, const struct __sai__GetEnabledInterfaces *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetEnabledInterfaces(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetEnabledInterfaces(struct soap *soap, const char *tag, int id, const struct __sai__GetEnabledInterfaces *a, const char *type) +{ + soap_out_PointerTo_sai__GetEnabledInterfaces(soap, "sai:GetEnabledInterfaces", -1, &a->sai__GetEnabledInterfaces, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetEnabledInterfaces * SOAP_FMAC4 soap_get___sai__GetEnabledInterfaces(struct soap *soap, struct __sai__GetEnabledInterfaces *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetEnabledInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetEnabledInterfaces * SOAP_FMAC4 soap_in___sai__GetEnabledInterfaces(struct soap *soap, const char *tag, struct __sai__GetEnabledInterfaces *a, const char *type) +{ + short soap_flag_sai__GetEnabledInterfaces = 1; + a = (struct __sai__GetEnabledInterfaces *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetEnabledInterfaces, sizeof(struct __sai__GetEnabledInterfaces), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetEnabledInterfaces(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetEnabledInterfaces && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetEnabledInterfaces(soap, "sai:GetEnabledInterfaces", &a->sai__GetEnabledInterfaces, "")) + { soap_flag_sai__GetEnabledInterfaces--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetEnabledInterfaces * SOAP_FMAC6 soap_new___sai__GetEnabledInterfaces(struct soap *soap, int n) +{ return soap_instantiate___sai__GetEnabledInterfaces(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetEnabledInterfaces(struct soap *soap, struct __sai__GetEnabledInterfaces *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetEnabledInterfaces * SOAP_FMAC4 soap_instantiate___sai__GetEnabledInterfaces(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetEnabledInterfaces(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetEnabledInterfaces, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetEnabledInterfaces; + if (size) + *size = sizeof(struct __sai__GetEnabledInterfaces); + } + else + { cp->ptr = (void*)new struct __sai__GetEnabledInterfaces[n]; + if (size) + *size = n * sizeof(struct __sai__GetEnabledInterfaces); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetEnabledInterfaces*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetEnabledInterfaces(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetEnabledInterfaces %p -> %p\n", q, p)); + *(struct __sai__GetEnabledInterfaces*)p = *(struct __sai__GetEnabledInterfaces*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetEnabledInterfaces(struct soap *soap, const struct __sai__SetEnabledInterfaces *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetEnabledInterfaces(soap, &a->sai__SetEnabledInterfaces); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetEnabledInterfaces(struct soap *soap, struct __sai__SetEnabledInterfaces *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetEnabledInterfaces = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetEnabledInterfaces(struct soap *soap, const struct __sai__SetEnabledInterfaces *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetEnabledInterfaces(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetEnabledInterfaces(struct soap *soap, const char *tag, int id, const struct __sai__SetEnabledInterfaces *a, const char *type) +{ + soap_out_PointerTo_sai__SetEnabledInterfaces(soap, "sai:SetEnabledInterfaces", -1, &a->sai__SetEnabledInterfaces, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetEnabledInterfaces * SOAP_FMAC4 soap_get___sai__SetEnabledInterfaces(struct soap *soap, struct __sai__SetEnabledInterfaces *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetEnabledInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetEnabledInterfaces * SOAP_FMAC4 soap_in___sai__SetEnabledInterfaces(struct soap *soap, const char *tag, struct __sai__SetEnabledInterfaces *a, const char *type) +{ + short soap_flag_sai__SetEnabledInterfaces = 1; + a = (struct __sai__SetEnabledInterfaces *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetEnabledInterfaces, sizeof(struct __sai__SetEnabledInterfaces), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetEnabledInterfaces(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetEnabledInterfaces && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetEnabledInterfaces(soap, "sai:SetEnabledInterfaces", &a->sai__SetEnabledInterfaces, "")) + { soap_flag_sai__SetEnabledInterfaces--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetEnabledInterfaces * SOAP_FMAC6 soap_new___sai__SetEnabledInterfaces(struct soap *soap, int n) +{ return soap_instantiate___sai__SetEnabledInterfaces(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetEnabledInterfaces(struct soap *soap, struct __sai__SetEnabledInterfaces *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetEnabledInterfaces * SOAP_FMAC4 soap_instantiate___sai__SetEnabledInterfaces(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetEnabledInterfaces(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetEnabledInterfaces, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetEnabledInterfaces; + if (size) + *size = sizeof(struct __sai__SetEnabledInterfaces); + } + else + { cp->ptr = (void*)new struct __sai__SetEnabledInterfaces[n]; + if (size) + *size = n * sizeof(struct __sai__SetEnabledInterfaces); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetEnabledInterfaces*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetEnabledInterfaces(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetEnabledInterfaces %p -> %p\n", q, p)); + *(struct __sai__SetEnabledInterfaces*)p = *(struct __sai__SetEnabledInterfaces*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetKerberosOptions(struct soap *soap, const struct __sai__GetKerberosOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetKerberosOptions(soap, &a->sai__GetKerberosOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetKerberosOptions(struct soap *soap, struct __sai__GetKerberosOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetKerberosOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetKerberosOptions(struct soap *soap, const struct __sai__GetKerberosOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetKerberosOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetKerberosOptions(struct soap *soap, const char *tag, int id, const struct __sai__GetKerberosOptions *a, const char *type) +{ + soap_out_PointerTo_sai__GetKerberosOptions(soap, "sai:GetKerberosOptions", -1, &a->sai__GetKerberosOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetKerberosOptions * SOAP_FMAC4 soap_get___sai__GetKerberosOptions(struct soap *soap, struct __sai__GetKerberosOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetKerberosOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetKerberosOptions * SOAP_FMAC4 soap_in___sai__GetKerberosOptions(struct soap *soap, const char *tag, struct __sai__GetKerberosOptions *a, const char *type) +{ + short soap_flag_sai__GetKerberosOptions = 1; + a = (struct __sai__GetKerberosOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetKerberosOptions, sizeof(struct __sai__GetKerberosOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetKerberosOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetKerberosOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetKerberosOptions(soap, "sai:GetKerberosOptions", &a->sai__GetKerberosOptions, "")) + { soap_flag_sai__GetKerberosOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetKerberosOptions * SOAP_FMAC6 soap_new___sai__GetKerberosOptions(struct soap *soap, int n) +{ return soap_instantiate___sai__GetKerberosOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetKerberosOptions(struct soap *soap, struct __sai__GetKerberosOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetKerberosOptions * SOAP_FMAC4 soap_instantiate___sai__GetKerberosOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetKerberosOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetKerberosOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetKerberosOptions; + if (size) + *size = sizeof(struct __sai__GetKerberosOptions); + } + else + { cp->ptr = (void*)new struct __sai__GetKerberosOptions[n]; + if (size) + *size = n * sizeof(struct __sai__GetKerberosOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetKerberosOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetKerberosOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetKerberosOptions %p -> %p\n", q, p)); + *(struct __sai__GetKerberosOptions*)p = *(struct __sai__GetKerberosOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetKerberosOptions(struct soap *soap, const struct __sai__SetKerberosOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetKerberosOptions(soap, &a->sai__SetKerberosOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetKerberosOptions(struct soap *soap, struct __sai__SetKerberosOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetKerberosOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetKerberosOptions(struct soap *soap, const struct __sai__SetKerberosOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetKerberosOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetKerberosOptions(struct soap *soap, const char *tag, int id, const struct __sai__SetKerberosOptions *a, const char *type) +{ + soap_out_PointerTo_sai__SetKerberosOptions(soap, "sai:SetKerberosOptions", -1, &a->sai__SetKerberosOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetKerberosOptions * SOAP_FMAC4 soap_get___sai__SetKerberosOptions(struct soap *soap, struct __sai__SetKerberosOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetKerberosOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetKerberosOptions * SOAP_FMAC4 soap_in___sai__SetKerberosOptions(struct soap *soap, const char *tag, struct __sai__SetKerberosOptions *a, const char *type) +{ + short soap_flag_sai__SetKerberosOptions = 1; + a = (struct __sai__SetKerberosOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetKerberosOptions, sizeof(struct __sai__SetKerberosOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetKerberosOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetKerberosOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetKerberosOptions(soap, "sai:SetKerberosOptions", &a->sai__SetKerberosOptions, "")) + { soap_flag_sai__SetKerberosOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetKerberosOptions * SOAP_FMAC6 soap_new___sai__SetKerberosOptions(struct soap *soap, int n) +{ return soap_instantiate___sai__SetKerberosOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetKerberosOptions(struct soap *soap, struct __sai__SetKerberosOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetKerberosOptions * SOAP_FMAC4 soap_instantiate___sai__SetKerberosOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetKerberosOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetKerberosOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetKerberosOptions; + if (size) + *size = sizeof(struct __sai__SetKerberosOptions); + } + else + { cp->ptr = (void*)new struct __sai__SetKerberosOptions[n]; + if (size) + *size = n * sizeof(struct __sai__SetKerberosOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetKerberosOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetKerberosOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetKerberosOptions %p -> %p\n", q, p)); + *(struct __sai__SetKerberosOptions*)p = *(struct __sai__SetKerberosOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetDigestRealm(struct soap *soap, const struct __sai__GetDigestRealm *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetDigestRealm(soap, &a->sai__GetDigestRealm); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetDigestRealm(struct soap *soap, struct __sai__GetDigestRealm *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetDigestRealm = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetDigestRealm(struct soap *soap, const struct __sai__GetDigestRealm *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetDigestRealm(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetDigestRealm(struct soap *soap, const char *tag, int id, const struct __sai__GetDigestRealm *a, const char *type) +{ + soap_out_PointerTo_sai__GetDigestRealm(soap, "sai:GetDigestRealm", -1, &a->sai__GetDigestRealm, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetDigestRealm * SOAP_FMAC4 soap_get___sai__GetDigestRealm(struct soap *soap, struct __sai__GetDigestRealm *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetDigestRealm(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetDigestRealm * SOAP_FMAC4 soap_in___sai__GetDigestRealm(struct soap *soap, const char *tag, struct __sai__GetDigestRealm *a, const char *type) +{ + short soap_flag_sai__GetDigestRealm = 1; + a = (struct __sai__GetDigestRealm *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetDigestRealm, sizeof(struct __sai__GetDigestRealm), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetDigestRealm(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetDigestRealm && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetDigestRealm(soap, "sai:GetDigestRealm", &a->sai__GetDigestRealm, "")) + { soap_flag_sai__GetDigestRealm--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetDigestRealm * SOAP_FMAC6 soap_new___sai__GetDigestRealm(struct soap *soap, int n) +{ return soap_instantiate___sai__GetDigestRealm(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetDigestRealm(struct soap *soap, struct __sai__GetDigestRealm *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetDigestRealm * SOAP_FMAC4 soap_instantiate___sai__GetDigestRealm(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetDigestRealm(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetDigestRealm, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetDigestRealm; + if (size) + *size = sizeof(struct __sai__GetDigestRealm); + } + else + { cp->ptr = (void*)new struct __sai__GetDigestRealm[n]; + if (size) + *size = n * sizeof(struct __sai__GetDigestRealm); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetDigestRealm*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetDigestRealm(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetDigestRealm %p -> %p\n", q, p)); + *(struct __sai__GetDigestRealm*)p = *(struct __sai__GetDigestRealm*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetAdminAclEntryEx(struct soap *soap, const struct __sai__SetAdminAclEntryEx *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetAdminAclEntryEx(soap, &a->sai__SetAdminAclEntryEx); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetAdminAclEntryEx(struct soap *soap, struct __sai__SetAdminAclEntryEx *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetAdminAclEntryEx = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetAdminAclEntryEx(struct soap *soap, const struct __sai__SetAdminAclEntryEx *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetAdminAclEntryEx(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetAdminAclEntryEx(struct soap *soap, const char *tag, int id, const struct __sai__SetAdminAclEntryEx *a, const char *type) +{ + soap_out_PointerTo_sai__SetAdminAclEntryEx(soap, "sai:SetAdminAclEntryEx", -1, &a->sai__SetAdminAclEntryEx, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_get___sai__SetAdminAclEntryEx(struct soap *soap, struct __sai__SetAdminAclEntryEx *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetAdminAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_in___sai__SetAdminAclEntryEx(struct soap *soap, const char *tag, struct __sai__SetAdminAclEntryEx *a, const char *type) +{ + short soap_flag_sai__SetAdminAclEntryEx = 1; + a = (struct __sai__SetAdminAclEntryEx *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetAdminAclEntryEx, sizeof(struct __sai__SetAdminAclEntryEx), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetAdminAclEntryEx(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetAdminAclEntryEx && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetAdminAclEntryEx(soap, "sai:SetAdminAclEntryEx", &a->sai__SetAdminAclEntryEx, "")) + { soap_flag_sai__SetAdminAclEntryEx--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetAdminAclEntryEx * SOAP_FMAC6 soap_new___sai__SetAdminAclEntryEx(struct soap *soap, int n) +{ return soap_instantiate___sai__SetAdminAclEntryEx(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetAdminAclEntryEx(struct soap *soap, struct __sai__SetAdminAclEntryEx *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetAdminAclEntryEx * SOAP_FMAC4 soap_instantiate___sai__SetAdminAclEntryEx(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetAdminAclEntryEx(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetAdminAclEntryEx, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetAdminAclEntryEx; + if (size) + *size = sizeof(struct __sai__SetAdminAclEntryEx); + } + else + { cp->ptr = (void*)new struct __sai__SetAdminAclEntryEx[n]; + if (size) + *size = n * sizeof(struct __sai__SetAdminAclEntryEx); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetAdminAclEntryEx*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetAdminAclEntryEx(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetAdminAclEntryEx %p -> %p\n", q, p)); + *(struct __sai__SetAdminAclEntryEx*)p = *(struct __sai__SetAdminAclEntryEx*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__UpdateUserAclEntryEx(struct soap *soap, const struct __sai__UpdateUserAclEntryEx *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__UpdateUserAclEntryEx(soap, &a->sai__UpdateUserAclEntryEx); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__UpdateUserAclEntryEx(struct soap *soap, struct __sai__UpdateUserAclEntryEx *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__UpdateUserAclEntryEx = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__UpdateUserAclEntryEx(struct soap *soap, const struct __sai__UpdateUserAclEntryEx *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__UpdateUserAclEntryEx(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__UpdateUserAclEntryEx(struct soap *soap, const char *tag, int id, const struct __sai__UpdateUserAclEntryEx *a, const char *type) +{ + soap_out_PointerTo_sai__UpdateUserAclEntryEx(soap, "sai:UpdateUserAclEntryEx", -1, &a->sai__UpdateUserAclEntryEx, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_get___sai__UpdateUserAclEntryEx(struct soap *soap, struct __sai__UpdateUserAclEntryEx *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__UpdateUserAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_in___sai__UpdateUserAclEntryEx(struct soap *soap, const char *tag, struct __sai__UpdateUserAclEntryEx *a, const char *type) +{ + short soap_flag_sai__UpdateUserAclEntryEx = 1; + a = (struct __sai__UpdateUserAclEntryEx *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__UpdateUserAclEntryEx, sizeof(struct __sai__UpdateUserAclEntryEx), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__UpdateUserAclEntryEx(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__UpdateUserAclEntryEx && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__UpdateUserAclEntryEx(soap, "sai:UpdateUserAclEntryEx", &a->sai__UpdateUserAclEntryEx, "")) + { soap_flag_sai__UpdateUserAclEntryEx--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__UpdateUserAclEntryEx * SOAP_FMAC6 soap_new___sai__UpdateUserAclEntryEx(struct soap *soap, int n) +{ return soap_instantiate___sai__UpdateUserAclEntryEx(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__UpdateUserAclEntryEx(struct soap *soap, struct __sai__UpdateUserAclEntryEx *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__UpdateUserAclEntryEx * SOAP_FMAC4 soap_instantiate___sai__UpdateUserAclEntryEx(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__UpdateUserAclEntryEx(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__UpdateUserAclEntryEx, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__UpdateUserAclEntryEx; + if (size) + *size = sizeof(struct __sai__UpdateUserAclEntryEx); + } + else + { cp->ptr = (void*)new struct __sai__UpdateUserAclEntryEx[n]; + if (size) + *size = n * sizeof(struct __sai__UpdateUserAclEntryEx); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__UpdateUserAclEntryEx*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__UpdateUserAclEntryEx(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__UpdateUserAclEntryEx %p -> %p\n", q, p)); + *(struct __sai__UpdateUserAclEntryEx*)p = *(struct __sai__UpdateUserAclEntryEx*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetUserAclEntryEx(struct soap *soap, const struct __sai__GetUserAclEntryEx *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetUserAclEntryEx(soap, &a->sai__GetUserAclEntryEx); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetUserAclEntryEx(struct soap *soap, struct __sai__GetUserAclEntryEx *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetUserAclEntryEx = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetUserAclEntryEx(struct soap *soap, const struct __sai__GetUserAclEntryEx *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetUserAclEntryEx(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetUserAclEntryEx(struct soap *soap, const char *tag, int id, const struct __sai__GetUserAclEntryEx *a, const char *type) +{ + soap_out_PointerTo_sai__GetUserAclEntryEx(soap, "sai:GetUserAclEntryEx", -1, &a->sai__GetUserAclEntryEx, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetUserAclEntryEx * SOAP_FMAC4 soap_get___sai__GetUserAclEntryEx(struct soap *soap, struct __sai__GetUserAclEntryEx *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetUserAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetUserAclEntryEx * SOAP_FMAC4 soap_in___sai__GetUserAclEntryEx(struct soap *soap, const char *tag, struct __sai__GetUserAclEntryEx *a, const char *type) +{ + short soap_flag_sai__GetUserAclEntryEx = 1; + a = (struct __sai__GetUserAclEntryEx *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetUserAclEntryEx, sizeof(struct __sai__GetUserAclEntryEx), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetUserAclEntryEx(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetUserAclEntryEx && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetUserAclEntryEx(soap, "sai:GetUserAclEntryEx", &a->sai__GetUserAclEntryEx, "")) + { soap_flag_sai__GetUserAclEntryEx--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetUserAclEntryEx * SOAP_FMAC6 soap_new___sai__GetUserAclEntryEx(struct soap *soap, int n) +{ return soap_instantiate___sai__GetUserAclEntryEx(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetUserAclEntryEx(struct soap *soap, struct __sai__GetUserAclEntryEx *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetUserAclEntryEx * SOAP_FMAC4 soap_instantiate___sai__GetUserAclEntryEx(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetUserAclEntryEx(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetUserAclEntryEx, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetUserAclEntryEx; + if (size) + *size = sizeof(struct __sai__GetUserAclEntryEx); + } + else + { cp->ptr = (void*)new struct __sai__GetUserAclEntryEx[n]; + if (size) + *size = n * sizeof(struct __sai__GetUserAclEntryEx); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetUserAclEntryEx*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetUserAclEntryEx(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetUserAclEntryEx %p -> %p\n", q, p)); + *(struct __sai__GetUserAclEntryEx*)p = *(struct __sai__GetUserAclEntryEx*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__AddUserAclEntryEx(struct soap *soap, const struct __sai__AddUserAclEntryEx *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__AddUserAclEntryEx(soap, &a->sai__AddUserAclEntryEx); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__AddUserAclEntryEx(struct soap *soap, struct __sai__AddUserAclEntryEx *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__AddUserAclEntryEx = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__AddUserAclEntryEx(struct soap *soap, const struct __sai__AddUserAclEntryEx *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__AddUserAclEntryEx(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__AddUserAclEntryEx(struct soap *soap, const char *tag, int id, const struct __sai__AddUserAclEntryEx *a, const char *type) +{ + soap_out_PointerTo_sai__AddUserAclEntryEx(soap, "sai:AddUserAclEntryEx", -1, &a->sai__AddUserAclEntryEx, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__AddUserAclEntryEx * SOAP_FMAC4 soap_get___sai__AddUserAclEntryEx(struct soap *soap, struct __sai__AddUserAclEntryEx *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__AddUserAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__AddUserAclEntryEx * SOAP_FMAC4 soap_in___sai__AddUserAclEntryEx(struct soap *soap, const char *tag, struct __sai__AddUserAclEntryEx *a, const char *type) +{ + short soap_flag_sai__AddUserAclEntryEx = 1; + a = (struct __sai__AddUserAclEntryEx *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__AddUserAclEntryEx, sizeof(struct __sai__AddUserAclEntryEx), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__AddUserAclEntryEx(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__AddUserAclEntryEx && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__AddUserAclEntryEx(soap, "sai:AddUserAclEntryEx", &a->sai__AddUserAclEntryEx, "")) + { soap_flag_sai__AddUserAclEntryEx--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__AddUserAclEntryEx * SOAP_FMAC6 soap_new___sai__AddUserAclEntryEx(struct soap *soap, int n) +{ return soap_instantiate___sai__AddUserAclEntryEx(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__AddUserAclEntryEx(struct soap *soap, struct __sai__AddUserAclEntryEx *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__AddUserAclEntryEx * SOAP_FMAC4 soap_instantiate___sai__AddUserAclEntryEx(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__AddUserAclEntryEx(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__AddUserAclEntryEx, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__AddUserAclEntryEx; + if (size) + *size = sizeof(struct __sai__AddUserAclEntryEx); + } + else + { cp->ptr = (void*)new struct __sai__AddUserAclEntryEx[n]; + if (size) + *size = n * sizeof(struct __sai__AddUserAclEntryEx); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__AddUserAclEntryEx*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__AddUserAclEntryEx(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__AddUserAclEntryEx %p -> %p\n", q, p)); + *(struct __sai__AddUserAclEntryEx*)p = *(struct __sai__AddUserAclEntryEx*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetCoreVersion(struct soap *soap, const struct __sai__GetCoreVersion *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetCoreVersion(soap, &a->sai__GetCoreVersion); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetCoreVersion(struct soap *soap, struct __sai__GetCoreVersion *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetCoreVersion = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetCoreVersion(struct soap *soap, const struct __sai__GetCoreVersion *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetCoreVersion(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetCoreVersion(struct soap *soap, const char *tag, int id, const struct __sai__GetCoreVersion *a, const char *type) +{ + soap_out_PointerTo_sai__GetCoreVersion(soap, "sai:GetCoreVersion", -1, &a->sai__GetCoreVersion, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetCoreVersion * SOAP_FMAC4 soap_get___sai__GetCoreVersion(struct soap *soap, struct __sai__GetCoreVersion *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetCoreVersion(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetCoreVersion * SOAP_FMAC4 soap_in___sai__GetCoreVersion(struct soap *soap, const char *tag, struct __sai__GetCoreVersion *a, const char *type) +{ + short soap_flag_sai__GetCoreVersion = 1; + a = (struct __sai__GetCoreVersion *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetCoreVersion, sizeof(struct __sai__GetCoreVersion), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetCoreVersion(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetCoreVersion && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetCoreVersion(soap, "sai:GetCoreVersion", &a->sai__GetCoreVersion, "")) + { soap_flag_sai__GetCoreVersion--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetCoreVersion * SOAP_FMAC6 soap_new___sai__GetCoreVersion(struct soap *soap, int n) +{ return soap_instantiate___sai__GetCoreVersion(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetCoreVersion(struct soap *soap, struct __sai__GetCoreVersion *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetCoreVersion * SOAP_FMAC4 soap_instantiate___sai__GetCoreVersion(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetCoreVersion(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetCoreVersion, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetCoreVersion; + if (size) + *size = sizeof(struct __sai__GetCoreVersion); + } + else + { cp->ptr = (void*)new struct __sai__GetCoreVersion[n]; + if (size) + *size = n * sizeof(struct __sai__GetCoreVersion); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetCoreVersion*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetCoreVersion(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetCoreVersion %p -> %p\n", q, p)); + *(struct __sai__GetCoreVersion*)p = *(struct __sai__GetCoreVersion*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__CommitChanges(struct soap *soap, const struct __sai__CommitChanges *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__CommitChanges(soap, &a->sai__CommitChanges); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__CommitChanges(struct soap *soap, struct __sai__CommitChanges *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__CommitChanges = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__CommitChanges(struct soap *soap, const struct __sai__CommitChanges *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__CommitChanges(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__CommitChanges(struct soap *soap, const char *tag, int id, const struct __sai__CommitChanges *a, const char *type) +{ + soap_out_PointerTo_sai__CommitChanges(soap, "sai:CommitChanges", -1, &a->sai__CommitChanges, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__CommitChanges * SOAP_FMAC4 soap_get___sai__CommitChanges(struct soap *soap, struct __sai__CommitChanges *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__CommitChanges(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__CommitChanges * SOAP_FMAC4 soap_in___sai__CommitChanges(struct soap *soap, const char *tag, struct __sai__CommitChanges *a, const char *type) +{ + short soap_flag_sai__CommitChanges = 1; + a = (struct __sai__CommitChanges *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__CommitChanges, sizeof(struct __sai__CommitChanges), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__CommitChanges(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__CommitChanges && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__CommitChanges(soap, "sai:CommitChanges", &a->sai__CommitChanges, "")) + { soap_flag_sai__CommitChanges--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__CommitChanges * SOAP_FMAC6 soap_new___sai__CommitChanges(struct soap *soap, int n) +{ return soap_instantiate___sai__CommitChanges(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__CommitChanges(struct soap *soap, struct __sai__CommitChanges *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__CommitChanges * SOAP_FMAC4 soap_instantiate___sai__CommitChanges(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__CommitChanges(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__CommitChanges, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__CommitChanges; + if (size) + *size = sizeof(struct __sai__CommitChanges); + } + else + { cp->ptr = (void*)new struct __sai__CommitChanges[n]; + if (size) + *size = n * sizeof(struct __sai__CommitChanges); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__CommitChanges*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__CommitChanges(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__CommitChanges %p -> %p\n", q, p)); + *(struct __sai__CommitChanges*)p = *(struct __sai__CommitChanges*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__Unprovision(struct soap *soap, const struct __sai__Unprovision *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__Unprovision(soap, &a->sai__Unprovision); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__Unprovision(struct soap *soap, struct __sai__Unprovision *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__Unprovision = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__Unprovision(struct soap *soap, const struct __sai__Unprovision *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__Unprovision(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__Unprovision(struct soap *soap, const char *tag, int id, const struct __sai__Unprovision *a, const char *type) +{ + soap_out_PointerTo_sai__Unprovision(soap, "sai:Unprovision", -1, &a->sai__Unprovision, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__Unprovision * SOAP_FMAC4 soap_get___sai__Unprovision(struct soap *soap, struct __sai__Unprovision *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__Unprovision(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__Unprovision * SOAP_FMAC4 soap_in___sai__Unprovision(struct soap *soap, const char *tag, struct __sai__Unprovision *a, const char *type) +{ + short soap_flag_sai__Unprovision = 1; + a = (struct __sai__Unprovision *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__Unprovision, sizeof(struct __sai__Unprovision), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__Unprovision(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__Unprovision && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__Unprovision(soap, "sai:Unprovision", &a->sai__Unprovision, "")) + { soap_flag_sai__Unprovision--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__Unprovision * SOAP_FMAC6 soap_new___sai__Unprovision(struct soap *soap, int n) +{ return soap_instantiate___sai__Unprovision(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__Unprovision(struct soap *soap, struct __sai__Unprovision *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__Unprovision * SOAP_FMAC4 soap_instantiate___sai__Unprovision(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__Unprovision(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__Unprovision, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__Unprovision; + if (size) + *size = sizeof(struct __sai__Unprovision); + } + else + { cp->ptr = (void*)new struct __sai__Unprovision[n]; + if (size) + *size = n * sizeof(struct __sai__Unprovision); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__Unprovision*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__Unprovision(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__Unprovision %p -> %p\n", q, p)); + *(struct __sai__Unprovision*)p = *(struct __sai__Unprovision*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetProvisioningMode(struct soap *soap, const struct __sai__SetProvisioningMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetProvisioningMode(soap, &a->sai__SetProvisioningMode); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetProvisioningMode(struct soap *soap, struct __sai__SetProvisioningMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetProvisioningMode = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetProvisioningMode(struct soap *soap, const struct __sai__SetProvisioningMode *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetProvisioningMode(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetProvisioningMode(struct soap *soap, const char *tag, int id, const struct __sai__SetProvisioningMode *a, const char *type) +{ + soap_out_PointerTo_sai__SetProvisioningMode(soap, "sai:SetProvisioningMode", -1, &a->sai__SetProvisioningMode, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetProvisioningMode * SOAP_FMAC4 soap_get___sai__SetProvisioningMode(struct soap *soap, struct __sai__SetProvisioningMode *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetProvisioningMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetProvisioningMode * SOAP_FMAC4 soap_in___sai__SetProvisioningMode(struct soap *soap, const char *tag, struct __sai__SetProvisioningMode *a, const char *type) +{ + short soap_flag_sai__SetProvisioningMode = 1; + a = (struct __sai__SetProvisioningMode *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetProvisioningMode, sizeof(struct __sai__SetProvisioningMode), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetProvisioningMode(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetProvisioningMode && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetProvisioningMode(soap, "sai:SetProvisioningMode", &a->sai__SetProvisioningMode, "")) + { soap_flag_sai__SetProvisioningMode--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetProvisioningMode * SOAP_FMAC6 soap_new___sai__SetProvisioningMode(struct soap *soap, int n) +{ return soap_instantiate___sai__SetProvisioningMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetProvisioningMode(struct soap *soap, struct __sai__SetProvisioningMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetProvisioningMode * SOAP_FMAC4 soap_instantiate___sai__SetProvisioningMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetProvisioningMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetProvisioningMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetProvisioningMode; + if (size) + *size = sizeof(struct __sai__SetProvisioningMode); + } + else + { cp->ptr = (void*)new struct __sai__SetProvisioningMode[n]; + if (size) + *size = n * sizeof(struct __sai__SetProvisioningMode); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetProvisioningMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetProvisioningMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetProvisioningMode %p -> %p\n", q, p)); + *(struct __sai__SetProvisioningMode*)p = *(struct __sai__SetProvisioningMode*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetProvisioningMode(struct soap *soap, const struct __sai__GetProvisioningMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetProvisioningMode(soap, &a->sai__GetProvisioningMode); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetProvisioningMode(struct soap *soap, struct __sai__GetProvisioningMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetProvisioningMode = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetProvisioningMode(struct soap *soap, const struct __sai__GetProvisioningMode *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetProvisioningMode(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetProvisioningMode(struct soap *soap, const char *tag, int id, const struct __sai__GetProvisioningMode *a, const char *type) +{ + soap_out_PointerTo_sai__GetProvisioningMode(soap, "sai:GetProvisioningMode", -1, &a->sai__GetProvisioningMode, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetProvisioningMode * SOAP_FMAC4 soap_get___sai__GetProvisioningMode(struct soap *soap, struct __sai__GetProvisioningMode *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetProvisioningMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetProvisioningMode * SOAP_FMAC4 soap_in___sai__GetProvisioningMode(struct soap *soap, const char *tag, struct __sai__GetProvisioningMode *a, const char *type) +{ + short soap_flag_sai__GetProvisioningMode = 1; + a = (struct __sai__GetProvisioningMode *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetProvisioningMode, sizeof(struct __sai__GetProvisioningMode), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetProvisioningMode(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetProvisioningMode && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetProvisioningMode(soap, "sai:GetProvisioningMode", &a->sai__GetProvisioningMode, "")) + { soap_flag_sai__GetProvisioningMode--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetProvisioningMode * SOAP_FMAC6 soap_new___sai__GetProvisioningMode(struct soap *soap, int n) +{ return soap_instantiate___sai__GetProvisioningMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetProvisioningMode(struct soap *soap, struct __sai__GetProvisioningMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetProvisioningMode * SOAP_FMAC4 soap_instantiate___sai__GetProvisioningMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetProvisioningMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetProvisioningMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetProvisioningMode; + if (size) + *size = sizeof(struct __sai__GetProvisioningMode); + } + else + { cp->ptr = (void*)new struct __sai__GetProvisioningMode[n]; + if (size) + *size = n * sizeof(struct __sai__GetProvisioningMode); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetProvisioningMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetProvisioningMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetProvisioningMode %p -> %p\n", q, p)); + *(struct __sai__GetProvisioningMode*)p = *(struct __sai__GetProvisioningMode*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__UpdateCoreFromUrl(struct soap *soap, const struct __sai__UpdateCoreFromUrl *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__UpdateCoreFromUrl(soap, &a->sai__UpdateCoreFromUrl); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__UpdateCoreFromUrl(struct soap *soap, struct __sai__UpdateCoreFromUrl *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__UpdateCoreFromUrl = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__UpdateCoreFromUrl(struct soap *soap, const struct __sai__UpdateCoreFromUrl *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__UpdateCoreFromUrl(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__UpdateCoreFromUrl(struct soap *soap, const char *tag, int id, const struct __sai__UpdateCoreFromUrl *a, const char *type) +{ + soap_out_PointerTo_sai__UpdateCoreFromUrl(soap, "sai:UpdateCoreFromUrl", -1, &a->sai__UpdateCoreFromUrl, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_get___sai__UpdateCoreFromUrl(struct soap *soap, struct __sai__UpdateCoreFromUrl *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__UpdateCoreFromUrl(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_in___sai__UpdateCoreFromUrl(struct soap *soap, const char *tag, struct __sai__UpdateCoreFromUrl *a, const char *type) +{ + short soap_flag_sai__UpdateCoreFromUrl = 1; + a = (struct __sai__UpdateCoreFromUrl *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__UpdateCoreFromUrl, sizeof(struct __sai__UpdateCoreFromUrl), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__UpdateCoreFromUrl(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__UpdateCoreFromUrl && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__UpdateCoreFromUrl(soap, "sai:UpdateCoreFromUrl", &a->sai__UpdateCoreFromUrl, "")) + { soap_flag_sai__UpdateCoreFromUrl--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__UpdateCoreFromUrl * SOAP_FMAC6 soap_new___sai__UpdateCoreFromUrl(struct soap *soap, int n) +{ return soap_instantiate___sai__UpdateCoreFromUrl(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__UpdateCoreFromUrl(struct soap *soap, struct __sai__UpdateCoreFromUrl *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__UpdateCoreFromUrl * SOAP_FMAC4 soap_instantiate___sai__UpdateCoreFromUrl(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__UpdateCoreFromUrl(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__UpdateCoreFromUrl, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__UpdateCoreFromUrl; + if (size) + *size = sizeof(struct __sai__UpdateCoreFromUrl); + } + else + { cp->ptr = (void*)new struct __sai__UpdateCoreFromUrl[n]; + if (size) + *size = n * sizeof(struct __sai__UpdateCoreFromUrl); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__UpdateCoreFromUrl*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__UpdateCoreFromUrl(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__UpdateCoreFromUrl %p -> %p\n", q, p)); + *(struct __sai__UpdateCoreFromUrl*)p = *(struct __sai__UpdateCoreFromUrl*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetTLSCertificate(struct soap *soap, const struct __sai__GetTLSCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetTLSCertificate(soap, &a->sai__GetTLSCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetTLSCertificate(struct soap *soap, struct __sai__GetTLSCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetTLSCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetTLSCertificate(struct soap *soap, const struct __sai__GetTLSCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetTLSCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetTLSCertificate(struct soap *soap, const char *tag, int id, const struct __sai__GetTLSCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__GetTLSCertificate(soap, "sai:GetTLSCertificate", -1, &a->sai__GetTLSCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetTLSCertificate * SOAP_FMAC4 soap_get___sai__GetTLSCertificate(struct soap *soap, struct __sai__GetTLSCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetTLSCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetTLSCertificate * SOAP_FMAC4 soap_in___sai__GetTLSCertificate(struct soap *soap, const char *tag, struct __sai__GetTLSCertificate *a, const char *type) +{ + short soap_flag_sai__GetTLSCertificate = 1; + a = (struct __sai__GetTLSCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetTLSCertificate, sizeof(struct __sai__GetTLSCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetTLSCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetTLSCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetTLSCertificate(soap, "sai:GetTLSCertificate", &a->sai__GetTLSCertificate, "")) + { soap_flag_sai__GetTLSCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetTLSCertificate * SOAP_FMAC6 soap_new___sai__GetTLSCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__GetTLSCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetTLSCertificate(struct soap *soap, struct __sai__GetTLSCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetTLSCertificate * SOAP_FMAC4 soap_instantiate___sai__GetTLSCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetTLSCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetTLSCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetTLSCertificate; + if (size) + *size = sizeof(struct __sai__GetTLSCertificate); + } + else + { cp->ptr = (void*)new struct __sai__GetTLSCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__GetTLSCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetTLSCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetTLSCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetTLSCertificate %p -> %p\n", q, p)); + *(struct __sai__GetTLSCertificate*)p = *(struct __sai__GetTLSCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTLSCertificate(struct soap *soap, const struct __sai__SetTLSCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetTLSCertificate(soap, &a->sai__SetTLSCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTLSCertificate(struct soap *soap, struct __sai__SetTLSCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetTLSCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTLSCertificate(struct soap *soap, const struct __sai__SetTLSCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetTLSCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTLSCertificate(struct soap *soap, const char *tag, int id, const struct __sai__SetTLSCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__SetTLSCertificate(soap, "sai:SetTLSCertificate", -1, &a->sai__SetTLSCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetTLSCertificate * SOAP_FMAC4 soap_get___sai__SetTLSCertificate(struct soap *soap, struct __sai__SetTLSCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetTLSCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetTLSCertificate * SOAP_FMAC4 soap_in___sai__SetTLSCertificate(struct soap *soap, const char *tag, struct __sai__SetTLSCertificate *a, const char *type) +{ + short soap_flag_sai__SetTLSCertificate = 1; + a = (struct __sai__SetTLSCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetTLSCertificate, sizeof(struct __sai__SetTLSCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetTLSCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetTLSCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetTLSCertificate(soap, "sai:SetTLSCertificate", &a->sai__SetTLSCertificate, "")) + { soap_flag_sai__SetTLSCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetTLSCertificate * SOAP_FMAC6 soap_new___sai__SetTLSCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__SetTLSCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTLSCertificate(struct soap *soap, struct __sai__SetTLSCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetTLSCertificate * SOAP_FMAC4 soap_instantiate___sai__SetTLSCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetTLSCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetTLSCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetTLSCertificate; + if (size) + *size = sizeof(struct __sai__SetTLSCertificate); + } + else + { cp->ptr = (void*)new struct __sai__SetTLSCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__SetTLSCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetTLSCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTLSCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetTLSCertificate %p -> %p\n", q, p)); + *(struct __sai__SetTLSCertificate*)p = *(struct __sai__SetTLSCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTLSKeyAndCertificate(struct soap *soap, const struct __sai__SetTLSKeyAndCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetTLSKeyAndCertificate(soap, &a->sai__SetTLSKeyAndCertificate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTLSKeyAndCertificate(struct soap *soap, struct __sai__SetTLSKeyAndCertificate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetTLSKeyAndCertificate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTLSKeyAndCertificate(struct soap *soap, const struct __sai__SetTLSKeyAndCertificate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetTLSKeyAndCertificate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTLSKeyAndCertificate(struct soap *soap, const char *tag, int id, const struct __sai__SetTLSKeyAndCertificate *a, const char *type) +{ + soap_out_PointerTo_sai__SetTLSKeyAndCertificate(soap, "sai:SetTLSKeyAndCertificate", -1, &a->sai__SetTLSKeyAndCertificate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_get___sai__SetTLSKeyAndCertificate(struct soap *soap, struct __sai__SetTLSKeyAndCertificate *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetTLSKeyAndCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_in___sai__SetTLSKeyAndCertificate(struct soap *soap, const char *tag, struct __sai__SetTLSKeyAndCertificate *a, const char *type) +{ + short soap_flag_sai__SetTLSKeyAndCertificate = 1; + a = (struct __sai__SetTLSKeyAndCertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetTLSKeyAndCertificate, sizeof(struct __sai__SetTLSKeyAndCertificate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetTLSKeyAndCertificate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetTLSKeyAndCertificate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetTLSKeyAndCertificate(soap, "sai:SetTLSKeyAndCertificate", &a->sai__SetTLSKeyAndCertificate, "")) + { soap_flag_sai__SetTLSKeyAndCertificate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetTLSKeyAndCertificate * SOAP_FMAC6 soap_new___sai__SetTLSKeyAndCertificate(struct soap *soap, int n) +{ return soap_instantiate___sai__SetTLSKeyAndCertificate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTLSKeyAndCertificate(struct soap *soap, struct __sai__SetTLSKeyAndCertificate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetTLSKeyAndCertificate * SOAP_FMAC4 soap_instantiate___sai__SetTLSKeyAndCertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetTLSKeyAndCertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetTLSKeyAndCertificate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetTLSKeyAndCertificate; + if (size) + *size = sizeof(struct __sai__SetTLSKeyAndCertificate); + } + else + { cp->ptr = (void*)new struct __sai__SetTLSKeyAndCertificate[n]; + if (size) + *size = n * sizeof(struct __sai__SetTLSKeyAndCertificate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetTLSKeyAndCertificate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTLSKeyAndCertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetTLSKeyAndCertificate %p -> %p\n", q, p)); + *(struct __sai__SetTLSKeyAndCertificate*)p = *(struct __sai__SetTLSKeyAndCertificate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetRngKey(struct soap *soap, const struct __sai__SetRngKey *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetRngKey(soap, &a->sai__SetRngKey); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetRngKey(struct soap *soap, struct __sai__SetRngKey *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetRngKey = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetRngKey(struct soap *soap, const struct __sai__SetRngKey *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetRngKey(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetRngKey(struct soap *soap, const char *tag, int id, const struct __sai__SetRngKey *a, const char *type) +{ + soap_out_PointerTo_sai__SetRngKey(soap, "sai:SetRngKey", -1, &a->sai__SetRngKey, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetRngKey * SOAP_FMAC4 soap_get___sai__SetRngKey(struct soap *soap, struct __sai__SetRngKey *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetRngKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetRngKey * SOAP_FMAC4 soap_in___sai__SetRngKey(struct soap *soap, const char *tag, struct __sai__SetRngKey *a, const char *type) +{ + short soap_flag_sai__SetRngKey = 1; + a = (struct __sai__SetRngKey *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetRngKey, sizeof(struct __sai__SetRngKey), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetRngKey(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetRngKey && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetRngKey(soap, "sai:SetRngKey", &a->sai__SetRngKey, "")) + { soap_flag_sai__SetRngKey--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetRngKey * SOAP_FMAC6 soap_new___sai__SetRngKey(struct soap *soap, int n) +{ return soap_instantiate___sai__SetRngKey(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetRngKey(struct soap *soap, struct __sai__SetRngKey *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetRngKey * SOAP_FMAC4 soap_instantiate___sai__SetRngKey(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetRngKey(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetRngKey, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetRngKey; + if (size) + *size = sizeof(struct __sai__SetRngKey); + } + else + { cp->ptr = (void*)new struct __sai__SetRngKey[n]; + if (size) + *size = n * sizeof(struct __sai__SetRngKey); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetRngKey*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetRngKey(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetRngKey %p -> %p\n", q, p)); + *(struct __sai__SetRngKey*)p = *(struct __sai__SetRngKey*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetTlsEnabled(struct soap *soap, const struct __sai__SetTlsEnabled *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetTlsEnabled(soap, &a->sai__SetTlsEnabled); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetTlsEnabled(struct soap *soap, struct __sai__SetTlsEnabled *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetTlsEnabled = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetTlsEnabled(struct soap *soap, const struct __sai__SetTlsEnabled *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetTlsEnabled(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetTlsEnabled(struct soap *soap, const char *tag, int id, const struct __sai__SetTlsEnabled *a, const char *type) +{ + soap_out_PointerTo_sai__SetTlsEnabled(soap, "sai:SetTlsEnabled", -1, &a->sai__SetTlsEnabled, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetTlsEnabled * SOAP_FMAC4 soap_get___sai__SetTlsEnabled(struct soap *soap, struct __sai__SetTlsEnabled *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetTlsEnabled(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetTlsEnabled * SOAP_FMAC4 soap_in___sai__SetTlsEnabled(struct soap *soap, const char *tag, struct __sai__SetTlsEnabled *a, const char *type) +{ + short soap_flag_sai__SetTlsEnabled = 1; + a = (struct __sai__SetTlsEnabled *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetTlsEnabled, sizeof(struct __sai__SetTlsEnabled), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetTlsEnabled(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetTlsEnabled && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetTlsEnabled(soap, "sai:SetTlsEnabled", &a->sai__SetTlsEnabled, "")) + { soap_flag_sai__SetTlsEnabled--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetTlsEnabled * SOAP_FMAC6 soap_new___sai__SetTlsEnabled(struct soap *soap, int n) +{ return soap_instantiate___sai__SetTlsEnabled(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetTlsEnabled(struct soap *soap, struct __sai__SetTlsEnabled *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetTlsEnabled * SOAP_FMAC4 soap_instantiate___sai__SetTlsEnabled(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetTlsEnabled(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetTlsEnabled, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetTlsEnabled; + if (size) + *size = sizeof(struct __sai__SetTlsEnabled); + } + else + { cp->ptr = (void*)new struct __sai__SetTlsEnabled[n]; + if (size) + *size = n * sizeof(struct __sai__SetTlsEnabled); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetTlsEnabled*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetTlsEnabled(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetTlsEnabled %p -> %p\n", q, p)); + *(struct __sai__SetTlsEnabled*)p = *(struct __sai__SetTlsEnabled*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__RemoveUserAclEntry(struct soap *soap, const struct __sai__RemoveUserAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__RemoveUserAclEntry(soap, &a->sai__RemoveUserAclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__RemoveUserAclEntry(struct soap *soap, struct __sai__RemoveUserAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__RemoveUserAclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__RemoveUserAclEntry(struct soap *soap, const struct __sai__RemoveUserAclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__RemoveUserAclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__RemoveUserAclEntry(struct soap *soap, const char *tag, int id, const struct __sai__RemoveUserAclEntry *a, const char *type) +{ + soap_out_PointerTo_sai__RemoveUserAclEntry(soap, "sai:RemoveUserAclEntry", -1, &a->sai__RemoveUserAclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__RemoveUserAclEntry * SOAP_FMAC4 soap_get___sai__RemoveUserAclEntry(struct soap *soap, struct __sai__RemoveUserAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__RemoveUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__RemoveUserAclEntry * SOAP_FMAC4 soap_in___sai__RemoveUserAclEntry(struct soap *soap, const char *tag, struct __sai__RemoveUserAclEntry *a, const char *type) +{ + short soap_flag_sai__RemoveUserAclEntry = 1; + a = (struct __sai__RemoveUserAclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__RemoveUserAclEntry, sizeof(struct __sai__RemoveUserAclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__RemoveUserAclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__RemoveUserAclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__RemoveUserAclEntry(soap, "sai:RemoveUserAclEntry", &a->sai__RemoveUserAclEntry, "")) + { soap_flag_sai__RemoveUserAclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__RemoveUserAclEntry * SOAP_FMAC6 soap_new___sai__RemoveUserAclEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__RemoveUserAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__RemoveUserAclEntry(struct soap *soap, struct __sai__RemoveUserAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__RemoveUserAclEntry * SOAP_FMAC4 soap_instantiate___sai__RemoveUserAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__RemoveUserAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__RemoveUserAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__RemoveUserAclEntry; + if (size) + *size = sizeof(struct __sai__RemoveUserAclEntry); + } + else + { cp->ptr = (void*)new struct __sai__RemoveUserAclEntry[n]; + if (size) + *size = n * sizeof(struct __sai__RemoveUserAclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__RemoveUserAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__RemoveUserAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__RemoveUserAclEntry %p -> %p\n", q, p)); + *(struct __sai__RemoveUserAclEntry*)p = *(struct __sai__RemoveUserAclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__UpdateUserAclEntry(struct soap *soap, const struct __sai__UpdateUserAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__UpdateUserAclEntry(soap, &a->sai__UpdateUserAclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__UpdateUserAclEntry(struct soap *soap, struct __sai__UpdateUserAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__UpdateUserAclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__UpdateUserAclEntry(struct soap *soap, const struct __sai__UpdateUserAclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__UpdateUserAclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__UpdateUserAclEntry(struct soap *soap, const char *tag, int id, const struct __sai__UpdateUserAclEntry *a, const char *type) +{ + soap_out_PointerTo_sai__UpdateUserAclEntry(soap, "sai:UpdateUserAclEntry", -1, &a->sai__UpdateUserAclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__UpdateUserAclEntry * SOAP_FMAC4 soap_get___sai__UpdateUserAclEntry(struct soap *soap, struct __sai__UpdateUserAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__UpdateUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__UpdateUserAclEntry * SOAP_FMAC4 soap_in___sai__UpdateUserAclEntry(struct soap *soap, const char *tag, struct __sai__UpdateUserAclEntry *a, const char *type) +{ + short soap_flag_sai__UpdateUserAclEntry = 1; + a = (struct __sai__UpdateUserAclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__UpdateUserAclEntry, sizeof(struct __sai__UpdateUserAclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__UpdateUserAclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__UpdateUserAclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__UpdateUserAclEntry(soap, "sai:UpdateUserAclEntry", &a->sai__UpdateUserAclEntry, "")) + { soap_flag_sai__UpdateUserAclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__UpdateUserAclEntry * SOAP_FMAC6 soap_new___sai__UpdateUserAclEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__UpdateUserAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__UpdateUserAclEntry(struct soap *soap, struct __sai__UpdateUserAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__UpdateUserAclEntry * SOAP_FMAC4 soap_instantiate___sai__UpdateUserAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__UpdateUserAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__UpdateUserAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__UpdateUserAclEntry; + if (size) + *size = sizeof(struct __sai__UpdateUserAclEntry); + } + else + { cp->ptr = (void*)new struct __sai__UpdateUserAclEntry[n]; + if (size) + *size = n * sizeof(struct __sai__UpdateUserAclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__UpdateUserAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__UpdateUserAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__UpdateUserAclEntry %p -> %p\n", q, p)); + *(struct __sai__UpdateUserAclEntry*)p = *(struct __sai__UpdateUserAclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetUserAclEntry(struct soap *soap, const struct __sai__GetUserAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetUserAclEntry(soap, &a->sai__GetUserAclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetUserAclEntry(struct soap *soap, struct __sai__GetUserAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetUserAclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetUserAclEntry(struct soap *soap, const struct __sai__GetUserAclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetUserAclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetUserAclEntry(struct soap *soap, const char *tag, int id, const struct __sai__GetUserAclEntry *a, const char *type) +{ + soap_out_PointerTo_sai__GetUserAclEntry(soap, "sai:GetUserAclEntry", -1, &a->sai__GetUserAclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetUserAclEntry * SOAP_FMAC4 soap_get___sai__GetUserAclEntry(struct soap *soap, struct __sai__GetUserAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetUserAclEntry * SOAP_FMAC4 soap_in___sai__GetUserAclEntry(struct soap *soap, const char *tag, struct __sai__GetUserAclEntry *a, const char *type) +{ + short soap_flag_sai__GetUserAclEntry = 1; + a = (struct __sai__GetUserAclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetUserAclEntry, sizeof(struct __sai__GetUserAclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetUserAclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetUserAclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetUserAclEntry(soap, "sai:GetUserAclEntry", &a->sai__GetUserAclEntry, "")) + { soap_flag_sai__GetUserAclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetUserAclEntry * SOAP_FMAC6 soap_new___sai__GetUserAclEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__GetUserAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetUserAclEntry(struct soap *soap, struct __sai__GetUserAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetUserAclEntry * SOAP_FMAC4 soap_instantiate___sai__GetUserAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetUserAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetUserAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetUserAclEntry; + if (size) + *size = sizeof(struct __sai__GetUserAclEntry); + } + else + { cp->ptr = (void*)new struct __sai__GetUserAclEntry[n]; + if (size) + *size = n * sizeof(struct __sai__GetUserAclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetUserAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetUserAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetUserAclEntry %p -> %p\n", q, p)); + *(struct __sai__GetUserAclEntry*)p = *(struct __sai__GetUserAclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__EnumerateUserAclEntries(struct soap *soap, const struct __sai__EnumerateUserAclEntries *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__EnumerateUserAclEntries(soap, &a->sai__EnumerateUserAclEntries); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__EnumerateUserAclEntries(struct soap *soap, struct __sai__EnumerateUserAclEntries *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__EnumerateUserAclEntries = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__EnumerateUserAclEntries(struct soap *soap, const struct __sai__EnumerateUserAclEntries *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__EnumerateUserAclEntries(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__EnumerateUserAclEntries(struct soap *soap, const char *tag, int id, const struct __sai__EnumerateUserAclEntries *a, const char *type) +{ + soap_out_PointerTo_sai__EnumerateUserAclEntries(soap, "sai:EnumerateUserAclEntries", -1, &a->sai__EnumerateUserAclEntries, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_get___sai__EnumerateUserAclEntries(struct soap *soap, struct __sai__EnumerateUserAclEntries *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__EnumerateUserAclEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_in___sai__EnumerateUserAclEntries(struct soap *soap, const char *tag, struct __sai__EnumerateUserAclEntries *a, const char *type) +{ + short soap_flag_sai__EnumerateUserAclEntries = 1; + a = (struct __sai__EnumerateUserAclEntries *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__EnumerateUserAclEntries, sizeof(struct __sai__EnumerateUserAclEntries), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__EnumerateUserAclEntries(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__EnumerateUserAclEntries && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__EnumerateUserAclEntries(soap, "sai:EnumerateUserAclEntries", &a->sai__EnumerateUserAclEntries, "")) + { soap_flag_sai__EnumerateUserAclEntries--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__EnumerateUserAclEntries * SOAP_FMAC6 soap_new___sai__EnumerateUserAclEntries(struct soap *soap, int n) +{ return soap_instantiate___sai__EnumerateUserAclEntries(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__EnumerateUserAclEntries(struct soap *soap, struct __sai__EnumerateUserAclEntries *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__EnumerateUserAclEntries * SOAP_FMAC4 soap_instantiate___sai__EnumerateUserAclEntries(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__EnumerateUserAclEntries(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__EnumerateUserAclEntries, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__EnumerateUserAclEntries; + if (size) + *size = sizeof(struct __sai__EnumerateUserAclEntries); + } + else + { cp->ptr = (void*)new struct __sai__EnumerateUserAclEntries[n]; + if (size) + *size = n * sizeof(struct __sai__EnumerateUserAclEntries); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__EnumerateUserAclEntries*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__EnumerateUserAclEntries(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__EnumerateUserAclEntries %p -> %p\n", q, p)); + *(struct __sai__EnumerateUserAclEntries*)p = *(struct __sai__EnumerateUserAclEntries*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__AddUserAclEntry(struct soap *soap, const struct __sai__AddUserAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__AddUserAclEntry(soap, &a->sai__AddUserAclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__AddUserAclEntry(struct soap *soap, struct __sai__AddUserAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__AddUserAclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__AddUserAclEntry(struct soap *soap, const struct __sai__AddUserAclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__AddUserAclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__AddUserAclEntry(struct soap *soap, const char *tag, int id, const struct __sai__AddUserAclEntry *a, const char *type) +{ + soap_out_PointerTo_sai__AddUserAclEntry(soap, "sai:AddUserAclEntry", -1, &a->sai__AddUserAclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__AddUserAclEntry * SOAP_FMAC4 soap_get___sai__AddUserAclEntry(struct soap *soap, struct __sai__AddUserAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__AddUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__AddUserAclEntry * SOAP_FMAC4 soap_in___sai__AddUserAclEntry(struct soap *soap, const char *tag, struct __sai__AddUserAclEntry *a, const char *type) +{ + short soap_flag_sai__AddUserAclEntry = 1; + a = (struct __sai__AddUserAclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__AddUserAclEntry, sizeof(struct __sai__AddUserAclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__AddUserAclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__AddUserAclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__AddUserAclEntry(soap, "sai:AddUserAclEntry", &a->sai__AddUserAclEntry, "")) + { soap_flag_sai__AddUserAclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__AddUserAclEntry * SOAP_FMAC6 soap_new___sai__AddUserAclEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__AddUserAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__AddUserAclEntry(struct soap *soap, struct __sai__AddUserAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__AddUserAclEntry * SOAP_FMAC4 soap_instantiate___sai__AddUserAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__AddUserAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__AddUserAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__AddUserAclEntry; + if (size) + *size = sizeof(struct __sai__AddUserAclEntry); + } + else + { cp->ptr = (void*)new struct __sai__AddUserAclEntry[n]; + if (size) + *size = n * sizeof(struct __sai__AddUserAclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__AddUserAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__AddUserAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__AddUserAclEntry %p -> %p\n", q, p)); + *(struct __sai__AddUserAclEntry*)p = *(struct __sai__AddUserAclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__SetAdminAclEntry(struct soap *soap, const struct __sai__SetAdminAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__SetAdminAclEntry(soap, &a->sai__SetAdminAclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__SetAdminAclEntry(struct soap *soap, struct __sai__SetAdminAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__SetAdminAclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__SetAdminAclEntry(struct soap *soap, const struct __sai__SetAdminAclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__SetAdminAclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__SetAdminAclEntry(struct soap *soap, const char *tag, int id, const struct __sai__SetAdminAclEntry *a, const char *type) +{ + soap_out_PointerTo_sai__SetAdminAclEntry(soap, "sai:SetAdminAclEntry", -1, &a->sai__SetAdminAclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__SetAdminAclEntry * SOAP_FMAC4 soap_get___sai__SetAdminAclEntry(struct soap *soap, struct __sai__SetAdminAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__SetAdminAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__SetAdminAclEntry * SOAP_FMAC4 soap_in___sai__SetAdminAclEntry(struct soap *soap, const char *tag, struct __sai__SetAdminAclEntry *a, const char *type) +{ + short soap_flag_sai__SetAdminAclEntry = 1; + a = (struct __sai__SetAdminAclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__SetAdminAclEntry, sizeof(struct __sai__SetAdminAclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__SetAdminAclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__SetAdminAclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__SetAdminAclEntry(soap, "sai:SetAdminAclEntry", &a->sai__SetAdminAclEntry, "")) + { soap_flag_sai__SetAdminAclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__SetAdminAclEntry * SOAP_FMAC6 soap_new___sai__SetAdminAclEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__SetAdminAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__SetAdminAclEntry(struct soap *soap, struct __sai__SetAdminAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__SetAdminAclEntry * SOAP_FMAC4 soap_instantiate___sai__SetAdminAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__SetAdminAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__SetAdminAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__SetAdminAclEntry; + if (size) + *size = sizeof(struct __sai__SetAdminAclEntry); + } + else + { cp->ptr = (void*)new struct __sai__SetAdminAclEntry[n]; + if (size) + *size = n * sizeof(struct __sai__SetAdminAclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__SetAdminAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__SetAdminAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__SetAdminAclEntry %p -> %p\n", q, p)); + *(struct __sai__SetAdminAclEntry*)p = *(struct __sai__SetAdminAclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__GetAdminAclEntry(struct soap *soap, const struct __sai__GetAdminAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__GetAdminAclEntry(soap, &a->sai__GetAdminAclEntry); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__GetAdminAclEntry(struct soap *soap, struct __sai__GetAdminAclEntry *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__GetAdminAclEntry = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__GetAdminAclEntry(struct soap *soap, const struct __sai__GetAdminAclEntry *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__GetAdminAclEntry(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__GetAdminAclEntry(struct soap *soap, const char *tag, int id, const struct __sai__GetAdminAclEntry *a, const char *type) +{ + soap_out_PointerTo_sai__GetAdminAclEntry(soap, "sai:GetAdminAclEntry", -1, &a->sai__GetAdminAclEntry, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__GetAdminAclEntry * SOAP_FMAC4 soap_get___sai__GetAdminAclEntry(struct soap *soap, struct __sai__GetAdminAclEntry *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__GetAdminAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__GetAdminAclEntry * SOAP_FMAC4 soap_in___sai__GetAdminAclEntry(struct soap *soap, const char *tag, struct __sai__GetAdminAclEntry *a, const char *type) +{ + short soap_flag_sai__GetAdminAclEntry = 1; + a = (struct __sai__GetAdminAclEntry *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__GetAdminAclEntry, sizeof(struct __sai__GetAdminAclEntry), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__GetAdminAclEntry(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__GetAdminAclEntry && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__GetAdminAclEntry(soap, "sai:GetAdminAclEntry", &a->sai__GetAdminAclEntry, "")) + { soap_flag_sai__GetAdminAclEntry--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__GetAdminAclEntry * SOAP_FMAC6 soap_new___sai__GetAdminAclEntry(struct soap *soap, int n) +{ return soap_instantiate___sai__GetAdminAclEntry(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__GetAdminAclEntry(struct soap *soap, struct __sai__GetAdminAclEntry *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__GetAdminAclEntry * SOAP_FMAC4 soap_instantiate___sai__GetAdminAclEntry(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__GetAdminAclEntry(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__GetAdminAclEntry, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__GetAdminAclEntry; + if (size) + *size = sizeof(struct __sai__GetAdminAclEntry); + } + else + { cp->ptr = (void*)new struct __sai__GetAdminAclEntry[n]; + if (size) + *size = n * sizeof(struct __sai__GetAdminAclEntry); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__GetAdminAclEntry*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__GetAdminAclEntry(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__GetAdminAclEntry %p -> %p\n", q, p)); + *(struct __sai__GetAdminAclEntry*)p = *(struct __sai__GetAdminAclEntry*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___sai__ResetFlashWearOutProtection(struct soap *soap, const struct __sai__ResetFlashWearOutProtection *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_sai__ResetFlashWearOutProtection(soap, &a->sai__ResetFlashWearOutProtection); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___sai__ResetFlashWearOutProtection(struct soap *soap, struct __sai__ResetFlashWearOutProtection *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->sai__ResetFlashWearOutProtection = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___sai__ResetFlashWearOutProtection(struct soap *soap, const struct __sai__ResetFlashWearOutProtection *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___sai__ResetFlashWearOutProtection(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___sai__ResetFlashWearOutProtection(struct soap *soap, const char *tag, int id, const struct __sai__ResetFlashWearOutProtection *a, const char *type) +{ + soap_out_PointerTo_sai__ResetFlashWearOutProtection(soap, "sai:ResetFlashWearOutProtection", -1, &a->sai__ResetFlashWearOutProtection, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_get___sai__ResetFlashWearOutProtection(struct soap *soap, struct __sai__ResetFlashWearOutProtection *p, const char *tag, const char *type) +{ + if ((p = soap_in___sai__ResetFlashWearOutProtection(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_in___sai__ResetFlashWearOutProtection(struct soap *soap, const char *tag, struct __sai__ResetFlashWearOutProtection *a, const char *type) +{ + short soap_flag_sai__ResetFlashWearOutProtection = 1; + a = (struct __sai__ResetFlashWearOutProtection *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___sai__ResetFlashWearOutProtection, sizeof(struct __sai__ResetFlashWearOutProtection), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___sai__ResetFlashWearOutProtection(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_sai__ResetFlashWearOutProtection && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_sai__ResetFlashWearOutProtection(soap, "sai:ResetFlashWearOutProtection", &a->sai__ResetFlashWearOutProtection, "")) + { soap_flag_sai__ResetFlashWearOutProtection--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __sai__ResetFlashWearOutProtection * SOAP_FMAC6 soap_new___sai__ResetFlashWearOutProtection(struct soap *soap, int n) +{ return soap_instantiate___sai__ResetFlashWearOutProtection(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___sai__ResetFlashWearOutProtection(struct soap *soap, struct __sai__ResetFlashWearOutProtection *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __sai__ResetFlashWearOutProtection * SOAP_FMAC4 soap_instantiate___sai__ResetFlashWearOutProtection(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___sai__ResetFlashWearOutProtection(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___sai__ResetFlashWearOutProtection, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __sai__ResetFlashWearOutProtection; + if (size) + *size = sizeof(struct __sai__ResetFlashWearOutProtection); + } + else + { cp->ptr = (void*)new struct __sai__ResetFlashWearOutProtection[n]; + if (size) + *size = n * sizeof(struct __sai__ResetFlashWearOutProtection); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __sai__ResetFlashWearOutProtection*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___sai__ResetFlashWearOutProtection(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __sai__ResetFlashWearOutProtection %p -> %p\n", q, p)); + *(struct __sai__ResetFlashWearOutProtection*)p = *(struct __sai__ResetFlashWearOutProtection*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___rci__GetSystemPowerState(struct soap *soap, const struct __rci__GetSystemPowerState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_rci__GetSystemPowerState(soap, &a->rci__GetSystemPowerState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___rci__GetSystemPowerState(struct soap *soap, struct __rci__GetSystemPowerState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->rci__GetSystemPowerState = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___rci__GetSystemPowerState(struct soap *soap, const struct __rci__GetSystemPowerState *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___rci__GetSystemPowerState(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___rci__GetSystemPowerState(struct soap *soap, const char *tag, int id, const struct __rci__GetSystemPowerState *a, const char *type) +{ + soap_out_PointerTo_rci__GetSystemPowerState(soap, "rci:GetSystemPowerState", -1, &a->rci__GetSystemPowerState, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __rci__GetSystemPowerState * SOAP_FMAC4 soap_get___rci__GetSystemPowerState(struct soap *soap, struct __rci__GetSystemPowerState *p, const char *tag, const char *type) +{ + if ((p = soap_in___rci__GetSystemPowerState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __rci__GetSystemPowerState * SOAP_FMAC4 soap_in___rci__GetSystemPowerState(struct soap *soap, const char *tag, struct __rci__GetSystemPowerState *a, const char *type) +{ + short soap_flag_rci__GetSystemPowerState = 1; + a = (struct __rci__GetSystemPowerState *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___rci__GetSystemPowerState, sizeof(struct __rci__GetSystemPowerState), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___rci__GetSystemPowerState(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_rci__GetSystemPowerState && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_rci__GetSystemPowerState(soap, "rci:GetSystemPowerState", &a->rci__GetSystemPowerState, "")) + { soap_flag_rci__GetSystemPowerState--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __rci__GetSystemPowerState * SOAP_FMAC6 soap_new___rci__GetSystemPowerState(struct soap *soap, int n) +{ return soap_instantiate___rci__GetSystemPowerState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___rci__GetSystemPowerState(struct soap *soap, struct __rci__GetSystemPowerState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __rci__GetSystemPowerState * SOAP_FMAC4 soap_instantiate___rci__GetSystemPowerState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___rci__GetSystemPowerState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___rci__GetSystemPowerState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __rci__GetSystemPowerState; + if (size) + *size = sizeof(struct __rci__GetSystemPowerState); + } + else + { cp->ptr = (void*)new struct __rci__GetSystemPowerState[n]; + if (size) + *size = n * sizeof(struct __rci__GetSystemPowerState); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __rci__GetSystemPowerState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___rci__GetSystemPowerState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __rci__GetSystemPowerState %p -> %p\n", q, p)); + *(struct __rci__GetSystemPowerState*)p = *(struct __rci__GetSystemPowerState*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___rci__RemoteControl(struct soap *soap, const struct __rci__RemoteControl *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_rci__RemoteControl(soap, &a->rci__RemoteControl); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___rci__RemoteControl(struct soap *soap, struct __rci__RemoteControl *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->rci__RemoteControl = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___rci__RemoteControl(struct soap *soap, const struct __rci__RemoteControl *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___rci__RemoteControl(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___rci__RemoteControl(struct soap *soap, const char *tag, int id, const struct __rci__RemoteControl *a, const char *type) +{ + soap_out_PointerTo_rci__RemoteControl(soap, "rci:RemoteControl", -1, &a->rci__RemoteControl, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __rci__RemoteControl * SOAP_FMAC4 soap_get___rci__RemoteControl(struct soap *soap, struct __rci__RemoteControl *p, const char *tag, const char *type) +{ + if ((p = soap_in___rci__RemoteControl(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __rci__RemoteControl * SOAP_FMAC4 soap_in___rci__RemoteControl(struct soap *soap, const char *tag, struct __rci__RemoteControl *a, const char *type) +{ + short soap_flag_rci__RemoteControl = 1; + a = (struct __rci__RemoteControl *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___rci__RemoteControl, sizeof(struct __rci__RemoteControl), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___rci__RemoteControl(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_rci__RemoteControl && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_rci__RemoteControl(soap, "rci:RemoteControl", &a->rci__RemoteControl, "")) + { soap_flag_rci__RemoteControl--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __rci__RemoteControl * SOAP_FMAC6 soap_new___rci__RemoteControl(struct soap *soap, int n) +{ return soap_instantiate___rci__RemoteControl(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___rci__RemoteControl(struct soap *soap, struct __rci__RemoteControl *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __rci__RemoteControl * SOAP_FMAC4 soap_instantiate___rci__RemoteControl(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___rci__RemoteControl(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___rci__RemoteControl, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __rci__RemoteControl; + if (size) + *size = sizeof(struct __rci__RemoteControl); + } + else + { cp->ptr = (void*)new struct __rci__RemoteControl[n]; + if (size) + *size = n * sizeof(struct __rci__RemoteControl); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __rci__RemoteControl*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___rci__RemoteControl(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __rci__RemoteControl %p -> %p\n", q, p)); + *(struct __rci__RemoteControl*)p = *(struct __rci__RemoteControl*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___rci__GetRemoteControlCapabilities(struct soap *soap, const struct __rci__GetRemoteControlCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_rci__GetRemoteControlCapabilities(soap, &a->rci__GetRemoteControlCapabilities); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___rci__GetRemoteControlCapabilities(struct soap *soap, struct __rci__GetRemoteControlCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->rci__GetRemoteControlCapabilities = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___rci__GetRemoteControlCapabilities(struct soap *soap, const struct __rci__GetRemoteControlCapabilities *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___rci__GetRemoteControlCapabilities(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___rci__GetRemoteControlCapabilities(struct soap *soap, const char *tag, int id, const struct __rci__GetRemoteControlCapabilities *a, const char *type) +{ + soap_out_PointerTo_rci__GetRemoteControlCapabilities(soap, "rci:GetRemoteControlCapabilities", -1, &a->rci__GetRemoteControlCapabilities, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_get___rci__GetRemoteControlCapabilities(struct soap *soap, struct __rci__GetRemoteControlCapabilities *p, const char *tag, const char *type) +{ + if ((p = soap_in___rci__GetRemoteControlCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_in___rci__GetRemoteControlCapabilities(struct soap *soap, const char *tag, struct __rci__GetRemoteControlCapabilities *a, const char *type) +{ + short soap_flag_rci__GetRemoteControlCapabilities = 1; + a = (struct __rci__GetRemoteControlCapabilities *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___rci__GetRemoteControlCapabilities, sizeof(struct __rci__GetRemoteControlCapabilities), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___rci__GetRemoteControlCapabilities(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_rci__GetRemoteControlCapabilities && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_rci__GetRemoteControlCapabilities(soap, "rci:GetRemoteControlCapabilities", &a->rci__GetRemoteControlCapabilities, "")) + { soap_flag_rci__GetRemoteControlCapabilities--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __rci__GetRemoteControlCapabilities * SOAP_FMAC6 soap_new___rci__GetRemoteControlCapabilities(struct soap *soap, int n) +{ return soap_instantiate___rci__GetRemoteControlCapabilities(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___rci__GetRemoteControlCapabilities(struct soap *soap, struct __rci__GetRemoteControlCapabilities *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __rci__GetRemoteControlCapabilities * SOAP_FMAC4 soap_instantiate___rci__GetRemoteControlCapabilities(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___rci__GetRemoteControlCapabilities(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___rci__GetRemoteControlCapabilities, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __rci__GetRemoteControlCapabilities; + if (size) + *size = sizeof(struct __rci__GetRemoteControlCapabilities); + } + else + { cp->ptr = (void*)new struct __rci__GetRemoteControlCapabilities[n]; + if (size) + *size = n * sizeof(struct __rci__GetRemoteControlCapabilities); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __rci__GetRemoteControlCapabilities*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___rci__GetRemoteControlCapabilities(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __rci__GetRemoteControlCapabilities %p -> %p\n", q, p)); + *(struct __rci__GetRemoteControlCapabilities*)p = *(struct __rci__GetRemoteControlCapabilities*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Get8021XPxeTimeout(struct soap *soap, const struct __net__Get8021XPxeTimeout *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__Get8021XPxeTimeout(soap, &a->net__Get8021XPxeTimeout); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Get8021XPxeTimeout(struct soap *soap, struct __net__Get8021XPxeTimeout *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__Get8021XPxeTimeout = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Get8021XPxeTimeout(struct soap *soap, const struct __net__Get8021XPxeTimeout *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__Get8021XPxeTimeout(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Get8021XPxeTimeout(struct soap *soap, const char *tag, int id, const struct __net__Get8021XPxeTimeout *a, const char *type) +{ + soap_out_PointerTo_net__Get8021XPxeTimeout(soap, "net:Get8021XPxeTimeout", -1, &a->net__Get8021XPxeTimeout, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__Get8021XPxeTimeout * SOAP_FMAC4 soap_get___net__Get8021XPxeTimeout(struct soap *soap, struct __net__Get8021XPxeTimeout *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__Get8021XPxeTimeout(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__Get8021XPxeTimeout * SOAP_FMAC4 soap_in___net__Get8021XPxeTimeout(struct soap *soap, const char *tag, struct __net__Get8021XPxeTimeout *a, const char *type) +{ + short soap_flag_net__Get8021XPxeTimeout = 1; + a = (struct __net__Get8021XPxeTimeout *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__Get8021XPxeTimeout, sizeof(struct __net__Get8021XPxeTimeout), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__Get8021XPxeTimeout(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__Get8021XPxeTimeout && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__Get8021XPxeTimeout(soap, "net:Get8021XPxeTimeout", &a->net__Get8021XPxeTimeout, "")) + { soap_flag_net__Get8021XPxeTimeout--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__Get8021XPxeTimeout * SOAP_FMAC6 soap_new___net__Get8021XPxeTimeout(struct soap *soap, int n) +{ return soap_instantiate___net__Get8021XPxeTimeout(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Get8021XPxeTimeout(struct soap *soap, struct __net__Get8021XPxeTimeout *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__Get8021XPxeTimeout * SOAP_FMAC4 soap_instantiate___net__Get8021XPxeTimeout(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__Get8021XPxeTimeout(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__Get8021XPxeTimeout, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__Get8021XPxeTimeout; + if (size) + *size = sizeof(struct __net__Get8021XPxeTimeout); + } + else + { cp->ptr = (void*)new struct __net__Get8021XPxeTimeout[n]; + if (size) + *size = n * sizeof(struct __net__Get8021XPxeTimeout); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__Get8021XPxeTimeout*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Get8021XPxeTimeout(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__Get8021XPxeTimeout %p -> %p\n", q, p)); + *(struct __net__Get8021XPxeTimeout*)p = *(struct __net__Get8021XPxeTimeout*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Set8021XPxeTimeout(struct soap *soap, const struct __net__Set8021XPxeTimeout *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__Set8021XPxeTimeout(soap, &a->net__Set8021XPxeTimeout); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Set8021XPxeTimeout(struct soap *soap, struct __net__Set8021XPxeTimeout *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__Set8021XPxeTimeout = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Set8021XPxeTimeout(struct soap *soap, const struct __net__Set8021XPxeTimeout *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__Set8021XPxeTimeout(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Set8021XPxeTimeout(struct soap *soap, const char *tag, int id, const struct __net__Set8021XPxeTimeout *a, const char *type) +{ + soap_out_PointerTo_net__Set8021XPxeTimeout(soap, "net:Set8021XPxeTimeout", -1, &a->net__Set8021XPxeTimeout, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__Set8021XPxeTimeout * SOAP_FMAC4 soap_get___net__Set8021XPxeTimeout(struct soap *soap, struct __net__Set8021XPxeTimeout *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__Set8021XPxeTimeout(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__Set8021XPxeTimeout * SOAP_FMAC4 soap_in___net__Set8021XPxeTimeout(struct soap *soap, const char *tag, struct __net__Set8021XPxeTimeout *a, const char *type) +{ + short soap_flag_net__Set8021XPxeTimeout = 1; + a = (struct __net__Set8021XPxeTimeout *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__Set8021XPxeTimeout, sizeof(struct __net__Set8021XPxeTimeout), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__Set8021XPxeTimeout(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__Set8021XPxeTimeout && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__Set8021XPxeTimeout(soap, "net:Set8021XPxeTimeout", &a->net__Set8021XPxeTimeout, "")) + { soap_flag_net__Set8021XPxeTimeout--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__Set8021XPxeTimeout * SOAP_FMAC6 soap_new___net__Set8021XPxeTimeout(struct soap *soap, int n) +{ return soap_instantiate___net__Set8021XPxeTimeout(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Set8021XPxeTimeout(struct soap *soap, struct __net__Set8021XPxeTimeout *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__Set8021XPxeTimeout * SOAP_FMAC4 soap_instantiate___net__Set8021XPxeTimeout(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__Set8021XPxeTimeout(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__Set8021XPxeTimeout, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__Set8021XPxeTimeout; + if (size) + *size = sizeof(struct __net__Set8021XPxeTimeout); + } + else + { cp->ptr = (void*)new struct __net__Set8021XPxeTimeout[n]; + if (size) + *size = n * sizeof(struct __net__Set8021XPxeTimeout); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__Set8021XPxeTimeout*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Set8021XPxeTimeout(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__Set8021XPxeTimeout %p -> %p\n", q, p)); + *(struct __net__Set8021XPxeTimeout*)p = *(struct __net__Set8021XPxeTimeout*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Get8021XActiveS0(struct soap *soap, const struct __net__Get8021XActiveS0 *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__Get8021XActiveS0(soap, &a->net__Get8021XActiveS0); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Get8021XActiveS0(struct soap *soap, struct __net__Get8021XActiveS0 *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__Get8021XActiveS0 = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Get8021XActiveS0(struct soap *soap, const struct __net__Get8021XActiveS0 *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__Get8021XActiveS0(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Get8021XActiveS0(struct soap *soap, const char *tag, int id, const struct __net__Get8021XActiveS0 *a, const char *type) +{ + soap_out_PointerTo_net__Get8021XActiveS0(soap, "net:Get8021XActiveS0", -1, &a->net__Get8021XActiveS0, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__Get8021XActiveS0 * SOAP_FMAC4 soap_get___net__Get8021XActiveS0(struct soap *soap, struct __net__Get8021XActiveS0 *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__Get8021XActiveS0(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__Get8021XActiveS0 * SOAP_FMAC4 soap_in___net__Get8021XActiveS0(struct soap *soap, const char *tag, struct __net__Get8021XActiveS0 *a, const char *type) +{ + short soap_flag_net__Get8021XActiveS0 = 1; + a = (struct __net__Get8021XActiveS0 *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__Get8021XActiveS0, sizeof(struct __net__Get8021XActiveS0), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__Get8021XActiveS0(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__Get8021XActiveS0 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__Get8021XActiveS0(soap, "net:Get8021XActiveS0", &a->net__Get8021XActiveS0, "")) + { soap_flag_net__Get8021XActiveS0--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__Get8021XActiveS0 * SOAP_FMAC6 soap_new___net__Get8021XActiveS0(struct soap *soap, int n) +{ return soap_instantiate___net__Get8021XActiveS0(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Get8021XActiveS0(struct soap *soap, struct __net__Get8021XActiveS0 *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__Get8021XActiveS0 * SOAP_FMAC4 soap_instantiate___net__Get8021XActiveS0(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__Get8021XActiveS0(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__Get8021XActiveS0, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__Get8021XActiveS0; + if (size) + *size = sizeof(struct __net__Get8021XActiveS0); + } + else + { cp->ptr = (void*)new struct __net__Get8021XActiveS0[n]; + if (size) + *size = n * sizeof(struct __net__Get8021XActiveS0); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__Get8021XActiveS0*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Get8021XActiveS0(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__Get8021XActiveS0 %p -> %p\n", q, p)); + *(struct __net__Get8021XActiveS0*)p = *(struct __net__Get8021XActiveS0*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Set8021XActiveS0(struct soap *soap, const struct __net__Set8021XActiveS0 *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__Set8021XActiveS0(soap, &a->net__Set8021XActiveS0); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Set8021XActiveS0(struct soap *soap, struct __net__Set8021XActiveS0 *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__Set8021XActiveS0 = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Set8021XActiveS0(struct soap *soap, const struct __net__Set8021XActiveS0 *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__Set8021XActiveS0(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Set8021XActiveS0(struct soap *soap, const char *tag, int id, const struct __net__Set8021XActiveS0 *a, const char *type) +{ + soap_out_PointerTo_net__Set8021XActiveS0(soap, "net:Set8021XActiveS0", -1, &a->net__Set8021XActiveS0, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__Set8021XActiveS0 * SOAP_FMAC4 soap_get___net__Set8021XActiveS0(struct soap *soap, struct __net__Set8021XActiveS0 *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__Set8021XActiveS0(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__Set8021XActiveS0 * SOAP_FMAC4 soap_in___net__Set8021XActiveS0(struct soap *soap, const char *tag, struct __net__Set8021XActiveS0 *a, const char *type) +{ + short soap_flag_net__Set8021XActiveS0 = 1; + a = (struct __net__Set8021XActiveS0 *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__Set8021XActiveS0, sizeof(struct __net__Set8021XActiveS0), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__Set8021XActiveS0(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__Set8021XActiveS0 && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__Set8021XActiveS0(soap, "net:Set8021XActiveS0", &a->net__Set8021XActiveS0, "")) + { soap_flag_net__Set8021XActiveS0--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__Set8021XActiveS0 * SOAP_FMAC6 soap_new___net__Set8021XActiveS0(struct soap *soap, int n) +{ return soap_instantiate___net__Set8021XActiveS0(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Set8021XActiveS0(struct soap *soap, struct __net__Set8021XActiveS0 *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__Set8021XActiveS0 * SOAP_FMAC4 soap_instantiate___net__Set8021XActiveS0(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__Set8021XActiveS0(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__Set8021XActiveS0, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__Set8021XActiveS0; + if (size) + *size = sizeof(struct __net__Set8021XActiveS0); + } + else + { cp->ptr = (void*)new struct __net__Set8021XActiveS0[n]; + if (size) + *size = n * sizeof(struct __net__Set8021XActiveS0); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__Set8021XActiveS0*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Set8021XActiveS0(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__Set8021XActiveS0 %p -> %p\n", q, p)); + *(struct __net__Set8021XActiveS0*)p = *(struct __net__Set8021XActiveS0*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Get8021XWiredProfile(struct soap *soap, const struct __net__Get8021XWiredProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__Get8021XWiredProfile(soap, &a->net__Get8021XWiredProfile); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Get8021XWiredProfile(struct soap *soap, struct __net__Get8021XWiredProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__Get8021XWiredProfile = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Get8021XWiredProfile(struct soap *soap, const struct __net__Get8021XWiredProfile *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__Get8021XWiredProfile(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Get8021XWiredProfile(struct soap *soap, const char *tag, int id, const struct __net__Get8021XWiredProfile *a, const char *type) +{ + soap_out_PointerTo_net__Get8021XWiredProfile(soap, "net:Get8021XWiredProfile", -1, &a->net__Get8021XWiredProfile, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__Get8021XWiredProfile * SOAP_FMAC4 soap_get___net__Get8021XWiredProfile(struct soap *soap, struct __net__Get8021XWiredProfile *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__Get8021XWiredProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__Get8021XWiredProfile * SOAP_FMAC4 soap_in___net__Get8021XWiredProfile(struct soap *soap, const char *tag, struct __net__Get8021XWiredProfile *a, const char *type) +{ + short soap_flag_net__Get8021XWiredProfile = 1; + a = (struct __net__Get8021XWiredProfile *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__Get8021XWiredProfile, sizeof(struct __net__Get8021XWiredProfile), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__Get8021XWiredProfile(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__Get8021XWiredProfile && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__Get8021XWiredProfile(soap, "net:Get8021XWiredProfile", &a->net__Get8021XWiredProfile, "")) + { soap_flag_net__Get8021XWiredProfile--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__Get8021XWiredProfile * SOAP_FMAC6 soap_new___net__Get8021XWiredProfile(struct soap *soap, int n) +{ return soap_instantiate___net__Get8021XWiredProfile(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Get8021XWiredProfile(struct soap *soap, struct __net__Get8021XWiredProfile *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__Get8021XWiredProfile * SOAP_FMAC4 soap_instantiate___net__Get8021XWiredProfile(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__Get8021XWiredProfile(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__Get8021XWiredProfile, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__Get8021XWiredProfile; + if (size) + *size = sizeof(struct __net__Get8021XWiredProfile); + } + else + { cp->ptr = (void*)new struct __net__Get8021XWiredProfile[n]; + if (size) + *size = n * sizeof(struct __net__Get8021XWiredProfile); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__Get8021XWiredProfile*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Get8021XWiredProfile(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__Get8021XWiredProfile %p -> %p\n", q, p)); + *(struct __net__Get8021XWiredProfile*)p = *(struct __net__Get8021XWiredProfile*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__Set8021XWiredProfile(struct soap *soap, const struct __net__Set8021XWiredProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__Set8021XWiredProfile(soap, &a->net__Set8021XWiredProfile); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__Set8021XWiredProfile(struct soap *soap, struct __net__Set8021XWiredProfile *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__Set8021XWiredProfile = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__Set8021XWiredProfile(struct soap *soap, const struct __net__Set8021XWiredProfile *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__Set8021XWiredProfile(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__Set8021XWiredProfile(struct soap *soap, const char *tag, int id, const struct __net__Set8021XWiredProfile *a, const char *type) +{ + soap_out_PointerTo_net__Set8021XWiredProfile(soap, "net:Set8021XWiredProfile", -1, &a->net__Set8021XWiredProfile, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__Set8021XWiredProfile * SOAP_FMAC4 soap_get___net__Set8021XWiredProfile(struct soap *soap, struct __net__Set8021XWiredProfile *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__Set8021XWiredProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__Set8021XWiredProfile * SOAP_FMAC4 soap_in___net__Set8021XWiredProfile(struct soap *soap, const char *tag, struct __net__Set8021XWiredProfile *a, const char *type) +{ + short soap_flag_net__Set8021XWiredProfile = 1; + a = (struct __net__Set8021XWiredProfile *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__Set8021XWiredProfile, sizeof(struct __net__Set8021XWiredProfile), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__Set8021XWiredProfile(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__Set8021XWiredProfile && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__Set8021XWiredProfile(soap, "net:Set8021XWiredProfile", &a->net__Set8021XWiredProfile, "")) + { soap_flag_net__Set8021XWiredProfile--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__Set8021XWiredProfile * SOAP_FMAC6 soap_new___net__Set8021XWiredProfile(struct soap *soap, int n) +{ return soap_instantiate___net__Set8021XWiredProfile(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__Set8021XWiredProfile(struct soap *soap, struct __net__Set8021XWiredProfile *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__Set8021XWiredProfile * SOAP_FMAC4 soap_instantiate___net__Set8021XWiredProfile(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__Set8021XWiredProfile(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__Set8021XWiredProfile, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__Set8021XWiredProfile; + if (size) + *size = sizeof(struct __net__Set8021XWiredProfile); + } + else + { cp->ptr = (void*)new struct __net__Set8021XWiredProfile[n]; + if (size) + *size = n * sizeof(struct __net__Set8021XWiredProfile); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__Set8021XWiredProfile*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__Set8021XWiredProfile(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__Set8021XWiredProfile %p -> %p\n", q, p)); + *(struct __net__Set8021XWiredProfile*)p = *(struct __net__Set8021XWiredProfile*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetInterfaceSettings(struct soap *soap, const struct __net__SetInterfaceSettings *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__SetInterfaceSettings(soap, &a->net__SetInterfaceSettings); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetInterfaceSettings(struct soap *soap, struct __net__SetInterfaceSettings *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__SetInterfaceSettings = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetInterfaceSettings(struct soap *soap, const struct __net__SetInterfaceSettings *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__SetInterfaceSettings(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetInterfaceSettings(struct soap *soap, const char *tag, int id, const struct __net__SetInterfaceSettings *a, const char *type) +{ + soap_out_PointerTo_net__SetInterfaceSettings(soap, "net:SetInterfaceSettings", -1, &a->net__SetInterfaceSettings, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__SetInterfaceSettings * SOAP_FMAC4 soap_get___net__SetInterfaceSettings(struct soap *soap, struct __net__SetInterfaceSettings *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__SetInterfaceSettings(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__SetInterfaceSettings * SOAP_FMAC4 soap_in___net__SetInterfaceSettings(struct soap *soap, const char *tag, struct __net__SetInterfaceSettings *a, const char *type) +{ + short soap_flag_net__SetInterfaceSettings = 1; + a = (struct __net__SetInterfaceSettings *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__SetInterfaceSettings, sizeof(struct __net__SetInterfaceSettings), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__SetInterfaceSettings(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__SetInterfaceSettings && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__SetInterfaceSettings(soap, "net:SetInterfaceSettings", &a->net__SetInterfaceSettings, "")) + { soap_flag_net__SetInterfaceSettings--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__SetInterfaceSettings * SOAP_FMAC6 soap_new___net__SetInterfaceSettings(struct soap *soap, int n) +{ return soap_instantiate___net__SetInterfaceSettings(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetInterfaceSettings(struct soap *soap, struct __net__SetInterfaceSettings *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__SetInterfaceSettings * SOAP_FMAC4 soap_instantiate___net__SetInterfaceSettings(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__SetInterfaceSettings(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__SetInterfaceSettings, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__SetInterfaceSettings; + if (size) + *size = sizeof(struct __net__SetInterfaceSettings); + } + else + { cp->ptr = (void*)new struct __net__SetInterfaceSettings[n]; + if (size) + *size = n * sizeof(struct __net__SetInterfaceSettings); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__SetInterfaceSettings*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetInterfaceSettings(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__SetInterfaceSettings %p -> %p\n", q, p)); + *(struct __net__SetInterfaceSettings*)p = *(struct __net__SetInterfaceSettings*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetInterfaceSettings(struct soap *soap, const struct __net__GetInterfaceSettings *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__GetInterfaceSettings(soap, &a->net__GetInterfaceSettings); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetInterfaceSettings(struct soap *soap, struct __net__GetInterfaceSettings *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__GetInterfaceSettings = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetInterfaceSettings(struct soap *soap, const struct __net__GetInterfaceSettings *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__GetInterfaceSettings(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetInterfaceSettings(struct soap *soap, const char *tag, int id, const struct __net__GetInterfaceSettings *a, const char *type) +{ + soap_out_PointerTo_net__GetInterfaceSettings(soap, "net:GetInterfaceSettings", -1, &a->net__GetInterfaceSettings, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__GetInterfaceSettings * SOAP_FMAC4 soap_get___net__GetInterfaceSettings(struct soap *soap, struct __net__GetInterfaceSettings *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__GetInterfaceSettings(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__GetInterfaceSettings * SOAP_FMAC4 soap_in___net__GetInterfaceSettings(struct soap *soap, const char *tag, struct __net__GetInterfaceSettings *a, const char *type) +{ + short soap_flag_net__GetInterfaceSettings = 1; + a = (struct __net__GetInterfaceSettings *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__GetInterfaceSettings, sizeof(struct __net__GetInterfaceSettings), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__GetInterfaceSettings(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__GetInterfaceSettings && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__GetInterfaceSettings(soap, "net:GetInterfaceSettings", &a->net__GetInterfaceSettings, "")) + { soap_flag_net__GetInterfaceSettings--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__GetInterfaceSettings * SOAP_FMAC6 soap_new___net__GetInterfaceSettings(struct soap *soap, int n) +{ return soap_instantiate___net__GetInterfaceSettings(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetInterfaceSettings(struct soap *soap, struct __net__GetInterfaceSettings *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__GetInterfaceSettings * SOAP_FMAC4 soap_instantiate___net__GetInterfaceSettings(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__GetInterfaceSettings(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__GetInterfaceSettings, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__GetInterfaceSettings; + if (size) + *size = sizeof(struct __net__GetInterfaceSettings); + } + else + { cp->ptr = (void*)new struct __net__GetInterfaceSettings[n]; + if (size) + *size = n * sizeof(struct __net__GetInterfaceSettings); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__GetInterfaceSettings*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetInterfaceSettings(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__GetInterfaceSettings %p -> %p\n", q, p)); + *(struct __net__GetInterfaceSettings*)p = *(struct __net__GetInterfaceSettings*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__EnumerateInterfaces(struct soap *soap, const struct __net__EnumerateInterfaces *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__EnumerateInterfaces(soap, &a->net__EnumerateInterfaces); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__EnumerateInterfaces(struct soap *soap, struct __net__EnumerateInterfaces *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__EnumerateInterfaces = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__EnumerateInterfaces(struct soap *soap, const struct __net__EnumerateInterfaces *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__EnumerateInterfaces(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__EnumerateInterfaces(struct soap *soap, const char *tag, int id, const struct __net__EnumerateInterfaces *a, const char *type) +{ + soap_out_PointerTo_net__EnumerateInterfaces(soap, "net:EnumerateInterfaces", -1, &a->net__EnumerateInterfaces, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__EnumerateInterfaces * SOAP_FMAC4 soap_get___net__EnumerateInterfaces(struct soap *soap, struct __net__EnumerateInterfaces *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__EnumerateInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__EnumerateInterfaces * SOAP_FMAC4 soap_in___net__EnumerateInterfaces(struct soap *soap, const char *tag, struct __net__EnumerateInterfaces *a, const char *type) +{ + short soap_flag_net__EnumerateInterfaces = 1; + a = (struct __net__EnumerateInterfaces *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__EnumerateInterfaces, sizeof(struct __net__EnumerateInterfaces), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__EnumerateInterfaces(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__EnumerateInterfaces && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__EnumerateInterfaces(soap, "net:EnumerateInterfaces", &a->net__EnumerateInterfaces, "")) + { soap_flag_net__EnumerateInterfaces--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__EnumerateInterfaces * SOAP_FMAC6 soap_new___net__EnumerateInterfaces(struct soap *soap, int n) +{ return soap_instantiate___net__EnumerateInterfaces(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__EnumerateInterfaces(struct soap *soap, struct __net__EnumerateInterfaces *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__EnumerateInterfaces * SOAP_FMAC4 soap_instantiate___net__EnumerateInterfaces(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__EnumerateInterfaces(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__EnumerateInterfaces, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__EnumerateInterfaces; + if (size) + *size = sizeof(struct __net__EnumerateInterfaces); + } + else + { cp->ptr = (void*)new struct __net__EnumerateInterfaces[n]; + if (size) + *size = n * sizeof(struct __net__EnumerateInterfaces); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__EnumerateInterfaces*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__EnumerateInterfaces(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__EnumerateInterfaces %p -> %p\n", q, p)); + *(struct __net__EnumerateInterfaces*)p = *(struct __net__EnumerateInterfaces*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetPingResponse(struct soap *soap, const struct __net__GetPingResponse *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__GetPingResponse(soap, &a->net__GetPingResponse); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetPingResponse(struct soap *soap, struct __net__GetPingResponse *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__GetPingResponse = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetPingResponse(struct soap *soap, const struct __net__GetPingResponse *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__GetPingResponse(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetPingResponse(struct soap *soap, const char *tag, int id, const struct __net__GetPingResponse *a, const char *type) +{ + soap_out_PointerTo_net__GetPingResponse(soap, "net:GetPingResponse", -1, &a->net__GetPingResponse, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__GetPingResponse * SOAP_FMAC4 soap_get___net__GetPingResponse(struct soap *soap, struct __net__GetPingResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__GetPingResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__GetPingResponse * SOAP_FMAC4 soap_in___net__GetPingResponse(struct soap *soap, const char *tag, struct __net__GetPingResponse *a, const char *type) +{ + short soap_flag_net__GetPingResponse = 1; + a = (struct __net__GetPingResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__GetPingResponse, sizeof(struct __net__GetPingResponse), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__GetPingResponse(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__GetPingResponse && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__GetPingResponse(soap, "net:GetPingResponse", &a->net__GetPingResponse, "")) + { soap_flag_net__GetPingResponse--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__GetPingResponse * SOAP_FMAC6 soap_new___net__GetPingResponse(struct soap *soap, int n) +{ return soap_instantiate___net__GetPingResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetPingResponse(struct soap *soap, struct __net__GetPingResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__GetPingResponse * SOAP_FMAC4 soap_instantiate___net__GetPingResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__GetPingResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__GetPingResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__GetPingResponse; + if (size) + *size = sizeof(struct __net__GetPingResponse); + } + else + { cp->ptr = (void*)new struct __net__GetPingResponse[n]; + if (size) + *size = n * sizeof(struct __net__GetPingResponse); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__GetPingResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetPingResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__GetPingResponse %p -> %p\n", q, p)); + *(struct __net__GetPingResponse*)p = *(struct __net__GetPingResponse*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetPingResponse(struct soap *soap, const struct __net__SetPingResponse *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__SetPingResponse(soap, &a->net__SetPingResponse); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetPingResponse(struct soap *soap, struct __net__SetPingResponse *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__SetPingResponse = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetPingResponse(struct soap *soap, const struct __net__SetPingResponse *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__SetPingResponse(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetPingResponse(struct soap *soap, const char *tag, int id, const struct __net__SetPingResponse *a, const char *type) +{ + soap_out_PointerTo_net__SetPingResponse(soap, "net:SetPingResponse", -1, &a->net__SetPingResponse, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__SetPingResponse * SOAP_FMAC4 soap_get___net__SetPingResponse(struct soap *soap, struct __net__SetPingResponse *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__SetPingResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__SetPingResponse * SOAP_FMAC4 soap_in___net__SetPingResponse(struct soap *soap, const char *tag, struct __net__SetPingResponse *a, const char *type) +{ + short soap_flag_net__SetPingResponse = 1; + a = (struct __net__SetPingResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__SetPingResponse, sizeof(struct __net__SetPingResponse), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__SetPingResponse(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__SetPingResponse && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__SetPingResponse(soap, "net:SetPingResponse", &a->net__SetPingResponse, "")) + { soap_flag_net__SetPingResponse--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__SetPingResponse * SOAP_FMAC6 soap_new___net__SetPingResponse(struct soap *soap, int n) +{ return soap_instantiate___net__SetPingResponse(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetPingResponse(struct soap *soap, struct __net__SetPingResponse *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__SetPingResponse * SOAP_FMAC4 soap_instantiate___net__SetPingResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__SetPingResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__SetPingResponse, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__SetPingResponse; + if (size) + *size = sizeof(struct __net__SetPingResponse); + } + else + { cp->ptr = (void*)new struct __net__SetPingResponse[n]; + if (size) + *size = n * sizeof(struct __net__SetPingResponse); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__SetPingResponse*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetPingResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__SetPingResponse %p -> %p\n", q, p)); + *(struct __net__SetPingResponse*)p = *(struct __net__SetPingResponse*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetVlanParameters(struct soap *soap, const struct __net__GetVlanParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__GetVlanParameters(soap, &a->net__GetVlanParameters); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetVlanParameters(struct soap *soap, struct __net__GetVlanParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__GetVlanParameters = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetVlanParameters(struct soap *soap, const struct __net__GetVlanParameters *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__GetVlanParameters(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetVlanParameters(struct soap *soap, const char *tag, int id, const struct __net__GetVlanParameters *a, const char *type) +{ + soap_out_PointerTo_net__GetVlanParameters(soap, "net:GetVlanParameters", -1, &a->net__GetVlanParameters, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__GetVlanParameters * SOAP_FMAC4 soap_get___net__GetVlanParameters(struct soap *soap, struct __net__GetVlanParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__GetVlanParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__GetVlanParameters * SOAP_FMAC4 soap_in___net__GetVlanParameters(struct soap *soap, const char *tag, struct __net__GetVlanParameters *a, const char *type) +{ + short soap_flag_net__GetVlanParameters = 1; + a = (struct __net__GetVlanParameters *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__GetVlanParameters, sizeof(struct __net__GetVlanParameters), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__GetVlanParameters(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__GetVlanParameters && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__GetVlanParameters(soap, "net:GetVlanParameters", &a->net__GetVlanParameters, "")) + { soap_flag_net__GetVlanParameters--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__GetVlanParameters * SOAP_FMAC6 soap_new___net__GetVlanParameters(struct soap *soap, int n) +{ return soap_instantiate___net__GetVlanParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetVlanParameters(struct soap *soap, struct __net__GetVlanParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__GetVlanParameters * SOAP_FMAC4 soap_instantiate___net__GetVlanParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__GetVlanParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__GetVlanParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__GetVlanParameters; + if (size) + *size = sizeof(struct __net__GetVlanParameters); + } + else + { cp->ptr = (void*)new struct __net__GetVlanParameters[n]; + if (size) + *size = n * sizeof(struct __net__GetVlanParameters); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__GetVlanParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetVlanParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__GetVlanParameters %p -> %p\n", q, p)); + *(struct __net__GetVlanParameters*)p = *(struct __net__GetVlanParameters*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetVlanParameters(struct soap *soap, const struct __net__SetVlanParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__SetVlanParameters(soap, &a->net__SetVlanParameters); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetVlanParameters(struct soap *soap, struct __net__SetVlanParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__SetVlanParameters = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetVlanParameters(struct soap *soap, const struct __net__SetVlanParameters *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__SetVlanParameters(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetVlanParameters(struct soap *soap, const char *tag, int id, const struct __net__SetVlanParameters *a, const char *type) +{ + soap_out_PointerTo_net__SetVlanParameters(soap, "net:SetVlanParameters", -1, &a->net__SetVlanParameters, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__SetVlanParameters * SOAP_FMAC4 soap_get___net__SetVlanParameters(struct soap *soap, struct __net__SetVlanParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__SetVlanParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__SetVlanParameters * SOAP_FMAC4 soap_in___net__SetVlanParameters(struct soap *soap, const char *tag, struct __net__SetVlanParameters *a, const char *type) +{ + short soap_flag_net__SetVlanParameters = 1; + a = (struct __net__SetVlanParameters *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__SetVlanParameters, sizeof(struct __net__SetVlanParameters), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__SetVlanParameters(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__SetVlanParameters && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__SetVlanParameters(soap, "net:SetVlanParameters", &a->net__SetVlanParameters, "")) + { soap_flag_net__SetVlanParameters--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__SetVlanParameters * SOAP_FMAC6 soap_new___net__SetVlanParameters(struct soap *soap, int n) +{ return soap_instantiate___net__SetVlanParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetVlanParameters(struct soap *soap, struct __net__SetVlanParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__SetVlanParameters * SOAP_FMAC4 soap_instantiate___net__SetVlanParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__SetVlanParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__SetVlanParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__SetVlanParameters; + if (size) + *size = sizeof(struct __net__SetVlanParameters); + } + else + { cp->ptr = (void*)new struct __net__SetVlanParameters[n]; + if (size) + *size = n * sizeof(struct __net__SetVlanParameters); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__SetVlanParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetVlanParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__SetVlanParameters %p -> %p\n", q, p)); + *(struct __net__SetVlanParameters*)p = *(struct __net__SetVlanParameters*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetTcpIpParameters(struct soap *soap, const struct __net__GetTcpIpParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__GetTcpIpParameters(soap, &a->net__GetTcpIpParameters); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetTcpIpParameters(struct soap *soap, struct __net__GetTcpIpParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__GetTcpIpParameters = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetTcpIpParameters(struct soap *soap, const struct __net__GetTcpIpParameters *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__GetTcpIpParameters(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetTcpIpParameters(struct soap *soap, const char *tag, int id, const struct __net__GetTcpIpParameters *a, const char *type) +{ + soap_out_PointerTo_net__GetTcpIpParameters(soap, "net:GetTcpIpParameters", -1, &a->net__GetTcpIpParameters, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__GetTcpIpParameters * SOAP_FMAC4 soap_get___net__GetTcpIpParameters(struct soap *soap, struct __net__GetTcpIpParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__GetTcpIpParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__GetTcpIpParameters * SOAP_FMAC4 soap_in___net__GetTcpIpParameters(struct soap *soap, const char *tag, struct __net__GetTcpIpParameters *a, const char *type) +{ + short soap_flag_net__GetTcpIpParameters = 1; + a = (struct __net__GetTcpIpParameters *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__GetTcpIpParameters, sizeof(struct __net__GetTcpIpParameters), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__GetTcpIpParameters(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__GetTcpIpParameters && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__GetTcpIpParameters(soap, "net:GetTcpIpParameters", &a->net__GetTcpIpParameters, "")) + { soap_flag_net__GetTcpIpParameters--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__GetTcpIpParameters * SOAP_FMAC6 soap_new___net__GetTcpIpParameters(struct soap *soap, int n) +{ return soap_instantiate___net__GetTcpIpParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetTcpIpParameters(struct soap *soap, struct __net__GetTcpIpParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__GetTcpIpParameters * SOAP_FMAC4 soap_instantiate___net__GetTcpIpParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__GetTcpIpParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__GetTcpIpParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__GetTcpIpParameters; + if (size) + *size = sizeof(struct __net__GetTcpIpParameters); + } + else + { cp->ptr = (void*)new struct __net__GetTcpIpParameters[n]; + if (size) + *size = n * sizeof(struct __net__GetTcpIpParameters); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__GetTcpIpParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetTcpIpParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__GetTcpIpParameters %p -> %p\n", q, p)); + *(struct __net__GetTcpIpParameters*)p = *(struct __net__GetTcpIpParameters*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetTcpIpParameters(struct soap *soap, const struct __net__SetTcpIpParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__SetTcpIpParameters(soap, &a->net__SetTcpIpParameters); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetTcpIpParameters(struct soap *soap, struct __net__SetTcpIpParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__SetTcpIpParameters = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetTcpIpParameters(struct soap *soap, const struct __net__SetTcpIpParameters *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__SetTcpIpParameters(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetTcpIpParameters(struct soap *soap, const char *tag, int id, const struct __net__SetTcpIpParameters *a, const char *type) +{ + soap_out_PointerTo_net__SetTcpIpParameters(soap, "net:SetTcpIpParameters", -1, &a->net__SetTcpIpParameters, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__SetTcpIpParameters * SOAP_FMAC4 soap_get___net__SetTcpIpParameters(struct soap *soap, struct __net__SetTcpIpParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__SetTcpIpParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__SetTcpIpParameters * SOAP_FMAC4 soap_in___net__SetTcpIpParameters(struct soap *soap, const char *tag, struct __net__SetTcpIpParameters *a, const char *type) +{ + short soap_flag_net__SetTcpIpParameters = 1; + a = (struct __net__SetTcpIpParameters *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__SetTcpIpParameters, sizeof(struct __net__SetTcpIpParameters), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__SetTcpIpParameters(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__SetTcpIpParameters && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__SetTcpIpParameters(soap, "net:SetTcpIpParameters", &a->net__SetTcpIpParameters, "")) + { soap_flag_net__SetTcpIpParameters--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__SetTcpIpParameters * SOAP_FMAC6 soap_new___net__SetTcpIpParameters(struct soap *soap, int n) +{ return soap_instantiate___net__SetTcpIpParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetTcpIpParameters(struct soap *soap, struct __net__SetTcpIpParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__SetTcpIpParameters * SOAP_FMAC4 soap_instantiate___net__SetTcpIpParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__SetTcpIpParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__SetTcpIpParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__SetTcpIpParameters; + if (size) + *size = sizeof(struct __net__SetTcpIpParameters); + } + else + { cp->ptr = (void*)new struct __net__SetTcpIpParameters[n]; + if (size) + *size = n * sizeof(struct __net__SetTcpIpParameters); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__SetTcpIpParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetTcpIpParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__SetTcpIpParameters %p -> %p\n", q, p)); + *(struct __net__SetTcpIpParameters*)p = *(struct __net__SetTcpIpParameters*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetDomainName(struct soap *soap, const struct __net__GetDomainName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__GetDomainName(soap, &a->net__GetDomainName); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetDomainName(struct soap *soap, struct __net__GetDomainName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__GetDomainName = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetDomainName(struct soap *soap, const struct __net__GetDomainName *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__GetDomainName(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetDomainName(struct soap *soap, const char *tag, int id, const struct __net__GetDomainName *a, const char *type) +{ + soap_out_PointerTo_net__GetDomainName(soap, "net:GetDomainName", -1, &a->net__GetDomainName, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__GetDomainName * SOAP_FMAC4 soap_get___net__GetDomainName(struct soap *soap, struct __net__GetDomainName *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__GetDomainName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__GetDomainName * SOAP_FMAC4 soap_in___net__GetDomainName(struct soap *soap, const char *tag, struct __net__GetDomainName *a, const char *type) +{ + short soap_flag_net__GetDomainName = 1; + a = (struct __net__GetDomainName *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__GetDomainName, sizeof(struct __net__GetDomainName), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__GetDomainName(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__GetDomainName && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__GetDomainName(soap, "net:GetDomainName", &a->net__GetDomainName, "")) + { soap_flag_net__GetDomainName--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__GetDomainName * SOAP_FMAC6 soap_new___net__GetDomainName(struct soap *soap, int n) +{ return soap_instantiate___net__GetDomainName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetDomainName(struct soap *soap, struct __net__GetDomainName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__GetDomainName * SOAP_FMAC4 soap_instantiate___net__GetDomainName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__GetDomainName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__GetDomainName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__GetDomainName; + if (size) + *size = sizeof(struct __net__GetDomainName); + } + else + { cp->ptr = (void*)new struct __net__GetDomainName[n]; + if (size) + *size = n * sizeof(struct __net__GetDomainName); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__GetDomainName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetDomainName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__GetDomainName %p -> %p\n", q, p)); + *(struct __net__GetDomainName*)p = *(struct __net__GetDomainName*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetDomainName(struct soap *soap, const struct __net__SetDomainName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__SetDomainName(soap, &a->net__SetDomainName); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetDomainName(struct soap *soap, struct __net__SetDomainName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__SetDomainName = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetDomainName(struct soap *soap, const struct __net__SetDomainName *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__SetDomainName(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetDomainName(struct soap *soap, const char *tag, int id, const struct __net__SetDomainName *a, const char *type) +{ + soap_out_PointerTo_net__SetDomainName(soap, "net:SetDomainName", -1, &a->net__SetDomainName, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__SetDomainName * SOAP_FMAC4 soap_get___net__SetDomainName(struct soap *soap, struct __net__SetDomainName *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__SetDomainName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__SetDomainName * SOAP_FMAC4 soap_in___net__SetDomainName(struct soap *soap, const char *tag, struct __net__SetDomainName *a, const char *type) +{ + short soap_flag_net__SetDomainName = 1; + a = (struct __net__SetDomainName *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__SetDomainName, sizeof(struct __net__SetDomainName), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__SetDomainName(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__SetDomainName && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__SetDomainName(soap, "net:SetDomainName", &a->net__SetDomainName, "")) + { soap_flag_net__SetDomainName--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__SetDomainName * SOAP_FMAC6 soap_new___net__SetDomainName(struct soap *soap, int n) +{ return soap_instantiate___net__SetDomainName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetDomainName(struct soap *soap, struct __net__SetDomainName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__SetDomainName * SOAP_FMAC4 soap_instantiate___net__SetDomainName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__SetDomainName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__SetDomainName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__SetDomainName; + if (size) + *size = sizeof(struct __net__SetDomainName); + } + else + { cp->ptr = (void*)new struct __net__SetDomainName[n]; + if (size) + *size = n * sizeof(struct __net__SetDomainName); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__SetDomainName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetDomainName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__SetDomainName %p -> %p\n", q, p)); + *(struct __net__SetDomainName*)p = *(struct __net__SetDomainName*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__GetHostName(struct soap *soap, const struct __net__GetHostName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__GetHostName(soap, &a->net__GetHostName); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__GetHostName(struct soap *soap, struct __net__GetHostName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__GetHostName = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__GetHostName(struct soap *soap, const struct __net__GetHostName *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__GetHostName(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__GetHostName(struct soap *soap, const char *tag, int id, const struct __net__GetHostName *a, const char *type) +{ + soap_out_PointerTo_net__GetHostName(soap, "net:GetHostName", -1, &a->net__GetHostName, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__GetHostName * SOAP_FMAC4 soap_get___net__GetHostName(struct soap *soap, struct __net__GetHostName *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__GetHostName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__GetHostName * SOAP_FMAC4 soap_in___net__GetHostName(struct soap *soap, const char *tag, struct __net__GetHostName *a, const char *type) +{ + short soap_flag_net__GetHostName = 1; + a = (struct __net__GetHostName *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__GetHostName, sizeof(struct __net__GetHostName), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__GetHostName(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__GetHostName && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__GetHostName(soap, "net:GetHostName", &a->net__GetHostName, "")) + { soap_flag_net__GetHostName--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__GetHostName * SOAP_FMAC6 soap_new___net__GetHostName(struct soap *soap, int n) +{ return soap_instantiate___net__GetHostName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__GetHostName(struct soap *soap, struct __net__GetHostName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__GetHostName * SOAP_FMAC4 soap_instantiate___net__GetHostName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__GetHostName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__GetHostName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__GetHostName; + if (size) + *size = sizeof(struct __net__GetHostName); + } + else + { cp->ptr = (void*)new struct __net__GetHostName[n]; + if (size) + *size = n * sizeof(struct __net__GetHostName); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__GetHostName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__GetHostName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__GetHostName %p -> %p\n", q, p)); + *(struct __net__GetHostName*)p = *(struct __net__GetHostName*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___net__SetHostName(struct soap *soap, const struct __net__SetHostName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_net__SetHostName(soap, &a->net__SetHostName); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___net__SetHostName(struct soap *soap, struct __net__SetHostName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->net__SetHostName = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___net__SetHostName(struct soap *soap, const struct __net__SetHostName *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___net__SetHostName(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___net__SetHostName(struct soap *soap, const char *tag, int id, const struct __net__SetHostName *a, const char *type) +{ + soap_out_PointerTo_net__SetHostName(soap, "net:SetHostName", -1, &a->net__SetHostName, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __net__SetHostName * SOAP_FMAC4 soap_get___net__SetHostName(struct soap *soap, struct __net__SetHostName *p, const char *tag, const char *type) +{ + if ((p = soap_in___net__SetHostName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __net__SetHostName * SOAP_FMAC4 soap_in___net__SetHostName(struct soap *soap, const char *tag, struct __net__SetHostName *a, const char *type) +{ + short soap_flag_net__SetHostName = 1; + a = (struct __net__SetHostName *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___net__SetHostName, sizeof(struct __net__SetHostName), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___net__SetHostName(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_net__SetHostName && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_net__SetHostName(soap, "net:SetHostName", &a->net__SetHostName, "")) + { soap_flag_net__SetHostName--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __net__SetHostName * SOAP_FMAC6 soap_new___net__SetHostName(struct soap *soap, int n) +{ return soap_instantiate___net__SetHostName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___net__SetHostName(struct soap *soap, struct __net__SetHostName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __net__SetHostName * SOAP_FMAC4 soap_instantiate___net__SetHostName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___net__SetHostName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___net__SetHostName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __net__SetHostName; + if (size) + *size = sizeof(struct __net__SetHostName); + } + else + { cp->ptr = (void*)new struct __net__SetHostName[n]; + if (size) + *size = n * sizeof(struct __net__SetHostName); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __net__SetHostName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___net__SetHostName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __net__SetHostName %p -> %p\n", q, p)); + *(struct __net__SetHostName*)p = *(struct __net__SetHostName*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetIderSessionLog(struct soap *soap, const struct __inf__GetIderSessionLog *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetIderSessionLog(soap, &a->inf__GetIderSessionLog); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetIderSessionLog(struct soap *soap, struct __inf__GetIderSessionLog *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetIderSessionLog = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetIderSessionLog(struct soap *soap, const struct __inf__GetIderSessionLog *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetIderSessionLog(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetIderSessionLog(struct soap *soap, const char *tag, int id, const struct __inf__GetIderSessionLog *a, const char *type) +{ + soap_out_PointerTo_inf__GetIderSessionLog(soap, "inf:GetIderSessionLog", -1, &a->inf__GetIderSessionLog, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetIderSessionLog * SOAP_FMAC4 soap_get___inf__GetIderSessionLog(struct soap *soap, struct __inf__GetIderSessionLog *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetIderSessionLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetIderSessionLog * SOAP_FMAC4 soap_in___inf__GetIderSessionLog(struct soap *soap, const char *tag, struct __inf__GetIderSessionLog *a, const char *type) +{ + short soap_flag_inf__GetIderSessionLog = 1; + a = (struct __inf__GetIderSessionLog *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetIderSessionLog, sizeof(struct __inf__GetIderSessionLog), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetIderSessionLog(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetIderSessionLog && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetIderSessionLog(soap, "inf:GetIderSessionLog", &a->inf__GetIderSessionLog, "")) + { soap_flag_inf__GetIderSessionLog--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetIderSessionLog * SOAP_FMAC6 soap_new___inf__GetIderSessionLog(struct soap *soap, int n) +{ return soap_instantiate___inf__GetIderSessionLog(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetIderSessionLog(struct soap *soap, struct __inf__GetIderSessionLog *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetIderSessionLog * SOAP_FMAC4 soap_instantiate___inf__GetIderSessionLog(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetIderSessionLog(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetIderSessionLog, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetIderSessionLog; + if (size) + *size = sizeof(struct __inf__GetIderSessionLog); + } + else + { cp->ptr = (void*)new struct __inf__GetIderSessionLog[n]; + if (size) + *size = n * sizeof(struct __inf__GetIderSessionLog); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetIderSessionLog*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetIderSessionLog(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetIderSessionLog %p -> %p\n", q, p)); + *(struct __inf__GetIderSessionLog*)p = *(struct __inf__GetIderSessionLog*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetSecurityParameters(struct soap *soap, const struct __inf__GetSecurityParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetSecurityParameters(soap, &a->inf__GetSecurityParameters); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetSecurityParameters(struct soap *soap, struct __inf__GetSecurityParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetSecurityParameters = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetSecurityParameters(struct soap *soap, const struct __inf__GetSecurityParameters *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetSecurityParameters(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetSecurityParameters(struct soap *soap, const char *tag, int id, const struct __inf__GetSecurityParameters *a, const char *type) +{ + soap_out_PointerTo_inf__GetSecurityParameters(soap, "inf:GetSecurityParameters", -1, &a->inf__GetSecurityParameters, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetSecurityParameters * SOAP_FMAC4 soap_get___inf__GetSecurityParameters(struct soap *soap, struct __inf__GetSecurityParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetSecurityParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetSecurityParameters * SOAP_FMAC4 soap_in___inf__GetSecurityParameters(struct soap *soap, const char *tag, struct __inf__GetSecurityParameters *a, const char *type) +{ + short soap_flag_inf__GetSecurityParameters = 1; + a = (struct __inf__GetSecurityParameters *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetSecurityParameters, sizeof(struct __inf__GetSecurityParameters), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetSecurityParameters(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetSecurityParameters && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetSecurityParameters(soap, "inf:GetSecurityParameters", &a->inf__GetSecurityParameters, "")) + { soap_flag_inf__GetSecurityParameters--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetSecurityParameters * SOAP_FMAC6 soap_new___inf__GetSecurityParameters(struct soap *soap, int n) +{ return soap_instantiate___inf__GetSecurityParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetSecurityParameters(struct soap *soap, struct __inf__GetSecurityParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetSecurityParameters * SOAP_FMAC4 soap_instantiate___inf__GetSecurityParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetSecurityParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetSecurityParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetSecurityParameters; + if (size) + *size = sizeof(struct __inf__GetSecurityParameters); + } + else + { cp->ptr = (void*)new struct __inf__GetSecurityParameters[n]; + if (size) + *size = n * sizeof(struct __inf__GetSecurityParameters); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetSecurityParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetSecurityParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetSecurityParameters %p -> %p\n", q, p)); + *(struct __inf__GetSecurityParameters*)p = *(struct __inf__GetSecurityParameters*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetNetworkState(struct soap *soap, const struct __inf__GetNetworkState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetNetworkState(soap, &a->inf__GetNetworkState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetNetworkState(struct soap *soap, struct __inf__GetNetworkState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetNetworkState = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetNetworkState(struct soap *soap, const struct __inf__GetNetworkState *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetNetworkState(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetNetworkState(struct soap *soap, const char *tag, int id, const struct __inf__GetNetworkState *a, const char *type) +{ + soap_out_PointerTo_inf__GetNetworkState(soap, "inf:GetNetworkState", -1, &a->inf__GetNetworkState, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetNetworkState * SOAP_FMAC4 soap_get___inf__GetNetworkState(struct soap *soap, struct __inf__GetNetworkState *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetNetworkState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetNetworkState * SOAP_FMAC4 soap_in___inf__GetNetworkState(struct soap *soap, const char *tag, struct __inf__GetNetworkState *a, const char *type) +{ + short soap_flag_inf__GetNetworkState = 1; + a = (struct __inf__GetNetworkState *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetNetworkState, sizeof(struct __inf__GetNetworkState), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetNetworkState(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetNetworkState && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetNetworkState(soap, "inf:GetNetworkState", &a->inf__GetNetworkState, "")) + { soap_flag_inf__GetNetworkState--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetNetworkState * SOAP_FMAC6 soap_new___inf__GetNetworkState(struct soap *soap, int n) +{ return soap_instantiate___inf__GetNetworkState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetNetworkState(struct soap *soap, struct __inf__GetNetworkState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetNetworkState * SOAP_FMAC4 soap_instantiate___inf__GetNetworkState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetNetworkState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetNetworkState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetNetworkState; + if (size) + *size = sizeof(struct __inf__GetNetworkState); + } + else + { cp->ptr = (void*)new struct __inf__GetNetworkState[n]; + if (size) + *size = n * sizeof(struct __inf__GetNetworkState); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetNetworkState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetNetworkState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetNetworkState %p -> %p\n", q, p)); + *(struct __inf__GetNetworkState*)p = *(struct __inf__GetNetworkState*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetEnabledInterfaces(struct soap *soap, const struct __inf__GetEnabledInterfaces *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetEnabledInterfaces(soap, &a->inf__GetEnabledInterfaces); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetEnabledInterfaces(struct soap *soap, struct __inf__GetEnabledInterfaces *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetEnabledInterfaces = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetEnabledInterfaces(struct soap *soap, const struct __inf__GetEnabledInterfaces *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetEnabledInterfaces(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetEnabledInterfaces(struct soap *soap, const char *tag, int id, const struct __inf__GetEnabledInterfaces *a, const char *type) +{ + soap_out_PointerTo_inf__GetEnabledInterfaces(soap, "inf:GetEnabledInterfaces", -1, &a->inf__GetEnabledInterfaces, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetEnabledInterfaces * SOAP_FMAC4 soap_get___inf__GetEnabledInterfaces(struct soap *soap, struct __inf__GetEnabledInterfaces *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetEnabledInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetEnabledInterfaces * SOAP_FMAC4 soap_in___inf__GetEnabledInterfaces(struct soap *soap, const char *tag, struct __inf__GetEnabledInterfaces *a, const char *type) +{ + short soap_flag_inf__GetEnabledInterfaces = 1; + a = (struct __inf__GetEnabledInterfaces *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetEnabledInterfaces, sizeof(struct __inf__GetEnabledInterfaces), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetEnabledInterfaces(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetEnabledInterfaces && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetEnabledInterfaces(soap, "inf:GetEnabledInterfaces", &a->inf__GetEnabledInterfaces, "")) + { soap_flag_inf__GetEnabledInterfaces--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetEnabledInterfaces * SOAP_FMAC6 soap_new___inf__GetEnabledInterfaces(struct soap *soap, int n) +{ return soap_instantiate___inf__GetEnabledInterfaces(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetEnabledInterfaces(struct soap *soap, struct __inf__GetEnabledInterfaces *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetEnabledInterfaces * SOAP_FMAC4 soap_instantiate___inf__GetEnabledInterfaces(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetEnabledInterfaces(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetEnabledInterfaces, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetEnabledInterfaces; + if (size) + *size = sizeof(struct __inf__GetEnabledInterfaces); + } + else + { cp->ptr = (void*)new struct __inf__GetEnabledInterfaces[n]; + if (size) + *size = n * sizeof(struct __inf__GetEnabledInterfaces); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetEnabledInterfaces*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetEnabledInterfaces(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetEnabledInterfaces %p -> %p\n", q, p)); + *(struct __inf__GetEnabledInterfaces*)p = *(struct __inf__GetEnabledInterfaces*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetPasswordModel(struct soap *soap, const struct __inf__GetPasswordModel *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetPasswordModel(soap, &a->inf__GetPasswordModel); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetPasswordModel(struct soap *soap, struct __inf__GetPasswordModel *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetPasswordModel = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetPasswordModel(struct soap *soap, const struct __inf__GetPasswordModel *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetPasswordModel(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetPasswordModel(struct soap *soap, const char *tag, int id, const struct __inf__GetPasswordModel *a, const char *type) +{ + soap_out_PointerTo_inf__GetPasswordModel(soap, "inf:GetPasswordModel", -1, &a->inf__GetPasswordModel, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetPasswordModel * SOAP_FMAC4 soap_get___inf__GetPasswordModel(struct soap *soap, struct __inf__GetPasswordModel *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetPasswordModel(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetPasswordModel * SOAP_FMAC4 soap_in___inf__GetPasswordModel(struct soap *soap, const char *tag, struct __inf__GetPasswordModel *a, const char *type) +{ + short soap_flag_inf__GetPasswordModel = 1; + a = (struct __inf__GetPasswordModel *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetPasswordModel, sizeof(struct __inf__GetPasswordModel), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetPasswordModel(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetPasswordModel && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetPasswordModel(soap, "inf:GetPasswordModel", &a->inf__GetPasswordModel, "")) + { soap_flag_inf__GetPasswordModel--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetPasswordModel * SOAP_FMAC6 soap_new___inf__GetPasswordModel(struct soap *soap, int n) +{ return soap_instantiate___inf__GetPasswordModel(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetPasswordModel(struct soap *soap, struct __inf__GetPasswordModel *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetPasswordModel * SOAP_FMAC4 soap_instantiate___inf__GetPasswordModel(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetPasswordModel(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetPasswordModel, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetPasswordModel; + if (size) + *size = sizeof(struct __inf__GetPasswordModel); + } + else + { cp->ptr = (void*)new struct __inf__GetPasswordModel[n]; + if (size) + *size = n * sizeof(struct __inf__GetPasswordModel); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetPasswordModel*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetPasswordModel(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetPasswordModel %p -> %p\n", q, p)); + *(struct __inf__GetPasswordModel*)p = *(struct __inf__GetPasswordModel*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetAdminNetAclEntryStatus(struct soap *soap, const struct __inf__GetAdminNetAclEntryStatus *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetAdminNetAclEntryStatus(soap, &a->inf__GetAdminNetAclEntryStatus); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetAdminNetAclEntryStatus(struct soap *soap, struct __inf__GetAdminNetAclEntryStatus *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetAdminNetAclEntryStatus = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetAdminNetAclEntryStatus(struct soap *soap, const struct __inf__GetAdminNetAclEntryStatus *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetAdminNetAclEntryStatus(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetAdminNetAclEntryStatus(struct soap *soap, const char *tag, int id, const struct __inf__GetAdminNetAclEntryStatus *a, const char *type) +{ + soap_out_PointerTo_inf__GetAdminNetAclEntryStatus(soap, "inf:GetAdminNetAclEntryStatus", -1, &a->inf__GetAdminNetAclEntryStatus, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_get___inf__GetAdminNetAclEntryStatus(struct soap *soap, struct __inf__GetAdminNetAclEntryStatus *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetAdminNetAclEntryStatus(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_in___inf__GetAdminNetAclEntryStatus(struct soap *soap, const char *tag, struct __inf__GetAdminNetAclEntryStatus *a, const char *type) +{ + short soap_flag_inf__GetAdminNetAclEntryStatus = 1; + a = (struct __inf__GetAdminNetAclEntryStatus *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetAdminNetAclEntryStatus, sizeof(struct __inf__GetAdminNetAclEntryStatus), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetAdminNetAclEntryStatus(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetAdminNetAclEntryStatus && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetAdminNetAclEntryStatus(soap, "inf:GetAdminNetAclEntryStatus", &a->inf__GetAdminNetAclEntryStatus, "")) + { soap_flag_inf__GetAdminNetAclEntryStatus--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetAdminNetAclEntryStatus * SOAP_FMAC6 soap_new___inf__GetAdminNetAclEntryStatus(struct soap *soap, int n) +{ return soap_instantiate___inf__GetAdminNetAclEntryStatus(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetAdminNetAclEntryStatus(struct soap *soap, struct __inf__GetAdminNetAclEntryStatus *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetAdminNetAclEntryStatus * SOAP_FMAC4 soap_instantiate___inf__GetAdminNetAclEntryStatus(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetAdminNetAclEntryStatus(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetAdminNetAclEntryStatus, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetAdminNetAclEntryStatus; + if (size) + *size = sizeof(struct __inf__GetAdminNetAclEntryStatus); + } + else + { cp->ptr = (void*)new struct __inf__GetAdminNetAclEntryStatus[n]; + if (size) + *size = n * sizeof(struct __inf__GetAdminNetAclEntryStatus); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetAdminNetAclEntryStatus*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetAdminNetAclEntryStatus(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetAdminNetAclEntryStatus %p -> %p\n", q, p)); + *(struct __inf__GetAdminNetAclEntryStatus*)p = *(struct __inf__GetAdminNetAclEntryStatus*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetAdminAclEntryStatus(struct soap *soap, const struct __inf__GetAdminAclEntryStatus *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetAdminAclEntryStatus(soap, &a->inf__GetAdminAclEntryStatus); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetAdminAclEntryStatus(struct soap *soap, struct __inf__GetAdminAclEntryStatus *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetAdminAclEntryStatus = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetAdminAclEntryStatus(struct soap *soap, const struct __inf__GetAdminAclEntryStatus *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetAdminAclEntryStatus(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetAdminAclEntryStatus(struct soap *soap, const char *tag, int id, const struct __inf__GetAdminAclEntryStatus *a, const char *type) +{ + soap_out_PointerTo_inf__GetAdminAclEntryStatus(soap, "inf:GetAdminAclEntryStatus", -1, &a->inf__GetAdminAclEntryStatus, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_get___inf__GetAdminAclEntryStatus(struct soap *soap, struct __inf__GetAdminAclEntryStatus *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetAdminAclEntryStatus(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_in___inf__GetAdminAclEntryStatus(struct soap *soap, const char *tag, struct __inf__GetAdminAclEntryStatus *a, const char *type) +{ + short soap_flag_inf__GetAdminAclEntryStatus = 1; + a = (struct __inf__GetAdminAclEntryStatus *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetAdminAclEntryStatus, sizeof(struct __inf__GetAdminAclEntryStatus), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetAdminAclEntryStatus(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetAdminAclEntryStatus && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetAdminAclEntryStatus(soap, "inf:GetAdminAclEntryStatus", &a->inf__GetAdminAclEntryStatus, "")) + { soap_flag_inf__GetAdminAclEntryStatus--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetAdminAclEntryStatus * SOAP_FMAC6 soap_new___inf__GetAdminAclEntryStatus(struct soap *soap, int n) +{ return soap_instantiate___inf__GetAdminAclEntryStatus(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetAdminAclEntryStatus(struct soap *soap, struct __inf__GetAdminAclEntryStatus *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetAdminAclEntryStatus * SOAP_FMAC4 soap_instantiate___inf__GetAdminAclEntryStatus(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetAdminAclEntryStatus(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetAdminAclEntryStatus, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetAdminAclEntryStatus; + if (size) + *size = sizeof(struct __inf__GetAdminAclEntryStatus); + } + else + { cp->ptr = (void*)new struct __inf__GetAdminAclEntryStatus[n]; + if (size) + *size = n * sizeof(struct __inf__GetAdminAclEntryStatus); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetAdminAclEntryStatus*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetAdminAclEntryStatus(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetAdminAclEntryStatus %p -> %p\n", q, p)); + *(struct __inf__GetAdminAclEntryStatus*)p = *(struct __inf__GetAdminAclEntryStatus*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetConfigServerInfo(struct soap *soap, const struct __inf__GetConfigServerInfo *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetConfigServerInfo(soap, &a->inf__GetConfigServerInfo); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetConfigServerInfo(struct soap *soap, struct __inf__GetConfigServerInfo *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetConfigServerInfo = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetConfigServerInfo(struct soap *soap, const struct __inf__GetConfigServerInfo *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetConfigServerInfo(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetConfigServerInfo(struct soap *soap, const char *tag, int id, const struct __inf__GetConfigServerInfo *a, const char *type) +{ + soap_out_PointerTo_inf__GetConfigServerInfo(soap, "inf:GetConfigServerInfo", -1, &a->inf__GetConfigServerInfo, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetConfigServerInfo * SOAP_FMAC4 soap_get___inf__GetConfigServerInfo(struct soap *soap, struct __inf__GetConfigServerInfo *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetConfigServerInfo(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetConfigServerInfo * SOAP_FMAC4 soap_in___inf__GetConfigServerInfo(struct soap *soap, const char *tag, struct __inf__GetConfigServerInfo *a, const char *type) +{ + short soap_flag_inf__GetConfigServerInfo = 1; + a = (struct __inf__GetConfigServerInfo *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetConfigServerInfo, sizeof(struct __inf__GetConfigServerInfo), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetConfigServerInfo(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetConfigServerInfo && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetConfigServerInfo(soap, "inf:GetConfigServerInfo", &a->inf__GetConfigServerInfo, "")) + { soap_flag_inf__GetConfigServerInfo--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetConfigServerInfo * SOAP_FMAC6 soap_new___inf__GetConfigServerInfo(struct soap *soap, int n) +{ return soap_instantiate___inf__GetConfigServerInfo(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetConfigServerInfo(struct soap *soap, struct __inf__GetConfigServerInfo *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetConfigServerInfo * SOAP_FMAC4 soap_instantiate___inf__GetConfigServerInfo(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetConfigServerInfo(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetConfigServerInfo, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetConfigServerInfo; + if (size) + *size = sizeof(struct __inf__GetConfigServerInfo); + } + else + { cp->ptr = (void*)new struct __inf__GetConfigServerInfo[n]; + if (size) + *size = n * sizeof(struct __inf__GetConfigServerInfo); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetConfigServerInfo*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetConfigServerInfo(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetConfigServerInfo %p -> %p\n", q, p)); + *(struct __inf__GetConfigServerInfo*)p = *(struct __inf__GetConfigServerInfo*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetHostName(struct soap *soap, const struct __inf__GetHostName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetHostName(soap, &a->inf__GetHostName); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetHostName(struct soap *soap, struct __inf__GetHostName *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetHostName = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetHostName(struct soap *soap, const struct __inf__GetHostName *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetHostName(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetHostName(struct soap *soap, const char *tag, int id, const struct __inf__GetHostName *a, const char *type) +{ + soap_out_PointerTo_inf__GetHostName(soap, "inf:GetHostName", -1, &a->inf__GetHostName, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetHostName * SOAP_FMAC4 soap_get___inf__GetHostName(struct soap *soap, struct __inf__GetHostName *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetHostName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetHostName * SOAP_FMAC4 soap_in___inf__GetHostName(struct soap *soap, const char *tag, struct __inf__GetHostName *a, const char *type) +{ + short soap_flag_inf__GetHostName = 1; + a = (struct __inf__GetHostName *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetHostName, sizeof(struct __inf__GetHostName), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetHostName(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetHostName && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetHostName(soap, "inf:GetHostName", &a->inf__GetHostName, "")) + { soap_flag_inf__GetHostName--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetHostName * SOAP_FMAC6 soap_new___inf__GetHostName(struct soap *soap, int n) +{ return soap_instantiate___inf__GetHostName(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetHostName(struct soap *soap, struct __inf__GetHostName *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetHostName * SOAP_FMAC4 soap_instantiate___inf__GetHostName(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetHostName(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetHostName, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetHostName; + if (size) + *size = sizeof(struct __inf__GetHostName); + } + else + { cp->ptr = (void*)new struct __inf__GetHostName[n]; + if (size) + *size = n * sizeof(struct __inf__GetHostName); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetHostName*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetHostName(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetHostName %p -> %p\n", q, p)); + *(struct __inf__GetHostName*)p = *(struct __inf__GetHostName*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetVlanParameters(struct soap *soap, const struct __inf__GetVlanParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetVlanParameters(soap, &a->inf__GetVlanParameters); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetVlanParameters(struct soap *soap, struct __inf__GetVlanParameters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetVlanParameters = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetVlanParameters(struct soap *soap, const struct __inf__GetVlanParameters *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetVlanParameters(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetVlanParameters(struct soap *soap, const char *tag, int id, const struct __inf__GetVlanParameters *a, const char *type) +{ + soap_out_PointerTo_inf__GetVlanParameters(soap, "inf:GetVlanParameters", -1, &a->inf__GetVlanParameters, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetVlanParameters * SOAP_FMAC4 soap_get___inf__GetVlanParameters(struct soap *soap, struct __inf__GetVlanParameters *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetVlanParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetVlanParameters * SOAP_FMAC4 soap_in___inf__GetVlanParameters(struct soap *soap, const char *tag, struct __inf__GetVlanParameters *a, const char *type) +{ + short soap_flag_inf__GetVlanParameters = 1; + a = (struct __inf__GetVlanParameters *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetVlanParameters, sizeof(struct __inf__GetVlanParameters), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetVlanParameters(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetVlanParameters && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetVlanParameters(soap, "inf:GetVlanParameters", &a->inf__GetVlanParameters, "")) + { soap_flag_inf__GetVlanParameters--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetVlanParameters * SOAP_FMAC6 soap_new___inf__GetVlanParameters(struct soap *soap, int n) +{ return soap_instantiate___inf__GetVlanParameters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetVlanParameters(struct soap *soap, struct __inf__GetVlanParameters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetVlanParameters * SOAP_FMAC4 soap_instantiate___inf__GetVlanParameters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetVlanParameters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetVlanParameters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetVlanParameters; + if (size) + *size = sizeof(struct __inf__GetVlanParameters); + } + else + { cp->ptr = (void*)new struct __inf__GetVlanParameters[n]; + if (size) + *size = n * sizeof(struct __inf__GetVlanParameters); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetVlanParameters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetVlanParameters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetVlanParameters %p -> %p\n", q, p)); + *(struct __inf__GetVlanParameters*)p = *(struct __inf__GetVlanParameters*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetProvisioningState(struct soap *soap, const struct __inf__GetProvisioningState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetProvisioningState(soap, &a->inf__GetProvisioningState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetProvisioningState(struct soap *soap, struct __inf__GetProvisioningState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetProvisioningState = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetProvisioningState(struct soap *soap, const struct __inf__GetProvisioningState *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetProvisioningState(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetProvisioningState(struct soap *soap, const char *tag, int id, const struct __inf__GetProvisioningState *a, const char *type) +{ + soap_out_PointerTo_inf__GetProvisioningState(soap, "inf:GetProvisioningState", -1, &a->inf__GetProvisioningState, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetProvisioningState * SOAP_FMAC4 soap_get___inf__GetProvisioningState(struct soap *soap, struct __inf__GetProvisioningState *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetProvisioningState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetProvisioningState * SOAP_FMAC4 soap_in___inf__GetProvisioningState(struct soap *soap, const char *tag, struct __inf__GetProvisioningState *a, const char *type) +{ + short soap_flag_inf__GetProvisioningState = 1; + a = (struct __inf__GetProvisioningState *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetProvisioningState, sizeof(struct __inf__GetProvisioningState), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetProvisioningState(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetProvisioningState && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetProvisioningState(soap, "inf:GetProvisioningState", &a->inf__GetProvisioningState, "")) + { soap_flag_inf__GetProvisioningState--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetProvisioningState * SOAP_FMAC6 soap_new___inf__GetProvisioningState(struct soap *soap, int n) +{ return soap_instantiate___inf__GetProvisioningState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetProvisioningState(struct soap *soap, struct __inf__GetProvisioningState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetProvisioningState * SOAP_FMAC4 soap_instantiate___inf__GetProvisioningState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetProvisioningState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetProvisioningState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetProvisioningState; + if (size) + *size = sizeof(struct __inf__GetProvisioningState); + } + else + { cp->ptr = (void*)new struct __inf__GetProvisioningState[n]; + if (size) + *size = n * sizeof(struct __inf__GetProvisioningState); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetProvisioningState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetProvisioningState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetProvisioningState %p -> %p\n", q, p)); + *(struct __inf__GetProvisioningState*)p = *(struct __inf__GetProvisioningState*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetProvisioningMode(struct soap *soap, const struct __inf__GetProvisioningMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetProvisioningMode(soap, &a->inf__GetProvisioningMode); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetProvisioningMode(struct soap *soap, struct __inf__GetProvisioningMode *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetProvisioningMode = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetProvisioningMode(struct soap *soap, const struct __inf__GetProvisioningMode *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetProvisioningMode(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetProvisioningMode(struct soap *soap, const char *tag, int id, const struct __inf__GetProvisioningMode *a, const char *type) +{ + soap_out_PointerTo_inf__GetProvisioningMode(soap, "inf:GetProvisioningMode", -1, &a->inf__GetProvisioningMode, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetProvisioningMode * SOAP_FMAC4 soap_get___inf__GetProvisioningMode(struct soap *soap, struct __inf__GetProvisioningMode *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetProvisioningMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetProvisioningMode * SOAP_FMAC4 soap_in___inf__GetProvisioningMode(struct soap *soap, const char *tag, struct __inf__GetProvisioningMode *a, const char *type) +{ + short soap_flag_inf__GetProvisioningMode = 1; + a = (struct __inf__GetProvisioningMode *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetProvisioningMode, sizeof(struct __inf__GetProvisioningMode), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetProvisioningMode(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetProvisioningMode && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetProvisioningMode(soap, "inf:GetProvisioningMode", &a->inf__GetProvisioningMode, "")) + { soap_flag_inf__GetProvisioningMode--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetProvisioningMode * SOAP_FMAC6 soap_new___inf__GetProvisioningMode(struct soap *soap, int n) +{ return soap_instantiate___inf__GetProvisioningMode(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetProvisioningMode(struct soap *soap, struct __inf__GetProvisioningMode *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetProvisioningMode * SOAP_FMAC4 soap_instantiate___inf__GetProvisioningMode(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetProvisioningMode(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetProvisioningMode, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetProvisioningMode; + if (size) + *size = sizeof(struct __inf__GetProvisioningMode); + } + else + { cp->ptr = (void*)new struct __inf__GetProvisioningMode[n]; + if (size) + *size = n * sizeof(struct __inf__GetProvisioningMode); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetProvisioningMode*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetProvisioningMode(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetProvisioningMode %p -> %p\n", q, p)); + *(struct __inf__GetProvisioningMode*)p = *(struct __inf__GetProvisioningMode*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetCodeVersions(struct soap *soap, const struct __inf__GetCodeVersions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetCodeVersions(soap, &a->inf__GetCodeVersions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetCodeVersions(struct soap *soap, struct __inf__GetCodeVersions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetCodeVersions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetCodeVersions(struct soap *soap, const struct __inf__GetCodeVersions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetCodeVersions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetCodeVersions(struct soap *soap, const char *tag, int id, const struct __inf__GetCodeVersions *a, const char *type) +{ + soap_out_PointerTo_inf__GetCodeVersions(soap, "inf:GetCodeVersions", -1, &a->inf__GetCodeVersions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetCodeVersions * SOAP_FMAC4 soap_get___inf__GetCodeVersions(struct soap *soap, struct __inf__GetCodeVersions *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetCodeVersions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetCodeVersions * SOAP_FMAC4 soap_in___inf__GetCodeVersions(struct soap *soap, const char *tag, struct __inf__GetCodeVersions *a, const char *type) +{ + short soap_flag_inf__GetCodeVersions = 1; + a = (struct __inf__GetCodeVersions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetCodeVersions, sizeof(struct __inf__GetCodeVersions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetCodeVersions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetCodeVersions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetCodeVersions(soap, "inf:GetCodeVersions", &a->inf__GetCodeVersions, "")) + { soap_flag_inf__GetCodeVersions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetCodeVersions * SOAP_FMAC6 soap_new___inf__GetCodeVersions(struct soap *soap, int n) +{ return soap_instantiate___inf__GetCodeVersions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetCodeVersions(struct soap *soap, struct __inf__GetCodeVersions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetCodeVersions * SOAP_FMAC4 soap_instantiate___inf__GetCodeVersions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetCodeVersions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetCodeVersions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetCodeVersions; + if (size) + *size = sizeof(struct __inf__GetCodeVersions); + } + else + { cp->ptr = (void*)new struct __inf__GetCodeVersions[n]; + if (size) + *size = n * sizeof(struct __inf__GetCodeVersions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetCodeVersions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetCodeVersions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetCodeVersions %p -> %p\n", q, p)); + *(struct __inf__GetCodeVersions*)p = *(struct __inf__GetCodeVersions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___inf__GetCoreVersion(struct soap *soap, const struct __inf__GetCoreVersion *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_inf__GetCoreVersion(soap, &a->inf__GetCoreVersion); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___inf__GetCoreVersion(struct soap *soap, struct __inf__GetCoreVersion *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->inf__GetCoreVersion = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___inf__GetCoreVersion(struct soap *soap, const struct __inf__GetCoreVersion *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___inf__GetCoreVersion(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___inf__GetCoreVersion(struct soap *soap, const char *tag, int id, const struct __inf__GetCoreVersion *a, const char *type) +{ + soap_out_PointerTo_inf__GetCoreVersion(soap, "inf:GetCoreVersion", -1, &a->inf__GetCoreVersion, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __inf__GetCoreVersion * SOAP_FMAC4 soap_get___inf__GetCoreVersion(struct soap *soap, struct __inf__GetCoreVersion *p, const char *tag, const char *type) +{ + if ((p = soap_in___inf__GetCoreVersion(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __inf__GetCoreVersion * SOAP_FMAC4 soap_in___inf__GetCoreVersion(struct soap *soap, const char *tag, struct __inf__GetCoreVersion *a, const char *type) +{ + short soap_flag_inf__GetCoreVersion = 1; + a = (struct __inf__GetCoreVersion *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___inf__GetCoreVersion, sizeof(struct __inf__GetCoreVersion), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___inf__GetCoreVersion(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_inf__GetCoreVersion && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_inf__GetCoreVersion(soap, "inf:GetCoreVersion", &a->inf__GetCoreVersion, "")) + { soap_flag_inf__GetCoreVersion--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __inf__GetCoreVersion * SOAP_FMAC6 soap_new___inf__GetCoreVersion(struct soap *soap, int n) +{ return soap_instantiate___inf__GetCoreVersion(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___inf__GetCoreVersion(struct soap *soap, struct __inf__GetCoreVersion *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __inf__GetCoreVersion * SOAP_FMAC4 soap_instantiate___inf__GetCoreVersion(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___inf__GetCoreVersion(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___inf__GetCoreVersion, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __inf__GetCoreVersion; + if (size) + *size = sizeof(struct __inf__GetCoreVersion); + } + else + { cp->ptr = (void*)new struct __inf__GetCoreVersion[n]; + if (size) + *size = n * sizeof(struct __inf__GetCoreVersion); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __inf__GetCoreVersion*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___inf__GetCoreVersion(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __inf__GetCoreVersion %p -> %p\n", q, p)); + *(struct __inf__GetCoreVersion*)p = *(struct __inf__GetCoreVersion*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___idr__GetIderSessionLog(struct soap *soap, const struct __idr__GetIderSessionLog *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_idr__GetIderSessionLog(soap, &a->idr__GetIderSessionLog); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___idr__GetIderSessionLog(struct soap *soap, struct __idr__GetIderSessionLog *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->idr__GetIderSessionLog = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___idr__GetIderSessionLog(struct soap *soap, const struct __idr__GetIderSessionLog *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___idr__GetIderSessionLog(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___idr__GetIderSessionLog(struct soap *soap, const char *tag, int id, const struct __idr__GetIderSessionLog *a, const char *type) +{ + soap_out_PointerTo_idr__GetIderSessionLog(soap, "idr:GetIderSessionLog", -1, &a->idr__GetIderSessionLog, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __idr__GetIderSessionLog * SOAP_FMAC4 soap_get___idr__GetIderSessionLog(struct soap *soap, struct __idr__GetIderSessionLog *p, const char *tag, const char *type) +{ + if ((p = soap_in___idr__GetIderSessionLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __idr__GetIderSessionLog * SOAP_FMAC4 soap_in___idr__GetIderSessionLog(struct soap *soap, const char *tag, struct __idr__GetIderSessionLog *a, const char *type) +{ + short soap_flag_idr__GetIderSessionLog = 1; + a = (struct __idr__GetIderSessionLog *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___idr__GetIderSessionLog, sizeof(struct __idr__GetIderSessionLog), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___idr__GetIderSessionLog(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_idr__GetIderSessionLog && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_idr__GetIderSessionLog(soap, "idr:GetIderSessionLog", &a->idr__GetIderSessionLog, "")) + { soap_flag_idr__GetIderSessionLog--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __idr__GetIderSessionLog * SOAP_FMAC6 soap_new___idr__GetIderSessionLog(struct soap *soap, int n) +{ return soap_instantiate___idr__GetIderSessionLog(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___idr__GetIderSessionLog(struct soap *soap, struct __idr__GetIderSessionLog *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __idr__GetIderSessionLog * SOAP_FMAC4 soap_instantiate___idr__GetIderSessionLog(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___idr__GetIderSessionLog(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___idr__GetIderSessionLog, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __idr__GetIderSessionLog; + if (size) + *size = sizeof(struct __idr__GetIderSessionLog); + } + else + { cp->ptr = (void*)new struct __idr__GetIderSessionLog[n]; + if (size) + *size = n * sizeof(struct __idr__GetIderSessionLog); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __idr__GetIderSessionLog*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___idr__GetIderSessionLog(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __idr__GetIderSessionLog %p -> %p\n", q, p)); + *(struct __idr__GetIderSessionLog*)p = *(struct __idr__GetIderSessionLog*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___idr__GetRedirectionListenerState(struct soap *soap, const struct __idr__GetRedirectionListenerState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_idr__GetRedirectionListenerState(soap, &a->idr__GetRedirectionListenerState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___idr__GetRedirectionListenerState(struct soap *soap, struct __idr__GetRedirectionListenerState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->idr__GetRedirectionListenerState = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___idr__GetRedirectionListenerState(struct soap *soap, const struct __idr__GetRedirectionListenerState *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___idr__GetRedirectionListenerState(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___idr__GetRedirectionListenerState(struct soap *soap, const char *tag, int id, const struct __idr__GetRedirectionListenerState *a, const char *type) +{ + soap_out_PointerTo_idr__GetRedirectionListenerState(soap, "idr:GetRedirectionListenerState", -1, &a->idr__GetRedirectionListenerState, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __idr__GetRedirectionListenerState * SOAP_FMAC4 soap_get___idr__GetRedirectionListenerState(struct soap *soap, struct __idr__GetRedirectionListenerState *p, const char *tag, const char *type) +{ + if ((p = soap_in___idr__GetRedirectionListenerState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __idr__GetRedirectionListenerState * SOAP_FMAC4 soap_in___idr__GetRedirectionListenerState(struct soap *soap, const char *tag, struct __idr__GetRedirectionListenerState *a, const char *type) +{ + short soap_flag_idr__GetRedirectionListenerState = 1; + a = (struct __idr__GetRedirectionListenerState *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___idr__GetRedirectionListenerState, sizeof(struct __idr__GetRedirectionListenerState), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___idr__GetRedirectionListenerState(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_idr__GetRedirectionListenerState && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_idr__GetRedirectionListenerState(soap, "idr:GetRedirectionListenerState", &a->idr__GetRedirectionListenerState, "")) + { soap_flag_idr__GetRedirectionListenerState--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __idr__GetRedirectionListenerState * SOAP_FMAC6 soap_new___idr__GetRedirectionListenerState(struct soap *soap, int n) +{ return soap_instantiate___idr__GetRedirectionListenerState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___idr__GetRedirectionListenerState(struct soap *soap, struct __idr__GetRedirectionListenerState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __idr__GetRedirectionListenerState * SOAP_FMAC4 soap_instantiate___idr__GetRedirectionListenerState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___idr__GetRedirectionListenerState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___idr__GetRedirectionListenerState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __idr__GetRedirectionListenerState; + if (size) + *size = sizeof(struct __idr__GetRedirectionListenerState); + } + else + { cp->ptr = (void*)new struct __idr__GetRedirectionListenerState[n]; + if (size) + *size = n * sizeof(struct __idr__GetRedirectionListenerState); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __idr__GetRedirectionListenerState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___idr__GetRedirectionListenerState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __idr__GetRedirectionListenerState %p -> %p\n", q, p)); + *(struct __idr__GetRedirectionListenerState*)p = *(struct __idr__GetRedirectionListenerState*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___idr__SetRedirectionListenerState(struct soap *soap, const struct __idr__SetRedirectionListenerState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_idr__SetRedirectionListenerState(soap, &a->idr__SetRedirectionListenerState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___idr__SetRedirectionListenerState(struct soap *soap, struct __idr__SetRedirectionListenerState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->idr__SetRedirectionListenerState = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___idr__SetRedirectionListenerState(struct soap *soap, const struct __idr__SetRedirectionListenerState *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___idr__SetRedirectionListenerState(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___idr__SetRedirectionListenerState(struct soap *soap, const char *tag, int id, const struct __idr__SetRedirectionListenerState *a, const char *type) +{ + soap_out_PointerTo_idr__SetRedirectionListenerState(soap, "idr:SetRedirectionListenerState", -1, &a->idr__SetRedirectionListenerState, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __idr__SetRedirectionListenerState * SOAP_FMAC4 soap_get___idr__SetRedirectionListenerState(struct soap *soap, struct __idr__SetRedirectionListenerState *p, const char *tag, const char *type) +{ + if ((p = soap_in___idr__SetRedirectionListenerState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __idr__SetRedirectionListenerState * SOAP_FMAC4 soap_in___idr__SetRedirectionListenerState(struct soap *soap, const char *tag, struct __idr__SetRedirectionListenerState *a, const char *type) +{ + short soap_flag_idr__SetRedirectionListenerState = 1; + a = (struct __idr__SetRedirectionListenerState *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___idr__SetRedirectionListenerState, sizeof(struct __idr__SetRedirectionListenerState), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___idr__SetRedirectionListenerState(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_idr__SetRedirectionListenerState && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_idr__SetRedirectionListenerState(soap, "idr:SetRedirectionListenerState", &a->idr__SetRedirectionListenerState, "")) + { soap_flag_idr__SetRedirectionListenerState--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __idr__SetRedirectionListenerState * SOAP_FMAC6 soap_new___idr__SetRedirectionListenerState(struct soap *soap, int n) +{ return soap_instantiate___idr__SetRedirectionListenerState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___idr__SetRedirectionListenerState(struct soap *soap, struct __idr__SetRedirectionListenerState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __idr__SetRedirectionListenerState * SOAP_FMAC4 soap_instantiate___idr__SetRedirectionListenerState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___idr__SetRedirectionListenerState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___idr__SetRedirectionListenerState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __idr__SetRedirectionListenerState; + if (size) + *size = sizeof(struct __idr__SetRedirectionListenerState); + } + else + { cp->ptr = (void*)new struct __idr__SetRedirectionListenerState[n]; + if (size) + *size = n * sizeof(struct __idr__SetRedirectionListenerState); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __idr__SetRedirectionListenerState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___idr__SetRedirectionListenerState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __idr__SetRedirectionListenerState %p -> %p\n", q, p)); + *(struct __idr__SetRedirectionListenerState*)p = *(struct __idr__SetRedirectionListenerState*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___hwa__GetAssetData(struct soap *soap, const struct __hwa__GetAssetData *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_hwa__GetAssetData(soap, &a->hwa__GetAssetData); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___hwa__GetAssetData(struct soap *soap, struct __hwa__GetAssetData *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->hwa__GetAssetData = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___hwa__GetAssetData(struct soap *soap, const struct __hwa__GetAssetData *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___hwa__GetAssetData(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___hwa__GetAssetData(struct soap *soap, const char *tag, int id, const struct __hwa__GetAssetData *a, const char *type) +{ + soap_out_PointerTo_hwa__GetAssetData(soap, "hwa:GetAssetData", -1, &a->hwa__GetAssetData, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __hwa__GetAssetData * SOAP_FMAC4 soap_get___hwa__GetAssetData(struct soap *soap, struct __hwa__GetAssetData *p, const char *tag, const char *type) +{ + if ((p = soap_in___hwa__GetAssetData(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __hwa__GetAssetData * SOAP_FMAC4 soap_in___hwa__GetAssetData(struct soap *soap, const char *tag, struct __hwa__GetAssetData *a, const char *type) +{ + short soap_flag_hwa__GetAssetData = 1; + a = (struct __hwa__GetAssetData *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___hwa__GetAssetData, sizeof(struct __hwa__GetAssetData), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___hwa__GetAssetData(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_hwa__GetAssetData && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_hwa__GetAssetData(soap, "hwa:GetAssetData", &a->hwa__GetAssetData, "")) + { soap_flag_hwa__GetAssetData--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __hwa__GetAssetData * SOAP_FMAC6 soap_new___hwa__GetAssetData(struct soap *soap, int n) +{ return soap_instantiate___hwa__GetAssetData(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___hwa__GetAssetData(struct soap *soap, struct __hwa__GetAssetData *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __hwa__GetAssetData * SOAP_FMAC4 soap_instantiate___hwa__GetAssetData(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___hwa__GetAssetData(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___hwa__GetAssetData, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __hwa__GetAssetData; + if (size) + *size = sizeof(struct __hwa__GetAssetData); + } + else + { cp->ptr = (void*)new struct __hwa__GetAssetData[n]; + if (size) + *size = n * sizeof(struct __hwa__GetAssetData); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __hwa__GetAssetData*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___hwa__GetAssetData(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __hwa__GetAssetData %p -> %p\n", q, p)); + *(struct __hwa__GetAssetData*)p = *(struct __hwa__GetAssetData*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___hwa__EnumerateAssetTypes(struct soap *soap, const struct __hwa__EnumerateAssetTypes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_hwa__EnumerateAssetTypes(soap, &a->hwa__EnumerateAssetTypes); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___hwa__EnumerateAssetTypes(struct soap *soap, struct __hwa__EnumerateAssetTypes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->hwa__EnumerateAssetTypes = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___hwa__EnumerateAssetTypes(struct soap *soap, const struct __hwa__EnumerateAssetTypes *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___hwa__EnumerateAssetTypes(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___hwa__EnumerateAssetTypes(struct soap *soap, const char *tag, int id, const struct __hwa__EnumerateAssetTypes *a, const char *type) +{ + soap_out_PointerTo_hwa__EnumerateAssetTypes(soap, "hwa:EnumerateAssetTypes", -1, &a->hwa__EnumerateAssetTypes, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_get___hwa__EnumerateAssetTypes(struct soap *soap, struct __hwa__EnumerateAssetTypes *p, const char *tag, const char *type) +{ + if ((p = soap_in___hwa__EnumerateAssetTypes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_in___hwa__EnumerateAssetTypes(struct soap *soap, const char *tag, struct __hwa__EnumerateAssetTypes *a, const char *type) +{ + short soap_flag_hwa__EnumerateAssetTypes = 1; + a = (struct __hwa__EnumerateAssetTypes *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___hwa__EnumerateAssetTypes, sizeof(struct __hwa__EnumerateAssetTypes), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___hwa__EnumerateAssetTypes(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_hwa__EnumerateAssetTypes && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_hwa__EnumerateAssetTypes(soap, "hwa:EnumerateAssetTypes", &a->hwa__EnumerateAssetTypes, "")) + { soap_flag_hwa__EnumerateAssetTypes--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __hwa__EnumerateAssetTypes * SOAP_FMAC6 soap_new___hwa__EnumerateAssetTypes(struct soap *soap, int n) +{ return soap_instantiate___hwa__EnumerateAssetTypes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___hwa__EnumerateAssetTypes(struct soap *soap, struct __hwa__EnumerateAssetTypes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __hwa__EnumerateAssetTypes * SOAP_FMAC4 soap_instantiate___hwa__EnumerateAssetTypes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___hwa__EnumerateAssetTypes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___hwa__EnumerateAssetTypes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __hwa__EnumerateAssetTypes; + if (size) + *size = sizeof(struct __hwa__EnumerateAssetTypes); + } + else + { cp->ptr = (void*)new struct __hwa__EnumerateAssetTypes[n]; + if (size) + *size = n * sizeof(struct __hwa__EnumerateAssetTypes); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __hwa__EnumerateAssetTypes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___hwa__EnumerateAssetTypes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __hwa__EnumerateAssetTypes %p -> %p\n", q, p)); + *(struct __hwa__EnumerateAssetTypes*)p = *(struct __hwa__EnumerateAssetTypes*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetGeneralAlertSubscription(struct soap *soap, const struct __emi__GetGeneralAlertSubscription *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__GetGeneralAlertSubscription(soap, &a->emi__GetGeneralAlertSubscription); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetGeneralAlertSubscription(struct soap *soap, struct __emi__GetGeneralAlertSubscription *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__GetGeneralAlertSubscription = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetGeneralAlertSubscription(struct soap *soap, const struct __emi__GetGeneralAlertSubscription *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__GetGeneralAlertSubscription(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetGeneralAlertSubscription(struct soap *soap, const char *tag, int id, const struct __emi__GetGeneralAlertSubscription *a, const char *type) +{ + soap_out_PointerTo_emi__GetGeneralAlertSubscription(soap, "emi:GetGeneralAlertSubscription", -1, &a->emi__GetGeneralAlertSubscription, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_get___emi__GetGeneralAlertSubscription(struct soap *soap, struct __emi__GetGeneralAlertSubscription *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__GetGeneralAlertSubscription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_in___emi__GetGeneralAlertSubscription(struct soap *soap, const char *tag, struct __emi__GetGeneralAlertSubscription *a, const char *type) +{ + short soap_flag_emi__GetGeneralAlertSubscription = 1; + a = (struct __emi__GetGeneralAlertSubscription *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__GetGeneralAlertSubscription, sizeof(struct __emi__GetGeneralAlertSubscription), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__GetGeneralAlertSubscription(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__GetGeneralAlertSubscription && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__GetGeneralAlertSubscription(soap, "emi:GetGeneralAlertSubscription", &a->emi__GetGeneralAlertSubscription, "")) + { soap_flag_emi__GetGeneralAlertSubscription--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__GetGeneralAlertSubscription * SOAP_FMAC6 soap_new___emi__GetGeneralAlertSubscription(struct soap *soap, int n) +{ return soap_instantiate___emi__GetGeneralAlertSubscription(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetGeneralAlertSubscription(struct soap *soap, struct __emi__GetGeneralAlertSubscription *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__GetGeneralAlertSubscription * SOAP_FMAC4 soap_instantiate___emi__GetGeneralAlertSubscription(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__GetGeneralAlertSubscription(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__GetGeneralAlertSubscription, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__GetGeneralAlertSubscription; + if (size) + *size = sizeof(struct __emi__GetGeneralAlertSubscription); + } + else + { cp->ptr = (void*)new struct __emi__GetGeneralAlertSubscription[n]; + if (size) + *size = n * sizeof(struct __emi__GetGeneralAlertSubscription); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__GetGeneralAlertSubscription*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetGeneralAlertSubscription(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__GetGeneralAlertSubscription %p -> %p\n", q, p)); + *(struct __emi__GetGeneralAlertSubscription*)p = *(struct __emi__GetGeneralAlertSubscription*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const struct __emi__EnumerateGeneralAlertSubscriptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__EnumerateGeneralAlertSubscriptions(soap, &a->emi__EnumerateGeneralAlertSubscriptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, struct __emi__EnumerateGeneralAlertSubscriptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__EnumerateGeneralAlertSubscriptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const struct __emi__EnumerateGeneralAlertSubscriptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__EnumerateGeneralAlertSubscriptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const char *tag, int id, const struct __emi__EnumerateGeneralAlertSubscriptions *a, const char *type) +{ + soap_out_PointerTo_emi__EnumerateGeneralAlertSubscriptions(soap, "emi:EnumerateGeneralAlertSubscriptions", -1, &a->emi__EnumerateGeneralAlertSubscriptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_get___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, struct __emi__EnumerateGeneralAlertSubscriptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__EnumerateGeneralAlertSubscriptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_in___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const char *tag, struct __emi__EnumerateGeneralAlertSubscriptions *a, const char *type) +{ + short soap_flag_emi__EnumerateGeneralAlertSubscriptions = 1; + a = (struct __emi__EnumerateGeneralAlertSubscriptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__EnumerateGeneralAlertSubscriptions, sizeof(struct __emi__EnumerateGeneralAlertSubscriptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__EnumerateGeneralAlertSubscriptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__EnumerateGeneralAlertSubscriptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__EnumerateGeneralAlertSubscriptions(soap, "emi:EnumerateGeneralAlertSubscriptions", &a->emi__EnumerateGeneralAlertSubscriptions, "")) + { soap_flag_emi__EnumerateGeneralAlertSubscriptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC6 soap_new___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, int n) +{ return soap_instantiate___emi__EnumerateGeneralAlertSubscriptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, struct __emi__EnumerateGeneralAlertSubscriptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__EnumerateGeneralAlertSubscriptions * SOAP_FMAC4 soap_instantiate___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__EnumerateGeneralAlertSubscriptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__EnumerateGeneralAlertSubscriptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__EnumerateGeneralAlertSubscriptions; + if (size) + *size = sizeof(struct __emi__EnumerateGeneralAlertSubscriptions); + } + else + { cp->ptr = (void*)new struct __emi__EnumerateGeneralAlertSubscriptions[n]; + if (size) + *size = n * sizeof(struct __emi__EnumerateGeneralAlertSubscriptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__EnumerateGeneralAlertSubscriptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__EnumerateGeneralAlertSubscriptions %p -> %p\n", q, p)); + *(struct __emi__EnumerateGeneralAlertSubscriptions*)p = *(struct __emi__EnumerateGeneralAlertSubscriptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__SubscribeForGeneralAlert(struct soap *soap, const struct __emi__SubscribeForGeneralAlert *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__SubscribeForGeneralAlert(soap, &a->emi__SubscribeForGeneralAlert); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__SubscribeForGeneralAlert(struct soap *soap, struct __emi__SubscribeForGeneralAlert *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__SubscribeForGeneralAlert = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__SubscribeForGeneralAlert(struct soap *soap, const struct __emi__SubscribeForGeneralAlert *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__SubscribeForGeneralAlert(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__SubscribeForGeneralAlert(struct soap *soap, const char *tag, int id, const struct __emi__SubscribeForGeneralAlert *a, const char *type) +{ + soap_out_PointerTo_emi__SubscribeForGeneralAlert(soap, "emi:SubscribeForGeneralAlert", -1, &a->emi__SubscribeForGeneralAlert, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_get___emi__SubscribeForGeneralAlert(struct soap *soap, struct __emi__SubscribeForGeneralAlert *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__SubscribeForGeneralAlert(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_in___emi__SubscribeForGeneralAlert(struct soap *soap, const char *tag, struct __emi__SubscribeForGeneralAlert *a, const char *type) +{ + short soap_flag_emi__SubscribeForGeneralAlert = 1; + a = (struct __emi__SubscribeForGeneralAlert *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__SubscribeForGeneralAlert, sizeof(struct __emi__SubscribeForGeneralAlert), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__SubscribeForGeneralAlert(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__SubscribeForGeneralAlert && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__SubscribeForGeneralAlert(soap, "emi:SubscribeForGeneralAlert", &a->emi__SubscribeForGeneralAlert, "")) + { soap_flag_emi__SubscribeForGeneralAlert--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__SubscribeForGeneralAlert * SOAP_FMAC6 soap_new___emi__SubscribeForGeneralAlert(struct soap *soap, int n) +{ return soap_instantiate___emi__SubscribeForGeneralAlert(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__SubscribeForGeneralAlert(struct soap *soap, struct __emi__SubscribeForGeneralAlert *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__SubscribeForGeneralAlert * SOAP_FMAC4 soap_instantiate___emi__SubscribeForGeneralAlert(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__SubscribeForGeneralAlert(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__SubscribeForGeneralAlert, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__SubscribeForGeneralAlert; + if (size) + *size = sizeof(struct __emi__SubscribeForGeneralAlert); + } + else + { cp->ptr = (void*)new struct __emi__SubscribeForGeneralAlert[n]; + if (size) + *size = n * sizeof(struct __emi__SubscribeForGeneralAlert); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__SubscribeForGeneralAlert*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__SubscribeForGeneralAlert(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__SubscribeForGeneralAlert %p -> %p\n", q, p)); + *(struct __emi__SubscribeForGeneralAlert*)p = *(struct __emi__SubscribeForGeneralAlert*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetSensorAttributes(struct soap *soap, const struct __emi__GetSensorAttributes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__GetSensorAttributes(soap, &a->emi__GetSensorAttributes); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetSensorAttributes(struct soap *soap, struct __emi__GetSensorAttributes *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__GetSensorAttributes = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetSensorAttributes(struct soap *soap, const struct __emi__GetSensorAttributes *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__GetSensorAttributes(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetSensorAttributes(struct soap *soap, const char *tag, int id, const struct __emi__GetSensorAttributes *a, const char *type) +{ + soap_out_PointerTo_emi__GetSensorAttributes(soap, "emi:GetSensorAttributes", -1, &a->emi__GetSensorAttributes, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__GetSensorAttributes * SOAP_FMAC4 soap_get___emi__GetSensorAttributes(struct soap *soap, struct __emi__GetSensorAttributes *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__GetSensorAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__GetSensorAttributes * SOAP_FMAC4 soap_in___emi__GetSensorAttributes(struct soap *soap, const char *tag, struct __emi__GetSensorAttributes *a, const char *type) +{ + short soap_flag_emi__GetSensorAttributes = 1; + a = (struct __emi__GetSensorAttributes *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__GetSensorAttributes, sizeof(struct __emi__GetSensorAttributes), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__GetSensorAttributes(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__GetSensorAttributes && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__GetSensorAttributes(soap, "emi:GetSensorAttributes", &a->emi__GetSensorAttributes, "")) + { soap_flag_emi__GetSensorAttributes--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__GetSensorAttributes * SOAP_FMAC6 soap_new___emi__GetSensorAttributes(struct soap *soap, int n) +{ return soap_instantiate___emi__GetSensorAttributes(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetSensorAttributes(struct soap *soap, struct __emi__GetSensorAttributes *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__GetSensorAttributes * SOAP_FMAC4 soap_instantiate___emi__GetSensorAttributes(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__GetSensorAttributes(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__GetSensorAttributes, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__GetSensorAttributes; + if (size) + *size = sizeof(struct __emi__GetSensorAttributes); + } + else + { cp->ptr = (void*)new struct __emi__GetSensorAttributes[n]; + if (size) + *size = n * sizeof(struct __emi__GetSensorAttributes); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__GetSensorAttributes*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetSensorAttributes(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__GetSensorAttributes %p -> %p\n", q, p)); + *(struct __emi__GetSensorAttributes*)p = *(struct __emi__GetSensorAttributes*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateSensors(struct soap *soap, const struct __emi__EnumerateSensors *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__EnumerateSensors(soap, &a->emi__EnumerateSensors); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateSensors(struct soap *soap, struct __emi__EnumerateSensors *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__EnumerateSensors = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateSensors(struct soap *soap, const struct __emi__EnumerateSensors *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__EnumerateSensors(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateSensors(struct soap *soap, const char *tag, int id, const struct __emi__EnumerateSensors *a, const char *type) +{ + soap_out_PointerTo_emi__EnumerateSensors(soap, "emi:EnumerateSensors", -1, &a->emi__EnumerateSensors, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__EnumerateSensors * SOAP_FMAC4 soap_get___emi__EnumerateSensors(struct soap *soap, struct __emi__EnumerateSensors *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__EnumerateSensors(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__EnumerateSensors * SOAP_FMAC4 soap_in___emi__EnumerateSensors(struct soap *soap, const char *tag, struct __emi__EnumerateSensors *a, const char *type) +{ + short soap_flag_emi__EnumerateSensors = 1; + a = (struct __emi__EnumerateSensors *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__EnumerateSensors, sizeof(struct __emi__EnumerateSensors), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__EnumerateSensors(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__EnumerateSensors && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__EnumerateSensors(soap, "emi:EnumerateSensors", &a->emi__EnumerateSensors, "")) + { soap_flag_emi__EnumerateSensors--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__EnumerateSensors * SOAP_FMAC6 soap_new___emi__EnumerateSensors(struct soap *soap, int n) +{ return soap_instantiate___emi__EnumerateSensors(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateSensors(struct soap *soap, struct __emi__EnumerateSensors *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__EnumerateSensors * SOAP_FMAC4 soap_instantiate___emi__EnumerateSensors(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__EnumerateSensors(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__EnumerateSensors, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__EnumerateSensors; + if (size) + *size = sizeof(struct __emi__EnumerateSensors); + } + else + { cp->ptr = (void*)new struct __emi__EnumerateSensors[n]; + if (size) + *size = n * sizeof(struct __emi__EnumerateSensors); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__EnumerateSensors*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateSensors(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__EnumerateSensors %p -> %p\n", q, p)); + *(struct __emi__EnumerateSensors*)p = *(struct __emi__EnumerateSensors*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetEventLogTimestampClock(struct soap *soap, const struct __emi__GetEventLogTimestampClock *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__GetEventLogTimestampClock(soap, &a->emi__GetEventLogTimestampClock); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetEventLogTimestampClock(struct soap *soap, struct __emi__GetEventLogTimestampClock *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__GetEventLogTimestampClock = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetEventLogTimestampClock(struct soap *soap, const struct __emi__GetEventLogTimestampClock *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__GetEventLogTimestampClock(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetEventLogTimestampClock(struct soap *soap, const char *tag, int id, const struct __emi__GetEventLogTimestampClock *a, const char *type) +{ + soap_out_PointerTo_emi__GetEventLogTimestampClock(soap, "emi:GetEventLogTimestampClock", -1, &a->emi__GetEventLogTimestampClock, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_get___emi__GetEventLogTimestampClock(struct soap *soap, struct __emi__GetEventLogTimestampClock *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__GetEventLogTimestampClock(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_in___emi__GetEventLogTimestampClock(struct soap *soap, const char *tag, struct __emi__GetEventLogTimestampClock *a, const char *type) +{ + short soap_flag_emi__GetEventLogTimestampClock = 1; + a = (struct __emi__GetEventLogTimestampClock *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__GetEventLogTimestampClock, sizeof(struct __emi__GetEventLogTimestampClock), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__GetEventLogTimestampClock(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__GetEventLogTimestampClock && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__GetEventLogTimestampClock(soap, "emi:GetEventLogTimestampClock", &a->emi__GetEventLogTimestampClock, "")) + { soap_flag_emi__GetEventLogTimestampClock--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__GetEventLogTimestampClock * SOAP_FMAC6 soap_new___emi__GetEventLogTimestampClock(struct soap *soap, int n) +{ return soap_instantiate___emi__GetEventLogTimestampClock(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetEventLogTimestampClock(struct soap *soap, struct __emi__GetEventLogTimestampClock *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__GetEventLogTimestampClock * SOAP_FMAC4 soap_instantiate___emi__GetEventLogTimestampClock(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__GetEventLogTimestampClock(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__GetEventLogTimestampClock, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__GetEventLogTimestampClock; + if (size) + *size = sizeof(struct __emi__GetEventLogTimestampClock); + } + else + { cp->ptr = (void*)new struct __emi__GetEventLogTimestampClock[n]; + if (size) + *size = n * sizeof(struct __emi__GetEventLogTimestampClock); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__GetEventLogTimestampClock*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetEventLogTimestampClock(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__GetEventLogTimestampClock %p -> %p\n", q, p)); + *(struct __emi__GetEventLogTimestampClock*)p = *(struct __emi__GetEventLogTimestampClock*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__SetEventLogTimestampClock(struct soap *soap, const struct __emi__SetEventLogTimestampClock *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__SetEventLogTimestampClock(soap, &a->emi__SetEventLogTimestampClock); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__SetEventLogTimestampClock(struct soap *soap, struct __emi__SetEventLogTimestampClock *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__SetEventLogTimestampClock = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__SetEventLogTimestampClock(struct soap *soap, const struct __emi__SetEventLogTimestampClock *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__SetEventLogTimestampClock(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__SetEventLogTimestampClock(struct soap *soap, const char *tag, int id, const struct __emi__SetEventLogTimestampClock *a, const char *type) +{ + soap_out_PointerTo_emi__SetEventLogTimestampClock(soap, "emi:SetEventLogTimestampClock", -1, &a->emi__SetEventLogTimestampClock, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_get___emi__SetEventLogTimestampClock(struct soap *soap, struct __emi__SetEventLogTimestampClock *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__SetEventLogTimestampClock(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_in___emi__SetEventLogTimestampClock(struct soap *soap, const char *tag, struct __emi__SetEventLogTimestampClock *a, const char *type) +{ + short soap_flag_emi__SetEventLogTimestampClock = 1; + a = (struct __emi__SetEventLogTimestampClock *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__SetEventLogTimestampClock, sizeof(struct __emi__SetEventLogTimestampClock), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__SetEventLogTimestampClock(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__SetEventLogTimestampClock && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__SetEventLogTimestampClock(soap, "emi:SetEventLogTimestampClock", &a->emi__SetEventLogTimestampClock, "")) + { soap_flag_emi__SetEventLogTimestampClock--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__SetEventLogTimestampClock * SOAP_FMAC6 soap_new___emi__SetEventLogTimestampClock(struct soap *soap, int n) +{ return soap_instantiate___emi__SetEventLogTimestampClock(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__SetEventLogTimestampClock(struct soap *soap, struct __emi__SetEventLogTimestampClock *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__SetEventLogTimestampClock * SOAP_FMAC4 soap_instantiate___emi__SetEventLogTimestampClock(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__SetEventLogTimestampClock(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__SetEventLogTimestampClock, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__SetEventLogTimestampClock; + if (size) + *size = sizeof(struct __emi__SetEventLogTimestampClock); + } + else + { cp->ptr = (void*)new struct __emi__SetEventLogTimestampClock[n]; + if (size) + *size = n * sizeof(struct __emi__SetEventLogTimestampClock); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__SetEventLogTimestampClock*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__SetEventLogTimestampClock(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__SetEventLogTimestampClock %p -> %p\n", q, p)); + *(struct __emi__SetEventLogTimestampClock*)p = *(struct __emi__SetEventLogTimestampClock*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__FreezeEventLog(struct soap *soap, const struct __emi__FreezeEventLog *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__FreezeEventLog(soap, &a->emi__FreezeEventLog); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__FreezeEventLog(struct soap *soap, struct __emi__FreezeEventLog *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__FreezeEventLog = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__FreezeEventLog(struct soap *soap, const struct __emi__FreezeEventLog *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__FreezeEventLog(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__FreezeEventLog(struct soap *soap, const char *tag, int id, const struct __emi__FreezeEventLog *a, const char *type) +{ + soap_out_PointerTo_emi__FreezeEventLog(soap, "emi:FreezeEventLog", -1, &a->emi__FreezeEventLog, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__FreezeEventLog * SOAP_FMAC4 soap_get___emi__FreezeEventLog(struct soap *soap, struct __emi__FreezeEventLog *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__FreezeEventLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__FreezeEventLog * SOAP_FMAC4 soap_in___emi__FreezeEventLog(struct soap *soap, const char *tag, struct __emi__FreezeEventLog *a, const char *type) +{ + short soap_flag_emi__FreezeEventLog = 1; + a = (struct __emi__FreezeEventLog *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__FreezeEventLog, sizeof(struct __emi__FreezeEventLog), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__FreezeEventLog(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__FreezeEventLog && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__FreezeEventLog(soap, "emi:FreezeEventLog", &a->emi__FreezeEventLog, "")) + { soap_flag_emi__FreezeEventLog--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__FreezeEventLog * SOAP_FMAC6 soap_new___emi__FreezeEventLog(struct soap *soap, int n) +{ return soap_instantiate___emi__FreezeEventLog(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__FreezeEventLog(struct soap *soap, struct __emi__FreezeEventLog *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__FreezeEventLog * SOAP_FMAC4 soap_instantiate___emi__FreezeEventLog(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__FreezeEventLog(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__FreezeEventLog, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__FreezeEventLog; + if (size) + *size = sizeof(struct __emi__FreezeEventLog); + } + else + { cp->ptr = (void*)new struct __emi__FreezeEventLog[n]; + if (size) + *size = n * sizeof(struct __emi__FreezeEventLog); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__FreezeEventLog*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__FreezeEventLog(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__FreezeEventLog %p -> %p\n", q, p)); + *(struct __emi__FreezeEventLog*)p = *(struct __emi__FreezeEventLog*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__ClearEventLog(struct soap *soap, const struct __emi__ClearEventLog *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__ClearEventLog(soap, &a->emi__ClearEventLog); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__ClearEventLog(struct soap *soap, struct __emi__ClearEventLog *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__ClearEventLog = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__ClearEventLog(struct soap *soap, const struct __emi__ClearEventLog *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__ClearEventLog(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__ClearEventLog(struct soap *soap, const char *tag, int id, const struct __emi__ClearEventLog *a, const char *type) +{ + soap_out_PointerTo_emi__ClearEventLog(soap, "emi:ClearEventLog", -1, &a->emi__ClearEventLog, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__ClearEventLog * SOAP_FMAC4 soap_get___emi__ClearEventLog(struct soap *soap, struct __emi__ClearEventLog *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__ClearEventLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__ClearEventLog * SOAP_FMAC4 soap_in___emi__ClearEventLog(struct soap *soap, const char *tag, struct __emi__ClearEventLog *a, const char *type) +{ + short soap_flag_emi__ClearEventLog = 1; + a = (struct __emi__ClearEventLog *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__ClearEventLog, sizeof(struct __emi__ClearEventLog), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__ClearEventLog(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__ClearEventLog && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__ClearEventLog(soap, "emi:ClearEventLog", &a->emi__ClearEventLog, "")) + { soap_flag_emi__ClearEventLog--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__ClearEventLog * SOAP_FMAC6 soap_new___emi__ClearEventLog(struct soap *soap, int n) +{ return soap_instantiate___emi__ClearEventLog(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__ClearEventLog(struct soap *soap, struct __emi__ClearEventLog *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__ClearEventLog * SOAP_FMAC4 soap_instantiate___emi__ClearEventLog(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__ClearEventLog(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__ClearEventLog, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__ClearEventLog; + if (size) + *size = sizeof(struct __emi__ClearEventLog); + } + else + { cp->ptr = (void*)new struct __emi__ClearEventLog[n]; + if (size) + *size = n * sizeof(struct __emi__ClearEventLog); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__ClearEventLog*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__ClearEventLog(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__ClearEventLog %p -> %p\n", q, p)); + *(struct __emi__ClearEventLog*)p = *(struct __emi__ClearEventLog*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__ReadEventLogRecords(struct soap *soap, const struct __emi__ReadEventLogRecords *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__ReadEventLogRecords(soap, &a->emi__ReadEventLogRecords); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__ReadEventLogRecords(struct soap *soap, struct __emi__ReadEventLogRecords *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__ReadEventLogRecords = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__ReadEventLogRecords(struct soap *soap, const struct __emi__ReadEventLogRecords *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__ReadEventLogRecords(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__ReadEventLogRecords(struct soap *soap, const char *tag, int id, const struct __emi__ReadEventLogRecords *a, const char *type) +{ + soap_out_PointerTo_emi__ReadEventLogRecords(soap, "emi:ReadEventLogRecords", -1, &a->emi__ReadEventLogRecords, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__ReadEventLogRecords * SOAP_FMAC4 soap_get___emi__ReadEventLogRecords(struct soap *soap, struct __emi__ReadEventLogRecords *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__ReadEventLogRecords(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__ReadEventLogRecords * SOAP_FMAC4 soap_in___emi__ReadEventLogRecords(struct soap *soap, const char *tag, struct __emi__ReadEventLogRecords *a, const char *type) +{ + short soap_flag_emi__ReadEventLogRecords = 1; + a = (struct __emi__ReadEventLogRecords *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__ReadEventLogRecords, sizeof(struct __emi__ReadEventLogRecords), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__ReadEventLogRecords(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__ReadEventLogRecords && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__ReadEventLogRecords(soap, "emi:ReadEventLogRecords", &a->emi__ReadEventLogRecords, "")) + { soap_flag_emi__ReadEventLogRecords--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__ReadEventLogRecords * SOAP_FMAC6 soap_new___emi__ReadEventLogRecords(struct soap *soap, int n) +{ return soap_instantiate___emi__ReadEventLogRecords(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__ReadEventLogRecords(struct soap *soap, struct __emi__ReadEventLogRecords *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__ReadEventLogRecords * SOAP_FMAC4 soap_instantiate___emi__ReadEventLogRecords(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__ReadEventLogRecords(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__ReadEventLogRecords, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__ReadEventLogRecords; + if (size) + *size = sizeof(struct __emi__ReadEventLogRecords); + } + else + { cp->ptr = (void*)new struct __emi__ReadEventLogRecords[n]; + if (size) + *size = n * sizeof(struct __emi__ReadEventLogRecords); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__ReadEventLogRecords*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__ReadEventLogRecords(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__ReadEventLogRecords %p -> %p\n", q, p)); + *(struct __emi__ReadEventLogRecords*)p = *(struct __emi__ReadEventLogRecords*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetEventLogStatus(struct soap *soap, const struct __emi__GetEventLogStatus *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__GetEventLogStatus(soap, &a->emi__GetEventLogStatus); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetEventLogStatus(struct soap *soap, struct __emi__GetEventLogStatus *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__GetEventLogStatus = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetEventLogStatus(struct soap *soap, const struct __emi__GetEventLogStatus *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__GetEventLogStatus(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetEventLogStatus(struct soap *soap, const char *tag, int id, const struct __emi__GetEventLogStatus *a, const char *type) +{ + soap_out_PointerTo_emi__GetEventLogStatus(soap, "emi:GetEventLogStatus", -1, &a->emi__GetEventLogStatus, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__GetEventLogStatus * SOAP_FMAC4 soap_get___emi__GetEventLogStatus(struct soap *soap, struct __emi__GetEventLogStatus *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__GetEventLogStatus(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__GetEventLogStatus * SOAP_FMAC4 soap_in___emi__GetEventLogStatus(struct soap *soap, const char *tag, struct __emi__GetEventLogStatus *a, const char *type) +{ + short soap_flag_emi__GetEventLogStatus = 1; + a = (struct __emi__GetEventLogStatus *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__GetEventLogStatus, sizeof(struct __emi__GetEventLogStatus), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__GetEventLogStatus(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__GetEventLogStatus && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__GetEventLogStatus(soap, "emi:GetEventLogStatus", &a->emi__GetEventLogStatus, "")) + { soap_flag_emi__GetEventLogStatus--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__GetEventLogStatus * SOAP_FMAC6 soap_new___emi__GetEventLogStatus(struct soap *soap, int n) +{ return soap_instantiate___emi__GetEventLogStatus(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetEventLogStatus(struct soap *soap, struct __emi__GetEventLogStatus *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__GetEventLogStatus * SOAP_FMAC4 soap_instantiate___emi__GetEventLogStatus(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__GetEventLogStatus(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__GetEventLogStatus, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__GetEventLogStatus; + if (size) + *size = sizeof(struct __emi__GetEventLogStatus); + } + else + { cp->ptr = (void*)new struct __emi__GetEventLogStatus[n]; + if (size) + *size = n * sizeof(struct __emi__GetEventLogStatus); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__GetEventLogStatus*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetEventLogStatus(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__GetEventLogStatus %p -> %p\n", q, p)); + *(struct __emi__GetEventLogStatus*)p = *(struct __emi__GetEventLogStatus*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__RemoveEventFilter(struct soap *soap, const struct __emi__RemoveEventFilter *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__RemoveEventFilter(soap, &a->emi__RemoveEventFilter); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__RemoveEventFilter(struct soap *soap, struct __emi__RemoveEventFilter *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__RemoveEventFilter = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__RemoveEventFilter(struct soap *soap, const struct __emi__RemoveEventFilter *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__RemoveEventFilter(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__RemoveEventFilter(struct soap *soap, const char *tag, int id, const struct __emi__RemoveEventFilter *a, const char *type) +{ + soap_out_PointerTo_emi__RemoveEventFilter(soap, "emi:RemoveEventFilter", -1, &a->emi__RemoveEventFilter, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__RemoveEventFilter * SOAP_FMAC4 soap_get___emi__RemoveEventFilter(struct soap *soap, struct __emi__RemoveEventFilter *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__RemoveEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__RemoveEventFilter * SOAP_FMAC4 soap_in___emi__RemoveEventFilter(struct soap *soap, const char *tag, struct __emi__RemoveEventFilter *a, const char *type) +{ + short soap_flag_emi__RemoveEventFilter = 1; + a = (struct __emi__RemoveEventFilter *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__RemoveEventFilter, sizeof(struct __emi__RemoveEventFilter), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__RemoveEventFilter(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__RemoveEventFilter && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__RemoveEventFilter(soap, "emi:RemoveEventFilter", &a->emi__RemoveEventFilter, "")) + { soap_flag_emi__RemoveEventFilter--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__RemoveEventFilter * SOAP_FMAC6 soap_new___emi__RemoveEventFilter(struct soap *soap, int n) +{ return soap_instantiate___emi__RemoveEventFilter(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__RemoveEventFilter(struct soap *soap, struct __emi__RemoveEventFilter *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__RemoveEventFilter * SOAP_FMAC4 soap_instantiate___emi__RemoveEventFilter(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__RemoveEventFilter(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__RemoveEventFilter, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__RemoveEventFilter; + if (size) + *size = sizeof(struct __emi__RemoveEventFilter); + } + else + { cp->ptr = (void*)new struct __emi__RemoveEventFilter[n]; + if (size) + *size = n * sizeof(struct __emi__RemoveEventFilter); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__RemoveEventFilter*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__RemoveEventFilter(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__RemoveEventFilter %p -> %p\n", q, p)); + *(struct __emi__RemoveEventFilter*)p = *(struct __emi__RemoveEventFilter*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__UpdateEventFilter(struct soap *soap, const struct __emi__UpdateEventFilter *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__UpdateEventFilter(soap, &a->emi__UpdateEventFilter); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__UpdateEventFilter(struct soap *soap, struct __emi__UpdateEventFilter *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__UpdateEventFilter = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__UpdateEventFilter(struct soap *soap, const struct __emi__UpdateEventFilter *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__UpdateEventFilter(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__UpdateEventFilter(struct soap *soap, const char *tag, int id, const struct __emi__UpdateEventFilter *a, const char *type) +{ + soap_out_PointerTo_emi__UpdateEventFilter(soap, "emi:UpdateEventFilter", -1, &a->emi__UpdateEventFilter, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__UpdateEventFilter * SOAP_FMAC4 soap_get___emi__UpdateEventFilter(struct soap *soap, struct __emi__UpdateEventFilter *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__UpdateEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__UpdateEventFilter * SOAP_FMAC4 soap_in___emi__UpdateEventFilter(struct soap *soap, const char *tag, struct __emi__UpdateEventFilter *a, const char *type) +{ + short soap_flag_emi__UpdateEventFilter = 1; + a = (struct __emi__UpdateEventFilter *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__UpdateEventFilter, sizeof(struct __emi__UpdateEventFilter), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__UpdateEventFilter(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__UpdateEventFilter && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__UpdateEventFilter(soap, "emi:UpdateEventFilter", &a->emi__UpdateEventFilter, "")) + { soap_flag_emi__UpdateEventFilter--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__UpdateEventFilter * SOAP_FMAC6 soap_new___emi__UpdateEventFilter(struct soap *soap, int n) +{ return soap_instantiate___emi__UpdateEventFilter(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__UpdateEventFilter(struct soap *soap, struct __emi__UpdateEventFilter *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__UpdateEventFilter * SOAP_FMAC4 soap_instantiate___emi__UpdateEventFilter(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__UpdateEventFilter(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__UpdateEventFilter, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__UpdateEventFilter; + if (size) + *size = sizeof(struct __emi__UpdateEventFilter); + } + else + { cp->ptr = (void*)new struct __emi__UpdateEventFilter[n]; + if (size) + *size = n * sizeof(struct __emi__UpdateEventFilter); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__UpdateEventFilter*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__UpdateEventFilter(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__UpdateEventFilter %p -> %p\n", q, p)); + *(struct __emi__UpdateEventFilter*)p = *(struct __emi__UpdateEventFilter*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetEventFilter(struct soap *soap, const struct __emi__GetEventFilter *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__GetEventFilter(soap, &a->emi__GetEventFilter); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetEventFilter(struct soap *soap, struct __emi__GetEventFilter *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__GetEventFilter = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetEventFilter(struct soap *soap, const struct __emi__GetEventFilter *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__GetEventFilter(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetEventFilter(struct soap *soap, const char *tag, int id, const struct __emi__GetEventFilter *a, const char *type) +{ + soap_out_PointerTo_emi__GetEventFilter(soap, "emi:GetEventFilter", -1, &a->emi__GetEventFilter, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__GetEventFilter * SOAP_FMAC4 soap_get___emi__GetEventFilter(struct soap *soap, struct __emi__GetEventFilter *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__GetEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__GetEventFilter * SOAP_FMAC4 soap_in___emi__GetEventFilter(struct soap *soap, const char *tag, struct __emi__GetEventFilter *a, const char *type) +{ + short soap_flag_emi__GetEventFilter = 1; + a = (struct __emi__GetEventFilter *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__GetEventFilter, sizeof(struct __emi__GetEventFilter), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__GetEventFilter(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__GetEventFilter && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__GetEventFilter(soap, "emi:GetEventFilter", &a->emi__GetEventFilter, "")) + { soap_flag_emi__GetEventFilter--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__GetEventFilter * SOAP_FMAC6 soap_new___emi__GetEventFilter(struct soap *soap, int n) +{ return soap_instantiate___emi__GetEventFilter(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetEventFilter(struct soap *soap, struct __emi__GetEventFilter *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__GetEventFilter * SOAP_FMAC4 soap_instantiate___emi__GetEventFilter(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__GetEventFilter(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__GetEventFilter, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__GetEventFilter; + if (size) + *size = sizeof(struct __emi__GetEventFilter); + } + else + { cp->ptr = (void*)new struct __emi__GetEventFilter[n]; + if (size) + *size = n * sizeof(struct __emi__GetEventFilter); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__GetEventFilter*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetEventFilter(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__GetEventFilter %p -> %p\n", q, p)); + *(struct __emi__GetEventFilter*)p = *(struct __emi__GetEventFilter*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__CancelAlertSubscription(struct soap *soap, const struct __emi__CancelAlertSubscription *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__CancelAlertSubscription(soap, &a->emi__CancelAlertSubscription); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__CancelAlertSubscription(struct soap *soap, struct __emi__CancelAlertSubscription *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__CancelAlertSubscription = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__CancelAlertSubscription(struct soap *soap, const struct __emi__CancelAlertSubscription *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__CancelAlertSubscription(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__CancelAlertSubscription(struct soap *soap, const char *tag, int id, const struct __emi__CancelAlertSubscription *a, const char *type) +{ + soap_out_PointerTo_emi__CancelAlertSubscription(soap, "emi:CancelAlertSubscription", -1, &a->emi__CancelAlertSubscription, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__CancelAlertSubscription * SOAP_FMAC4 soap_get___emi__CancelAlertSubscription(struct soap *soap, struct __emi__CancelAlertSubscription *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__CancelAlertSubscription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__CancelAlertSubscription * SOAP_FMAC4 soap_in___emi__CancelAlertSubscription(struct soap *soap, const char *tag, struct __emi__CancelAlertSubscription *a, const char *type) +{ + short soap_flag_emi__CancelAlertSubscription = 1; + a = (struct __emi__CancelAlertSubscription *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__CancelAlertSubscription, sizeof(struct __emi__CancelAlertSubscription), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__CancelAlertSubscription(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__CancelAlertSubscription && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__CancelAlertSubscription(soap, "emi:CancelAlertSubscription", &a->emi__CancelAlertSubscription, "")) + { soap_flag_emi__CancelAlertSubscription--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__CancelAlertSubscription * SOAP_FMAC6 soap_new___emi__CancelAlertSubscription(struct soap *soap, int n) +{ return soap_instantiate___emi__CancelAlertSubscription(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__CancelAlertSubscription(struct soap *soap, struct __emi__CancelAlertSubscription *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__CancelAlertSubscription * SOAP_FMAC4 soap_instantiate___emi__CancelAlertSubscription(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__CancelAlertSubscription(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__CancelAlertSubscription, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__CancelAlertSubscription; + if (size) + *size = sizeof(struct __emi__CancelAlertSubscription); + } + else + { cp->ptr = (void*)new struct __emi__CancelAlertSubscription[n]; + if (size) + *size = n * sizeof(struct __emi__CancelAlertSubscription); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__CancelAlertSubscription*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__CancelAlertSubscription(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__CancelAlertSubscription %p -> %p\n", q, p)); + *(struct __emi__CancelAlertSubscription*)p = *(struct __emi__CancelAlertSubscription*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateAlertPolicies(struct soap *soap, const struct __emi__EnumerateAlertPolicies *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__EnumerateAlertPolicies(soap, &a->emi__EnumerateAlertPolicies); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateAlertPolicies(struct soap *soap, struct __emi__EnumerateAlertPolicies *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__EnumerateAlertPolicies = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateAlertPolicies(struct soap *soap, const struct __emi__EnumerateAlertPolicies *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__EnumerateAlertPolicies(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateAlertPolicies(struct soap *soap, const char *tag, int id, const struct __emi__EnumerateAlertPolicies *a, const char *type) +{ + soap_out_PointerTo_emi__EnumerateAlertPolicies(soap, "emi:EnumerateAlertPolicies", -1, &a->emi__EnumerateAlertPolicies, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_get___emi__EnumerateAlertPolicies(struct soap *soap, struct __emi__EnumerateAlertPolicies *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__EnumerateAlertPolicies(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_in___emi__EnumerateAlertPolicies(struct soap *soap, const char *tag, struct __emi__EnumerateAlertPolicies *a, const char *type) +{ + short soap_flag_emi__EnumerateAlertPolicies = 1; + a = (struct __emi__EnumerateAlertPolicies *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__EnumerateAlertPolicies, sizeof(struct __emi__EnumerateAlertPolicies), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__EnumerateAlertPolicies(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__EnumerateAlertPolicies && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__EnumerateAlertPolicies(soap, "emi:EnumerateAlertPolicies", &a->emi__EnumerateAlertPolicies, "")) + { soap_flag_emi__EnumerateAlertPolicies--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__EnumerateAlertPolicies * SOAP_FMAC6 soap_new___emi__EnumerateAlertPolicies(struct soap *soap, int n) +{ return soap_instantiate___emi__EnumerateAlertPolicies(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateAlertPolicies(struct soap *soap, struct __emi__EnumerateAlertPolicies *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__EnumerateAlertPolicies * SOAP_FMAC4 soap_instantiate___emi__EnumerateAlertPolicies(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__EnumerateAlertPolicies(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__EnumerateAlertPolicies, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__EnumerateAlertPolicies; + if (size) + *size = sizeof(struct __emi__EnumerateAlertPolicies); + } + else + { cp->ptr = (void*)new struct __emi__EnumerateAlertPolicies[n]; + if (size) + *size = n * sizeof(struct __emi__EnumerateAlertPolicies); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__EnumerateAlertPolicies*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateAlertPolicies(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__EnumerateAlertPolicies %p -> %p\n", q, p)); + *(struct __emi__EnumerateAlertPolicies*)p = *(struct __emi__EnumerateAlertPolicies*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateAlertSubscriptions(struct soap *soap, const struct __emi__EnumerateAlertSubscriptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__EnumerateAlertSubscriptions(soap, &a->emi__EnumerateAlertSubscriptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateAlertSubscriptions(struct soap *soap, struct __emi__EnumerateAlertSubscriptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__EnumerateAlertSubscriptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateAlertSubscriptions(struct soap *soap, const struct __emi__EnumerateAlertSubscriptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__EnumerateAlertSubscriptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateAlertSubscriptions(struct soap *soap, const char *tag, int id, const struct __emi__EnumerateAlertSubscriptions *a, const char *type) +{ + soap_out_PointerTo_emi__EnumerateAlertSubscriptions(soap, "emi:EnumerateAlertSubscriptions", -1, &a->emi__EnumerateAlertSubscriptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_get___emi__EnumerateAlertSubscriptions(struct soap *soap, struct __emi__EnumerateAlertSubscriptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__EnumerateAlertSubscriptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_in___emi__EnumerateAlertSubscriptions(struct soap *soap, const char *tag, struct __emi__EnumerateAlertSubscriptions *a, const char *type) +{ + short soap_flag_emi__EnumerateAlertSubscriptions = 1; + a = (struct __emi__EnumerateAlertSubscriptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__EnumerateAlertSubscriptions, sizeof(struct __emi__EnumerateAlertSubscriptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__EnumerateAlertSubscriptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__EnumerateAlertSubscriptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__EnumerateAlertSubscriptions(soap, "emi:EnumerateAlertSubscriptions", &a->emi__EnumerateAlertSubscriptions, "")) + { soap_flag_emi__EnumerateAlertSubscriptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__EnumerateAlertSubscriptions * SOAP_FMAC6 soap_new___emi__EnumerateAlertSubscriptions(struct soap *soap, int n) +{ return soap_instantiate___emi__EnumerateAlertSubscriptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateAlertSubscriptions(struct soap *soap, struct __emi__EnumerateAlertSubscriptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__EnumerateAlertSubscriptions * SOAP_FMAC4 soap_instantiate___emi__EnumerateAlertSubscriptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__EnumerateAlertSubscriptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__EnumerateAlertSubscriptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__EnumerateAlertSubscriptions; + if (size) + *size = sizeof(struct __emi__EnumerateAlertSubscriptions); + } + else + { cp->ptr = (void*)new struct __emi__EnumerateAlertSubscriptions[n]; + if (size) + *size = n * sizeof(struct __emi__EnumerateAlertSubscriptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__EnumerateAlertSubscriptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateAlertSubscriptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__EnumerateAlertSubscriptions %p -> %p\n", q, p)); + *(struct __emi__EnumerateAlertSubscriptions*)p = *(struct __emi__EnumerateAlertSubscriptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__SubscribeForAlert(struct soap *soap, const struct __emi__SubscribeForAlert *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__SubscribeForAlert(soap, &a->emi__SubscribeForAlert); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__SubscribeForAlert(struct soap *soap, struct __emi__SubscribeForAlert *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__SubscribeForAlert = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__SubscribeForAlert(struct soap *soap, const struct __emi__SubscribeForAlert *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__SubscribeForAlert(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__SubscribeForAlert(struct soap *soap, const char *tag, int id, const struct __emi__SubscribeForAlert *a, const char *type) +{ + soap_out_PointerTo_emi__SubscribeForAlert(soap, "emi:SubscribeForAlert", -1, &a->emi__SubscribeForAlert, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__SubscribeForAlert * SOAP_FMAC4 soap_get___emi__SubscribeForAlert(struct soap *soap, struct __emi__SubscribeForAlert *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__SubscribeForAlert(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__SubscribeForAlert * SOAP_FMAC4 soap_in___emi__SubscribeForAlert(struct soap *soap, const char *tag, struct __emi__SubscribeForAlert *a, const char *type) +{ + short soap_flag_emi__SubscribeForAlert = 1; + a = (struct __emi__SubscribeForAlert *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__SubscribeForAlert, sizeof(struct __emi__SubscribeForAlert), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__SubscribeForAlert(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__SubscribeForAlert && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__SubscribeForAlert(soap, "emi:SubscribeForAlert", &a->emi__SubscribeForAlert, "")) + { soap_flag_emi__SubscribeForAlert--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__SubscribeForAlert * SOAP_FMAC6 soap_new___emi__SubscribeForAlert(struct soap *soap, int n) +{ return soap_instantiate___emi__SubscribeForAlert(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__SubscribeForAlert(struct soap *soap, struct __emi__SubscribeForAlert *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__SubscribeForAlert * SOAP_FMAC4 soap_instantiate___emi__SubscribeForAlert(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__SubscribeForAlert(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__SubscribeForAlert, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__SubscribeForAlert; + if (size) + *size = sizeof(struct __emi__SubscribeForAlert); + } + else + { cp->ptr = (void*)new struct __emi__SubscribeForAlert[n]; + if (size) + *size = n * sizeof(struct __emi__SubscribeForAlert); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__SubscribeForAlert*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__SubscribeForAlert(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__SubscribeForAlert %p -> %p\n", q, p)); + *(struct __emi__SubscribeForAlert*)p = *(struct __emi__SubscribeForAlert*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__AddEventFilter(struct soap *soap, const struct __emi__AddEventFilter *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__AddEventFilter(soap, &a->emi__AddEventFilter); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__AddEventFilter(struct soap *soap, struct __emi__AddEventFilter *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__AddEventFilter = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__AddEventFilter(struct soap *soap, const struct __emi__AddEventFilter *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__AddEventFilter(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__AddEventFilter(struct soap *soap, const char *tag, int id, const struct __emi__AddEventFilter *a, const char *type) +{ + soap_out_PointerTo_emi__AddEventFilter(soap, "emi:AddEventFilter", -1, &a->emi__AddEventFilter, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__AddEventFilter * SOAP_FMAC4 soap_get___emi__AddEventFilter(struct soap *soap, struct __emi__AddEventFilter *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__AddEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__AddEventFilter * SOAP_FMAC4 soap_in___emi__AddEventFilter(struct soap *soap, const char *tag, struct __emi__AddEventFilter *a, const char *type) +{ + short soap_flag_emi__AddEventFilter = 1; + a = (struct __emi__AddEventFilter *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__AddEventFilter, sizeof(struct __emi__AddEventFilter), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__AddEventFilter(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__AddEventFilter && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__AddEventFilter(soap, "emi:AddEventFilter", &a->emi__AddEventFilter, "")) + { soap_flag_emi__AddEventFilter--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__AddEventFilter * SOAP_FMAC6 soap_new___emi__AddEventFilter(struct soap *soap, int n) +{ return soap_instantiate___emi__AddEventFilter(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__AddEventFilter(struct soap *soap, struct __emi__AddEventFilter *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__AddEventFilter * SOAP_FMAC4 soap_instantiate___emi__AddEventFilter(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__AddEventFilter(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__AddEventFilter, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__AddEventFilter; + if (size) + *size = sizeof(struct __emi__AddEventFilter); + } + else + { cp->ptr = (void*)new struct __emi__AddEventFilter[n]; + if (size) + *size = n * sizeof(struct __emi__AddEventFilter); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__AddEventFilter*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__AddEventFilter(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__AddEventFilter %p -> %p\n", q, p)); + *(struct __emi__AddEventFilter*)p = *(struct __emi__AddEventFilter*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetAlertCommunityString(struct soap *soap, const struct __emi__GetAlertCommunityString *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__GetAlertCommunityString(soap, &a->emi__GetAlertCommunityString); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetAlertCommunityString(struct soap *soap, struct __emi__GetAlertCommunityString *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__GetAlertCommunityString = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetAlertCommunityString(struct soap *soap, const struct __emi__GetAlertCommunityString *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__GetAlertCommunityString(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetAlertCommunityString(struct soap *soap, const char *tag, int id, const struct __emi__GetAlertCommunityString *a, const char *type) +{ + soap_out_PointerTo_emi__GetAlertCommunityString(soap, "emi:GetAlertCommunityString", -1, &a->emi__GetAlertCommunityString, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__GetAlertCommunityString * SOAP_FMAC4 soap_get___emi__GetAlertCommunityString(struct soap *soap, struct __emi__GetAlertCommunityString *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__GetAlertCommunityString(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__GetAlertCommunityString * SOAP_FMAC4 soap_in___emi__GetAlertCommunityString(struct soap *soap, const char *tag, struct __emi__GetAlertCommunityString *a, const char *type) +{ + short soap_flag_emi__GetAlertCommunityString = 1; + a = (struct __emi__GetAlertCommunityString *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__GetAlertCommunityString, sizeof(struct __emi__GetAlertCommunityString), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__GetAlertCommunityString(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__GetAlertCommunityString && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__GetAlertCommunityString(soap, "emi:GetAlertCommunityString", &a->emi__GetAlertCommunityString, "")) + { soap_flag_emi__GetAlertCommunityString--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__GetAlertCommunityString * SOAP_FMAC6 soap_new___emi__GetAlertCommunityString(struct soap *soap, int n) +{ return soap_instantiate___emi__GetAlertCommunityString(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetAlertCommunityString(struct soap *soap, struct __emi__GetAlertCommunityString *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__GetAlertCommunityString * SOAP_FMAC4 soap_instantiate___emi__GetAlertCommunityString(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__GetAlertCommunityString(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__GetAlertCommunityString, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__GetAlertCommunityString; + if (size) + *size = sizeof(struct __emi__GetAlertCommunityString); + } + else + { cp->ptr = (void*)new struct __emi__GetAlertCommunityString[n]; + if (size) + *size = n * sizeof(struct __emi__GetAlertCommunityString); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__GetAlertCommunityString*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetAlertCommunityString(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__GetAlertCommunityString %p -> %p\n", q, p)); + *(struct __emi__GetAlertCommunityString*)p = *(struct __emi__GetAlertCommunityString*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__SetAlertCommunityString(struct soap *soap, const struct __emi__SetAlertCommunityString *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__SetAlertCommunityString(soap, &a->emi__SetAlertCommunityString); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__SetAlertCommunityString(struct soap *soap, struct __emi__SetAlertCommunityString *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__SetAlertCommunityString = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__SetAlertCommunityString(struct soap *soap, const struct __emi__SetAlertCommunityString *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__SetAlertCommunityString(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__SetAlertCommunityString(struct soap *soap, const char *tag, int id, const struct __emi__SetAlertCommunityString *a, const char *type) +{ + soap_out_PointerTo_emi__SetAlertCommunityString(soap, "emi:SetAlertCommunityString", -1, &a->emi__SetAlertCommunityString, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__SetAlertCommunityString * SOAP_FMAC4 soap_get___emi__SetAlertCommunityString(struct soap *soap, struct __emi__SetAlertCommunityString *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__SetAlertCommunityString(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__SetAlertCommunityString * SOAP_FMAC4 soap_in___emi__SetAlertCommunityString(struct soap *soap, const char *tag, struct __emi__SetAlertCommunityString *a, const char *type) +{ + short soap_flag_emi__SetAlertCommunityString = 1; + a = (struct __emi__SetAlertCommunityString *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__SetAlertCommunityString, sizeof(struct __emi__SetAlertCommunityString), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__SetAlertCommunityString(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__SetAlertCommunityString && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__SetAlertCommunityString(soap, "emi:SetAlertCommunityString", &a->emi__SetAlertCommunityString, "")) + { soap_flag_emi__SetAlertCommunityString--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__SetAlertCommunityString * SOAP_FMAC6 soap_new___emi__SetAlertCommunityString(struct soap *soap, int n) +{ return soap_instantiate___emi__SetAlertCommunityString(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__SetAlertCommunityString(struct soap *soap, struct __emi__SetAlertCommunityString *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__SetAlertCommunityString * SOAP_FMAC4 soap_instantiate___emi__SetAlertCommunityString(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__SetAlertCommunityString(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__SetAlertCommunityString, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__SetAlertCommunityString; + if (size) + *size = sizeof(struct __emi__SetAlertCommunityString); + } + else + { cp->ptr = (void*)new struct __emi__SetAlertCommunityString[n]; + if (size) + *size = n * sizeof(struct __emi__SetAlertCommunityString); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__SetAlertCommunityString*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__SetAlertCommunityString(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__SetAlertCommunityString %p -> %p\n", q, p)); + *(struct __emi__SetAlertCommunityString*)p = *(struct __emi__SetAlertCommunityString*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__GetAlertSubscription(struct soap *soap, const struct __emi__GetAlertSubscription *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__GetAlertSubscription(soap, &a->emi__GetAlertSubscription); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__GetAlertSubscription(struct soap *soap, struct __emi__GetAlertSubscription *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__GetAlertSubscription = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__GetAlertSubscription(struct soap *soap, const struct __emi__GetAlertSubscription *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__GetAlertSubscription(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__GetAlertSubscription(struct soap *soap, const char *tag, int id, const struct __emi__GetAlertSubscription *a, const char *type) +{ + soap_out_PointerTo_emi__GetAlertSubscription(soap, "emi:GetAlertSubscription", -1, &a->emi__GetAlertSubscription, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__GetAlertSubscription * SOAP_FMAC4 soap_get___emi__GetAlertSubscription(struct soap *soap, struct __emi__GetAlertSubscription *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__GetAlertSubscription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__GetAlertSubscription * SOAP_FMAC4 soap_in___emi__GetAlertSubscription(struct soap *soap, const char *tag, struct __emi__GetAlertSubscription *a, const char *type) +{ + short soap_flag_emi__GetAlertSubscription = 1; + a = (struct __emi__GetAlertSubscription *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__GetAlertSubscription, sizeof(struct __emi__GetAlertSubscription), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__GetAlertSubscription(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__GetAlertSubscription && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__GetAlertSubscription(soap, "emi:GetAlertSubscription", &a->emi__GetAlertSubscription, "")) + { soap_flag_emi__GetAlertSubscription--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__GetAlertSubscription * SOAP_FMAC6 soap_new___emi__GetAlertSubscription(struct soap *soap, int n) +{ return soap_instantiate___emi__GetAlertSubscription(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__GetAlertSubscription(struct soap *soap, struct __emi__GetAlertSubscription *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__GetAlertSubscription * SOAP_FMAC4 soap_instantiate___emi__GetAlertSubscription(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__GetAlertSubscription(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__GetAlertSubscription, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__GetAlertSubscription; + if (size) + *size = sizeof(struct __emi__GetAlertSubscription); + } + else + { cp->ptr = (void*)new struct __emi__GetAlertSubscription[n]; + if (size) + *size = n * sizeof(struct __emi__GetAlertSubscription); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__GetAlertSubscription*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__GetAlertSubscription(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__GetAlertSubscription %p -> %p\n", q, p)); + *(struct __emi__GetAlertSubscription*)p = *(struct __emi__GetAlertSubscription*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___emi__EnumerateEventFilters(struct soap *soap, const struct __emi__EnumerateEventFilters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_emi__EnumerateEventFilters(soap, &a->emi__EnumerateEventFilters); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___emi__EnumerateEventFilters(struct soap *soap, struct __emi__EnumerateEventFilters *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->emi__EnumerateEventFilters = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___emi__EnumerateEventFilters(struct soap *soap, const struct __emi__EnumerateEventFilters *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___emi__EnumerateEventFilters(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___emi__EnumerateEventFilters(struct soap *soap, const char *tag, int id, const struct __emi__EnumerateEventFilters *a, const char *type) +{ + soap_out_PointerTo_emi__EnumerateEventFilters(soap, "emi:EnumerateEventFilters", -1, &a->emi__EnumerateEventFilters, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __emi__EnumerateEventFilters * SOAP_FMAC4 soap_get___emi__EnumerateEventFilters(struct soap *soap, struct __emi__EnumerateEventFilters *p, const char *tag, const char *type) +{ + if ((p = soap_in___emi__EnumerateEventFilters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __emi__EnumerateEventFilters * SOAP_FMAC4 soap_in___emi__EnumerateEventFilters(struct soap *soap, const char *tag, struct __emi__EnumerateEventFilters *a, const char *type) +{ + short soap_flag_emi__EnumerateEventFilters = 1; + a = (struct __emi__EnumerateEventFilters *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___emi__EnumerateEventFilters, sizeof(struct __emi__EnumerateEventFilters), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___emi__EnumerateEventFilters(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_emi__EnumerateEventFilters && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_emi__EnumerateEventFilters(soap, "emi:EnumerateEventFilters", &a->emi__EnumerateEventFilters, "")) + { soap_flag_emi__EnumerateEventFilters--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __emi__EnumerateEventFilters * SOAP_FMAC6 soap_new___emi__EnumerateEventFilters(struct soap *soap, int n) +{ return soap_instantiate___emi__EnumerateEventFilters(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___emi__EnumerateEventFilters(struct soap *soap, struct __emi__EnumerateEventFilters *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __emi__EnumerateEventFilters * SOAP_FMAC4 soap_instantiate___emi__EnumerateEventFilters(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___emi__EnumerateEventFilters(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___emi__EnumerateEventFilters, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __emi__EnumerateEventFilters; + if (size) + *size = sizeof(struct __emi__EnumerateEventFilters); + } + else + { cp->ptr = (void*)new struct __emi__EnumerateEventFilters[n]; + if (size) + *size = n * sizeof(struct __emi__EnumerateEventFilters); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __emi__EnumerateEventFilters*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___emi__EnumerateEventFilters(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __emi__EnumerateEventFilters %p -> %p\n", q, p)); + *(struct __emi__EnumerateEventFilters*)p = *(struct __emi__EnumerateEventFilters*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__GetHcbState(struct soap *soap, const struct __cb__GetHcbState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__GetHcbState(soap, &a->cb__GetHcbState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__GetHcbState(struct soap *soap, struct __cb__GetHcbState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__GetHcbState = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__GetHcbState(struct soap *soap, const struct __cb__GetHcbState *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__GetHcbState(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__GetHcbState(struct soap *soap, const char *tag, int id, const struct __cb__GetHcbState *a, const char *type) +{ + soap_out_PointerTo_cb__GetHcbState(soap, "cb:GetHcbState", -1, &a->cb__GetHcbState, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__GetHcbState * SOAP_FMAC4 soap_get___cb__GetHcbState(struct soap *soap, struct __cb__GetHcbState *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__GetHcbState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__GetHcbState * SOAP_FMAC4 soap_in___cb__GetHcbState(struct soap *soap, const char *tag, struct __cb__GetHcbState *a, const char *type) +{ + short soap_flag_cb__GetHcbState = 1; + a = (struct __cb__GetHcbState *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__GetHcbState, sizeof(struct __cb__GetHcbState), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__GetHcbState(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__GetHcbState && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__GetHcbState(soap, "cb:GetHcbState", &a->cb__GetHcbState, "")) + { soap_flag_cb__GetHcbState--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__GetHcbState * SOAP_FMAC6 soap_new___cb__GetHcbState(struct soap *soap, int n) +{ return soap_instantiate___cb__GetHcbState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__GetHcbState(struct soap *soap, struct __cb__GetHcbState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__GetHcbState * SOAP_FMAC4 soap_instantiate___cb__GetHcbState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__GetHcbState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__GetHcbState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__GetHcbState; + if (size) + *size = sizeof(struct __cb__GetHcbState); + } + else + { cp->ptr = (void*)new struct __cb__GetHcbState[n]; + if (size) + *size = n * sizeof(struct __cb__GetHcbState); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__GetHcbState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__GetHcbState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__GetHcbState %p -> %p\n", q, p)); + *(struct __cb__GetHcbState*)p = *(struct __cb__GetHcbState*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__ClearHcbState(struct soap *soap, const struct __cb__ClearHcbState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__ClearHcbState(soap, &a->cb__ClearHcbState); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__ClearHcbState(struct soap *soap, struct __cb__ClearHcbState *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__ClearHcbState = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__ClearHcbState(struct soap *soap, const struct __cb__ClearHcbState *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__ClearHcbState(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__ClearHcbState(struct soap *soap, const char *tag, int id, const struct __cb__ClearHcbState *a, const char *type) +{ + soap_out_PointerTo_cb__ClearHcbState(soap, "cb:ClearHcbState", -1, &a->cb__ClearHcbState, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__ClearHcbState * SOAP_FMAC4 soap_get___cb__ClearHcbState(struct soap *soap, struct __cb__ClearHcbState *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__ClearHcbState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__ClearHcbState * SOAP_FMAC4 soap_in___cb__ClearHcbState(struct soap *soap, const char *tag, struct __cb__ClearHcbState *a, const char *type) +{ + short soap_flag_cb__ClearHcbState = 1; + a = (struct __cb__ClearHcbState *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__ClearHcbState, sizeof(struct __cb__ClearHcbState), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__ClearHcbState(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__ClearHcbState && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__ClearHcbState(soap, "cb:ClearHcbState", &a->cb__ClearHcbState, "")) + { soap_flag_cb__ClearHcbState--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__ClearHcbState * SOAP_FMAC6 soap_new___cb__ClearHcbState(struct soap *soap, int n) +{ return soap_instantiate___cb__ClearHcbState(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__ClearHcbState(struct soap *soap, struct __cb__ClearHcbState *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__ClearHcbState * SOAP_FMAC4 soap_instantiate___cb__ClearHcbState(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__ClearHcbState(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__ClearHcbState, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__ClearHcbState; + if (size) + *size = sizeof(struct __cb__ClearHcbState); + } + else + { cp->ptr = (void*)new struct __cb__ClearHcbState[n]; + if (size) + *size = n * sizeof(struct __cb__ClearHcbState); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__ClearHcbState*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__ClearHcbState(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__ClearHcbState %p -> %p\n", q, p)); + *(struct __cb__ClearHcbState*)p = *(struct __cb__ClearHcbState*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__GetHcbOptions(struct soap *soap, const struct __cb__GetHcbOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__GetHcbOptions(soap, &a->cb__GetHcbOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__GetHcbOptions(struct soap *soap, struct __cb__GetHcbOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__GetHcbOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__GetHcbOptions(struct soap *soap, const struct __cb__GetHcbOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__GetHcbOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__GetHcbOptions(struct soap *soap, const char *tag, int id, const struct __cb__GetHcbOptions *a, const char *type) +{ + soap_out_PointerTo_cb__GetHcbOptions(soap, "cb:GetHcbOptions", -1, &a->cb__GetHcbOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__GetHcbOptions * SOAP_FMAC4 soap_get___cb__GetHcbOptions(struct soap *soap, struct __cb__GetHcbOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__GetHcbOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__GetHcbOptions * SOAP_FMAC4 soap_in___cb__GetHcbOptions(struct soap *soap, const char *tag, struct __cb__GetHcbOptions *a, const char *type) +{ + short soap_flag_cb__GetHcbOptions = 1; + a = (struct __cb__GetHcbOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__GetHcbOptions, sizeof(struct __cb__GetHcbOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__GetHcbOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__GetHcbOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__GetHcbOptions(soap, "cb:GetHcbOptions", &a->cb__GetHcbOptions, "")) + { soap_flag_cb__GetHcbOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__GetHcbOptions * SOAP_FMAC6 soap_new___cb__GetHcbOptions(struct soap *soap, int n) +{ return soap_instantiate___cb__GetHcbOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__GetHcbOptions(struct soap *soap, struct __cb__GetHcbOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__GetHcbOptions * SOAP_FMAC4 soap_instantiate___cb__GetHcbOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__GetHcbOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__GetHcbOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__GetHcbOptions; + if (size) + *size = sizeof(struct __cb__GetHcbOptions); + } + else + { cp->ptr = (void*)new struct __cb__GetHcbOptions[n]; + if (size) + *size = n * sizeof(struct __cb__GetHcbOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__GetHcbOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__GetHcbOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__GetHcbOptions %p -> %p\n", q, p)); + *(struct __cb__GetHcbOptions*)p = *(struct __cb__GetHcbOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__SetHcbOptions(struct soap *soap, const struct __cb__SetHcbOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__SetHcbOptions(soap, &a->cb__SetHcbOptions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__SetHcbOptions(struct soap *soap, struct __cb__SetHcbOptions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__SetHcbOptions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__SetHcbOptions(struct soap *soap, const struct __cb__SetHcbOptions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__SetHcbOptions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__SetHcbOptions(struct soap *soap, const char *tag, int id, const struct __cb__SetHcbOptions *a, const char *type) +{ + soap_out_PointerTo_cb__SetHcbOptions(soap, "cb:SetHcbOptions", -1, &a->cb__SetHcbOptions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__SetHcbOptions * SOAP_FMAC4 soap_get___cb__SetHcbOptions(struct soap *soap, struct __cb__SetHcbOptions *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__SetHcbOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__SetHcbOptions * SOAP_FMAC4 soap_in___cb__SetHcbOptions(struct soap *soap, const char *tag, struct __cb__SetHcbOptions *a, const char *type) +{ + short soap_flag_cb__SetHcbOptions = 1; + a = (struct __cb__SetHcbOptions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__SetHcbOptions, sizeof(struct __cb__SetHcbOptions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__SetHcbOptions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__SetHcbOptions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__SetHcbOptions(soap, "cb:SetHcbOptions", &a->cb__SetHcbOptions, "")) + { soap_flag_cb__SetHcbOptions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__SetHcbOptions * SOAP_FMAC6 soap_new___cb__SetHcbOptions(struct soap *soap, int n) +{ return soap_instantiate___cb__SetHcbOptions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__SetHcbOptions(struct soap *soap, struct __cb__SetHcbOptions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__SetHcbOptions * SOAP_FMAC4 soap_instantiate___cb__SetHcbOptions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__SetHcbOptions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__SetHcbOptions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__SetHcbOptions; + if (size) + *size = sizeof(struct __cb__SetHcbOptions); + } + else + { cp->ptr = (void*)new struct __cb__SetHcbOptions[n]; + if (size) + *size = n * sizeof(struct __cb__SetHcbOptions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__SetHcbOptions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__SetHcbOptions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__SetHcbOptions %p -> %p\n", q, p)); + *(struct __cb__SetHcbOptions*)p = *(struct __cb__SetHcbOptions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbQueryCapabilities(struct soap *soap, const struct __cb__CbQueryCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbQueryCapabilities(soap, &a->cb__CbQueryCapabilities); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbQueryCapabilities(struct soap *soap, struct __cb__CbQueryCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbQueryCapabilities = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbQueryCapabilities(struct soap *soap, const struct __cb__CbQueryCapabilities *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbQueryCapabilities(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbQueryCapabilities(struct soap *soap, const char *tag, int id, const struct __cb__CbQueryCapabilities *a, const char *type) +{ + soap_out_PointerTo_cb__CbQueryCapabilities(soap, "cb:CbQueryCapabilities", -1, &a->cb__CbQueryCapabilities, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbQueryCapabilities * SOAP_FMAC4 soap_get___cb__CbQueryCapabilities(struct soap *soap, struct __cb__CbQueryCapabilities *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbQueryCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbQueryCapabilities * SOAP_FMAC4 soap_in___cb__CbQueryCapabilities(struct soap *soap, const char *tag, struct __cb__CbQueryCapabilities *a, const char *type) +{ + short soap_flag_cb__CbQueryCapabilities = 1; + a = (struct __cb__CbQueryCapabilities *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbQueryCapabilities, sizeof(struct __cb__CbQueryCapabilities), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbQueryCapabilities(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbQueryCapabilities && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbQueryCapabilities(soap, "cb:CbQueryCapabilities", &a->cb__CbQueryCapabilities, "")) + { soap_flag_cb__CbQueryCapabilities--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbQueryCapabilities * SOAP_FMAC6 soap_new___cb__CbQueryCapabilities(struct soap *soap, int n) +{ return soap_instantiate___cb__CbQueryCapabilities(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbQueryCapabilities(struct soap *soap, struct __cb__CbQueryCapabilities *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbQueryCapabilities * SOAP_FMAC4 soap_instantiate___cb__CbQueryCapabilities(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbQueryCapabilities(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbQueryCapabilities, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbQueryCapabilities; + if (size) + *size = sizeof(struct __cb__CbQueryCapabilities); + } + else + { cp->ptr = (void*)new struct __cb__CbQueryCapabilities[n]; + if (size) + *size = n * sizeof(struct __cb__CbQueryCapabilities); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbQueryCapabilities*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbQueryCapabilities(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbQueryCapabilities %p -> %p\n", q, p)); + *(struct __cb__CbQueryCapabilities*)p = *(struct __cb__CbQueryCapabilities*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbFilterEnumerate(struct soap *soap, const struct __cb__CbFilterEnumerate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbFilterEnumerate(soap, &a->cb__CbFilterEnumerate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbFilterEnumerate(struct soap *soap, struct __cb__CbFilterEnumerate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbFilterEnumerate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbFilterEnumerate(struct soap *soap, const struct __cb__CbFilterEnumerate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbFilterEnumerate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbFilterEnumerate(struct soap *soap, const char *tag, int id, const struct __cb__CbFilterEnumerate *a, const char *type) +{ + soap_out_PointerTo_cb__CbFilterEnumerate(soap, "cb:CbFilterEnumerate", -1, &a->cb__CbFilterEnumerate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbFilterEnumerate * SOAP_FMAC4 soap_get___cb__CbFilterEnumerate(struct soap *soap, struct __cb__CbFilterEnumerate *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbFilterEnumerate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbFilterEnumerate * SOAP_FMAC4 soap_in___cb__CbFilterEnumerate(struct soap *soap, const char *tag, struct __cb__CbFilterEnumerate *a, const char *type) +{ + short soap_flag_cb__CbFilterEnumerate = 1; + a = (struct __cb__CbFilterEnumerate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbFilterEnumerate, sizeof(struct __cb__CbFilterEnumerate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbFilterEnumerate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbFilterEnumerate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbFilterEnumerate(soap, "cb:CbFilterEnumerate", &a->cb__CbFilterEnumerate, "")) + { soap_flag_cb__CbFilterEnumerate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbFilterEnumerate * SOAP_FMAC6 soap_new___cb__CbFilterEnumerate(struct soap *soap, int n) +{ return soap_instantiate___cb__CbFilterEnumerate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbFilterEnumerate(struct soap *soap, struct __cb__CbFilterEnumerate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbFilterEnumerate * SOAP_FMAC4 soap_instantiate___cb__CbFilterEnumerate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbFilterEnumerate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbFilterEnumerate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbFilterEnumerate; + if (size) + *size = sizeof(struct __cb__CbFilterEnumerate); + } + else + { cp->ptr = (void*)new struct __cb__CbFilterEnumerate[n]; + if (size) + *size = n * sizeof(struct __cb__CbFilterEnumerate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbFilterEnumerate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbFilterEnumerate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbFilterEnumerate %p -> %p\n", q, p)); + *(struct __cb__CbFilterEnumerate*)p = *(struct __cb__CbFilterEnumerate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbFilterDelete(struct soap *soap, const struct __cb__CbFilterDelete *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbFilterDelete(soap, &a->cb__CbFilterDelete); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbFilterDelete(struct soap *soap, struct __cb__CbFilterDelete *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbFilterDelete = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbFilterDelete(struct soap *soap, const struct __cb__CbFilterDelete *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbFilterDelete(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbFilterDelete(struct soap *soap, const char *tag, int id, const struct __cb__CbFilterDelete *a, const char *type) +{ + soap_out_PointerTo_cb__CbFilterDelete(soap, "cb:CbFilterDelete", -1, &a->cb__CbFilterDelete, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbFilterDelete * SOAP_FMAC4 soap_get___cb__CbFilterDelete(struct soap *soap, struct __cb__CbFilterDelete *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbFilterDelete(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbFilterDelete * SOAP_FMAC4 soap_in___cb__CbFilterDelete(struct soap *soap, const char *tag, struct __cb__CbFilterDelete *a, const char *type) +{ + short soap_flag_cb__CbFilterDelete = 1; + a = (struct __cb__CbFilterDelete *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbFilterDelete, sizeof(struct __cb__CbFilterDelete), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbFilterDelete(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbFilterDelete && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbFilterDelete(soap, "cb:CbFilterDelete", &a->cb__CbFilterDelete, "")) + { soap_flag_cb__CbFilterDelete--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbFilterDelete * SOAP_FMAC6 soap_new___cb__CbFilterDelete(struct soap *soap, int n) +{ return soap_instantiate___cb__CbFilterDelete(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbFilterDelete(struct soap *soap, struct __cb__CbFilterDelete *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbFilterDelete * SOAP_FMAC4 soap_instantiate___cb__CbFilterDelete(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbFilterDelete(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbFilterDelete, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbFilterDelete; + if (size) + *size = sizeof(struct __cb__CbFilterDelete); + } + else + { cp->ptr = (void*)new struct __cb__CbFilterDelete[n]; + if (size) + *size = n * sizeof(struct __cb__CbFilterDelete); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbFilterDelete*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbFilterDelete(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbFilterDelete %p -> %p\n", q, p)); + *(struct __cb__CbFilterDelete*)p = *(struct __cb__CbFilterDelete*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbFilterGet(struct soap *soap, const struct __cb__CbFilterGet *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbFilterGet(soap, &a->cb__CbFilterGet); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbFilterGet(struct soap *soap, struct __cb__CbFilterGet *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbFilterGet = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbFilterGet(struct soap *soap, const struct __cb__CbFilterGet *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbFilterGet(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbFilterGet(struct soap *soap, const char *tag, int id, const struct __cb__CbFilterGet *a, const char *type) +{ + soap_out_PointerTo_cb__CbFilterGet(soap, "cb:CbFilterGet", -1, &a->cb__CbFilterGet, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbFilterGet * SOAP_FMAC4 soap_get___cb__CbFilterGet(struct soap *soap, struct __cb__CbFilterGet *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbFilterGet(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbFilterGet * SOAP_FMAC4 soap_in___cb__CbFilterGet(struct soap *soap, const char *tag, struct __cb__CbFilterGet *a, const char *type) +{ + short soap_flag_cb__CbFilterGet = 1; + a = (struct __cb__CbFilterGet *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbFilterGet, sizeof(struct __cb__CbFilterGet), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbFilterGet(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbFilterGet && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbFilterGet(soap, "cb:CbFilterGet", &a->cb__CbFilterGet, "")) + { soap_flag_cb__CbFilterGet--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbFilterGet * SOAP_FMAC6 soap_new___cb__CbFilterGet(struct soap *soap, int n) +{ return soap_instantiate___cb__CbFilterGet(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbFilterGet(struct soap *soap, struct __cb__CbFilterGet *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbFilterGet * SOAP_FMAC4 soap_instantiate___cb__CbFilterGet(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbFilterGet(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbFilterGet, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbFilterGet; + if (size) + *size = sizeof(struct __cb__CbFilterGet); + } + else + { cp->ptr = (void*)new struct __cb__CbFilterGet[n]; + if (size) + *size = n * sizeof(struct __cb__CbFilterGet); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbFilterGet*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbFilterGet(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbFilterGet %p -> %p\n", q, p)); + *(struct __cb__CbFilterGet*)p = *(struct __cb__CbFilterGet*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbFilterCreate(struct soap *soap, const struct __cb__CbFilterCreate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbFilterCreate(soap, &a->cb__CbFilterCreate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbFilterCreate(struct soap *soap, struct __cb__CbFilterCreate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbFilterCreate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbFilterCreate(struct soap *soap, const struct __cb__CbFilterCreate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbFilterCreate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbFilterCreate(struct soap *soap, const char *tag, int id, const struct __cb__CbFilterCreate *a, const char *type) +{ + soap_out_PointerTo_cb__CbFilterCreate(soap, "cb:CbFilterCreate", -1, &a->cb__CbFilterCreate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbFilterCreate * SOAP_FMAC4 soap_get___cb__CbFilterCreate(struct soap *soap, struct __cb__CbFilterCreate *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbFilterCreate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbFilterCreate * SOAP_FMAC4 soap_in___cb__CbFilterCreate(struct soap *soap, const char *tag, struct __cb__CbFilterCreate *a, const char *type) +{ + short soap_flag_cb__CbFilterCreate = 1; + a = (struct __cb__CbFilterCreate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbFilterCreate, sizeof(struct __cb__CbFilterCreate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbFilterCreate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbFilterCreate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbFilterCreate(soap, "cb:CbFilterCreate", &a->cb__CbFilterCreate, "")) + { soap_flag_cb__CbFilterCreate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbFilterCreate * SOAP_FMAC6 soap_new___cb__CbFilterCreate(struct soap *soap, int n) +{ return soap_instantiate___cb__CbFilterCreate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbFilterCreate(struct soap *soap, struct __cb__CbFilterCreate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbFilterCreate * SOAP_FMAC4 soap_instantiate___cb__CbFilterCreate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbFilterCreate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbFilterCreate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbFilterCreate; + if (size) + *size = sizeof(struct __cb__CbFilterCreate); + } + else + { cp->ptr = (void*)new struct __cb__CbFilterCreate[n]; + if (size) + *size = n * sizeof(struct __cb__CbFilterCreate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbFilterCreate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbFilterCreate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbFilterCreate %p -> %p\n", q, p)); + *(struct __cb__CbFilterCreate*)p = *(struct __cb__CbFilterCreate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyGetActiveStatistics(struct soap *soap, const struct __cb__CbPolicyGetActiveStatistics *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbPolicyGetActiveStatistics(soap, &a->cb__CbPolicyGetActiveStatistics); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyGetActiveStatistics(struct soap *soap, struct __cb__CbPolicyGetActiveStatistics *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbPolicyGetActiveStatistics = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyGetActiveStatistics(struct soap *soap, const struct __cb__CbPolicyGetActiveStatistics *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbPolicyGetActiveStatistics(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyGetActiveStatistics(struct soap *soap, const char *tag, int id, const struct __cb__CbPolicyGetActiveStatistics *a, const char *type) +{ + soap_out_PointerTo_cb__CbPolicyGetActiveStatistics(soap, "cb:CbPolicyGetActiveStatistics", -1, &a->cb__CbPolicyGetActiveStatistics, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_get___cb__CbPolicyGetActiveStatistics(struct soap *soap, struct __cb__CbPolicyGetActiveStatistics *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbPolicyGetActiveStatistics(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_in___cb__CbPolicyGetActiveStatistics(struct soap *soap, const char *tag, struct __cb__CbPolicyGetActiveStatistics *a, const char *type) +{ + short soap_flag_cb__CbPolicyGetActiveStatistics = 1; + a = (struct __cb__CbPolicyGetActiveStatistics *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbPolicyGetActiveStatistics, sizeof(struct __cb__CbPolicyGetActiveStatistics), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbPolicyGetActiveStatistics(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbPolicyGetActiveStatistics && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbPolicyGetActiveStatistics(soap, "cb:CbPolicyGetActiveStatistics", &a->cb__CbPolicyGetActiveStatistics, "")) + { soap_flag_cb__CbPolicyGetActiveStatistics--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbPolicyGetActiveStatistics * SOAP_FMAC6 soap_new___cb__CbPolicyGetActiveStatistics(struct soap *soap, int n) +{ return soap_instantiate___cb__CbPolicyGetActiveStatistics(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyGetActiveStatistics(struct soap *soap, struct __cb__CbPolicyGetActiveStatistics *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbPolicyGetActiveStatistics * SOAP_FMAC4 soap_instantiate___cb__CbPolicyGetActiveStatistics(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbPolicyGetActiveStatistics(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbPolicyGetActiveStatistics, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbPolicyGetActiveStatistics; + if (size) + *size = sizeof(struct __cb__CbPolicyGetActiveStatistics); + } + else + { cp->ptr = (void*)new struct __cb__CbPolicyGetActiveStatistics[n]; + if (size) + *size = n * sizeof(struct __cb__CbPolicyGetActiveStatistics); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbPolicyGetActiveStatistics*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyGetActiveStatistics(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbPolicyGetActiveStatistics %p -> %p\n", q, p)); + *(struct __cb__CbPolicyGetActiveStatistics*)p = *(struct __cb__CbPolicyGetActiveStatistics*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyGetEnabled(struct soap *soap, const struct __cb__CbPolicyGetEnabled *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbPolicyGetEnabled(soap, &a->cb__CbPolicyGetEnabled); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyGetEnabled(struct soap *soap, struct __cb__CbPolicyGetEnabled *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbPolicyGetEnabled = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyGetEnabled(struct soap *soap, const struct __cb__CbPolicyGetEnabled *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbPolicyGetEnabled(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyGetEnabled(struct soap *soap, const char *tag, int id, const struct __cb__CbPolicyGetEnabled *a, const char *type) +{ + soap_out_PointerTo_cb__CbPolicyGetEnabled(soap, "cb:CbPolicyGetEnabled", -1, &a->cb__CbPolicyGetEnabled, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_get___cb__CbPolicyGetEnabled(struct soap *soap, struct __cb__CbPolicyGetEnabled *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbPolicyGetEnabled(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_in___cb__CbPolicyGetEnabled(struct soap *soap, const char *tag, struct __cb__CbPolicyGetEnabled *a, const char *type) +{ + short soap_flag_cb__CbPolicyGetEnabled = 1; + a = (struct __cb__CbPolicyGetEnabled *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbPolicyGetEnabled, sizeof(struct __cb__CbPolicyGetEnabled), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbPolicyGetEnabled(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbPolicyGetEnabled && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbPolicyGetEnabled(soap, "cb:CbPolicyGetEnabled", &a->cb__CbPolicyGetEnabled, "")) + { soap_flag_cb__CbPolicyGetEnabled--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbPolicyGetEnabled * SOAP_FMAC6 soap_new___cb__CbPolicyGetEnabled(struct soap *soap, int n) +{ return soap_instantiate___cb__CbPolicyGetEnabled(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyGetEnabled(struct soap *soap, struct __cb__CbPolicyGetEnabled *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbPolicyGetEnabled * SOAP_FMAC4 soap_instantiate___cb__CbPolicyGetEnabled(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbPolicyGetEnabled(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbPolicyGetEnabled, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbPolicyGetEnabled; + if (size) + *size = sizeof(struct __cb__CbPolicyGetEnabled); + } + else + { cp->ptr = (void*)new struct __cb__CbPolicyGetEnabled[n]; + if (size) + *size = n * sizeof(struct __cb__CbPolicyGetEnabled); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbPolicyGetEnabled*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyGetEnabled(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbPolicyGetEnabled %p -> %p\n", q, p)); + *(struct __cb__CbPolicyGetEnabled*)p = *(struct __cb__CbPolicyGetEnabled*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyDisable(struct soap *soap, const struct __cb__CbPolicyDisable *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbPolicyDisable(soap, &a->cb__CbPolicyDisable); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyDisable(struct soap *soap, struct __cb__CbPolicyDisable *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbPolicyDisable = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyDisable(struct soap *soap, const struct __cb__CbPolicyDisable *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbPolicyDisable(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyDisable(struct soap *soap, const char *tag, int id, const struct __cb__CbPolicyDisable *a, const char *type) +{ + soap_out_PointerTo_cb__CbPolicyDisable(soap, "cb:CbPolicyDisable", -1, &a->cb__CbPolicyDisable, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbPolicyDisable * SOAP_FMAC4 soap_get___cb__CbPolicyDisable(struct soap *soap, struct __cb__CbPolicyDisable *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbPolicyDisable(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbPolicyDisable * SOAP_FMAC4 soap_in___cb__CbPolicyDisable(struct soap *soap, const char *tag, struct __cb__CbPolicyDisable *a, const char *type) +{ + short soap_flag_cb__CbPolicyDisable = 1; + a = (struct __cb__CbPolicyDisable *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbPolicyDisable, sizeof(struct __cb__CbPolicyDisable), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbPolicyDisable(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbPolicyDisable && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbPolicyDisable(soap, "cb:CbPolicyDisable", &a->cb__CbPolicyDisable, "")) + { soap_flag_cb__CbPolicyDisable--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbPolicyDisable * SOAP_FMAC6 soap_new___cb__CbPolicyDisable(struct soap *soap, int n) +{ return soap_instantiate___cb__CbPolicyDisable(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyDisable(struct soap *soap, struct __cb__CbPolicyDisable *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbPolicyDisable * SOAP_FMAC4 soap_instantiate___cb__CbPolicyDisable(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbPolicyDisable(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbPolicyDisable, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbPolicyDisable; + if (size) + *size = sizeof(struct __cb__CbPolicyDisable); + } + else + { cp->ptr = (void*)new struct __cb__CbPolicyDisable[n]; + if (size) + *size = n * sizeof(struct __cb__CbPolicyDisable); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbPolicyDisable*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyDisable(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbPolicyDisable %p -> %p\n", q, p)); + *(struct __cb__CbPolicyDisable*)p = *(struct __cb__CbPolicyDisable*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyEnable(struct soap *soap, const struct __cb__CbPolicyEnable *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbPolicyEnable(soap, &a->cb__CbPolicyEnable); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyEnable(struct soap *soap, struct __cb__CbPolicyEnable *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbPolicyEnable = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyEnable(struct soap *soap, const struct __cb__CbPolicyEnable *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbPolicyEnable(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyEnable(struct soap *soap, const char *tag, int id, const struct __cb__CbPolicyEnable *a, const char *type) +{ + soap_out_PointerTo_cb__CbPolicyEnable(soap, "cb:CbPolicyEnable", -1, &a->cb__CbPolicyEnable, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbPolicyEnable * SOAP_FMAC4 soap_get___cb__CbPolicyEnable(struct soap *soap, struct __cb__CbPolicyEnable *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbPolicyEnable(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbPolicyEnable * SOAP_FMAC4 soap_in___cb__CbPolicyEnable(struct soap *soap, const char *tag, struct __cb__CbPolicyEnable *a, const char *type) +{ + short soap_flag_cb__CbPolicyEnable = 1; + a = (struct __cb__CbPolicyEnable *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbPolicyEnable, sizeof(struct __cb__CbPolicyEnable), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbPolicyEnable(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbPolicyEnable && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbPolicyEnable(soap, "cb:CbPolicyEnable", &a->cb__CbPolicyEnable, "")) + { soap_flag_cb__CbPolicyEnable--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbPolicyEnable * SOAP_FMAC6 soap_new___cb__CbPolicyEnable(struct soap *soap, int n) +{ return soap_instantiate___cb__CbPolicyEnable(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyEnable(struct soap *soap, struct __cb__CbPolicyEnable *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbPolicyEnable * SOAP_FMAC4 soap_instantiate___cb__CbPolicyEnable(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbPolicyEnable(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbPolicyEnable, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbPolicyEnable; + if (size) + *size = sizeof(struct __cb__CbPolicyEnable); + } + else + { cp->ptr = (void*)new struct __cb__CbPolicyEnable[n]; + if (size) + *size = n * sizeof(struct __cb__CbPolicyEnable); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbPolicyEnable*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyEnable(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbPolicyEnable %p -> %p\n", q, p)); + *(struct __cb__CbPolicyEnable*)p = *(struct __cb__CbPolicyEnable*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyEnumerate(struct soap *soap, const struct __cb__CbPolicyEnumerate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbPolicyEnumerate(soap, &a->cb__CbPolicyEnumerate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyEnumerate(struct soap *soap, struct __cb__CbPolicyEnumerate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbPolicyEnumerate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyEnumerate(struct soap *soap, const struct __cb__CbPolicyEnumerate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbPolicyEnumerate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyEnumerate(struct soap *soap, const char *tag, int id, const struct __cb__CbPolicyEnumerate *a, const char *type) +{ + soap_out_PointerTo_cb__CbPolicyEnumerate(soap, "cb:CbPolicyEnumerate", -1, &a->cb__CbPolicyEnumerate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbPolicyEnumerate * SOAP_FMAC4 soap_get___cb__CbPolicyEnumerate(struct soap *soap, struct __cb__CbPolicyEnumerate *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbPolicyEnumerate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbPolicyEnumerate * SOAP_FMAC4 soap_in___cb__CbPolicyEnumerate(struct soap *soap, const char *tag, struct __cb__CbPolicyEnumerate *a, const char *type) +{ + short soap_flag_cb__CbPolicyEnumerate = 1; + a = (struct __cb__CbPolicyEnumerate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbPolicyEnumerate, sizeof(struct __cb__CbPolicyEnumerate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbPolicyEnumerate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbPolicyEnumerate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbPolicyEnumerate(soap, "cb:CbPolicyEnumerate", &a->cb__CbPolicyEnumerate, "")) + { soap_flag_cb__CbPolicyEnumerate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbPolicyEnumerate * SOAP_FMAC6 soap_new___cb__CbPolicyEnumerate(struct soap *soap, int n) +{ return soap_instantiate___cb__CbPolicyEnumerate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyEnumerate(struct soap *soap, struct __cb__CbPolicyEnumerate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbPolicyEnumerate * SOAP_FMAC4 soap_instantiate___cb__CbPolicyEnumerate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbPolicyEnumerate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbPolicyEnumerate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbPolicyEnumerate; + if (size) + *size = sizeof(struct __cb__CbPolicyEnumerate); + } + else + { cp->ptr = (void*)new struct __cb__CbPolicyEnumerate[n]; + if (size) + *size = n * sizeof(struct __cb__CbPolicyEnumerate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbPolicyEnumerate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyEnumerate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbPolicyEnumerate %p -> %p\n", q, p)); + *(struct __cb__CbPolicyEnumerate*)p = *(struct __cb__CbPolicyEnumerate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyDelete(struct soap *soap, const struct __cb__CbPolicyDelete *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbPolicyDelete(soap, &a->cb__CbPolicyDelete); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyDelete(struct soap *soap, struct __cb__CbPolicyDelete *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbPolicyDelete = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyDelete(struct soap *soap, const struct __cb__CbPolicyDelete *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbPolicyDelete(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyDelete(struct soap *soap, const char *tag, int id, const struct __cb__CbPolicyDelete *a, const char *type) +{ + soap_out_PointerTo_cb__CbPolicyDelete(soap, "cb:CbPolicyDelete", -1, &a->cb__CbPolicyDelete, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbPolicyDelete * SOAP_FMAC4 soap_get___cb__CbPolicyDelete(struct soap *soap, struct __cb__CbPolicyDelete *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbPolicyDelete(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbPolicyDelete * SOAP_FMAC4 soap_in___cb__CbPolicyDelete(struct soap *soap, const char *tag, struct __cb__CbPolicyDelete *a, const char *type) +{ + short soap_flag_cb__CbPolicyDelete = 1; + a = (struct __cb__CbPolicyDelete *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbPolicyDelete, sizeof(struct __cb__CbPolicyDelete), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbPolicyDelete(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbPolicyDelete && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbPolicyDelete(soap, "cb:CbPolicyDelete", &a->cb__CbPolicyDelete, "")) + { soap_flag_cb__CbPolicyDelete--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbPolicyDelete * SOAP_FMAC6 soap_new___cb__CbPolicyDelete(struct soap *soap, int n) +{ return soap_instantiate___cb__CbPolicyDelete(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyDelete(struct soap *soap, struct __cb__CbPolicyDelete *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbPolicyDelete * SOAP_FMAC4 soap_instantiate___cb__CbPolicyDelete(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbPolicyDelete(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbPolicyDelete, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbPolicyDelete; + if (size) + *size = sizeof(struct __cb__CbPolicyDelete); + } + else + { cp->ptr = (void*)new struct __cb__CbPolicyDelete[n]; + if (size) + *size = n * sizeof(struct __cb__CbPolicyDelete); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbPolicyDelete*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyDelete(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbPolicyDelete %p -> %p\n", q, p)); + *(struct __cb__CbPolicyDelete*)p = *(struct __cb__CbPolicyDelete*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyGet(struct soap *soap, const struct __cb__CbPolicyGet *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbPolicyGet(soap, &a->cb__CbPolicyGet); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyGet(struct soap *soap, struct __cb__CbPolicyGet *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbPolicyGet = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyGet(struct soap *soap, const struct __cb__CbPolicyGet *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbPolicyGet(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyGet(struct soap *soap, const char *tag, int id, const struct __cb__CbPolicyGet *a, const char *type) +{ + soap_out_PointerTo_cb__CbPolicyGet(soap, "cb:CbPolicyGet", -1, &a->cb__CbPolicyGet, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbPolicyGet * SOAP_FMAC4 soap_get___cb__CbPolicyGet(struct soap *soap, struct __cb__CbPolicyGet *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbPolicyGet(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbPolicyGet * SOAP_FMAC4 soap_in___cb__CbPolicyGet(struct soap *soap, const char *tag, struct __cb__CbPolicyGet *a, const char *type) +{ + short soap_flag_cb__CbPolicyGet = 1; + a = (struct __cb__CbPolicyGet *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbPolicyGet, sizeof(struct __cb__CbPolicyGet), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbPolicyGet(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbPolicyGet && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbPolicyGet(soap, "cb:CbPolicyGet", &a->cb__CbPolicyGet, "")) + { soap_flag_cb__CbPolicyGet--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbPolicyGet * SOAP_FMAC6 soap_new___cb__CbPolicyGet(struct soap *soap, int n) +{ return soap_instantiate___cb__CbPolicyGet(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyGet(struct soap *soap, struct __cb__CbPolicyGet *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbPolicyGet * SOAP_FMAC4 soap_instantiate___cb__CbPolicyGet(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbPolicyGet(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbPolicyGet, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbPolicyGet; + if (size) + *size = sizeof(struct __cb__CbPolicyGet); + } + else + { cp->ptr = (void*)new struct __cb__CbPolicyGet[n]; + if (size) + *size = n * sizeof(struct __cb__CbPolicyGet); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbPolicyGet*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyGet(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbPolicyGet %p -> %p\n", q, p)); + *(struct __cb__CbPolicyGet*)p = *(struct __cb__CbPolicyGet*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___cb__CbPolicyCreate(struct soap *soap, const struct __cb__CbPolicyCreate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_cb__CbPolicyCreate(soap, &a->cb__CbPolicyCreate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___cb__CbPolicyCreate(struct soap *soap, struct __cb__CbPolicyCreate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->cb__CbPolicyCreate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___cb__CbPolicyCreate(struct soap *soap, const struct __cb__CbPolicyCreate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___cb__CbPolicyCreate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___cb__CbPolicyCreate(struct soap *soap, const char *tag, int id, const struct __cb__CbPolicyCreate *a, const char *type) +{ + soap_out_PointerTo_cb__CbPolicyCreate(soap, "cb:CbPolicyCreate", -1, &a->cb__CbPolicyCreate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __cb__CbPolicyCreate * SOAP_FMAC4 soap_get___cb__CbPolicyCreate(struct soap *soap, struct __cb__CbPolicyCreate *p, const char *tag, const char *type) +{ + if ((p = soap_in___cb__CbPolicyCreate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __cb__CbPolicyCreate * SOAP_FMAC4 soap_in___cb__CbPolicyCreate(struct soap *soap, const char *tag, struct __cb__CbPolicyCreate *a, const char *type) +{ + short soap_flag_cb__CbPolicyCreate = 1; + a = (struct __cb__CbPolicyCreate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___cb__CbPolicyCreate, sizeof(struct __cb__CbPolicyCreate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___cb__CbPolicyCreate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_cb__CbPolicyCreate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_cb__CbPolicyCreate(soap, "cb:CbPolicyCreate", &a->cb__CbPolicyCreate, "")) + { soap_flag_cb__CbPolicyCreate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __cb__CbPolicyCreate * SOAP_FMAC6 soap_new___cb__CbPolicyCreate(struct soap *soap, int n) +{ return soap_instantiate___cb__CbPolicyCreate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___cb__CbPolicyCreate(struct soap *soap, struct __cb__CbPolicyCreate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __cb__CbPolicyCreate * SOAP_FMAC4 soap_instantiate___cb__CbPolicyCreate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___cb__CbPolicyCreate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___cb__CbPolicyCreate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __cb__CbPolicyCreate; + if (size) + *size = sizeof(struct __cb__CbPolicyCreate); + } + else + { cp->ptr = (void*)new struct __cb__CbPolicyCreate[n]; + if (size) + *size = n * sizeof(struct __cb__CbPolicyCreate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __cb__CbPolicyCreate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___cb__CbPolicyCreate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __cb__CbPolicyCreate %p -> %p\n", q, p)); + *(struct __cb__CbPolicyCreate*)p = *(struct __cb__CbPolicyCreate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const struct __apr__ConsoleWatchdogQueryCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apr__ConsoleWatchdogQueryCapabilities(soap, &a->apr__ConsoleWatchdogQueryCapabilities); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, struct __apr__ConsoleWatchdogQueryCapabilities *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apr__ConsoleWatchdogQueryCapabilities = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const struct __apr__ConsoleWatchdogQueryCapabilities *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apr__ConsoleWatchdogQueryCapabilities(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const char *tag, int id, const struct __apr__ConsoleWatchdogQueryCapabilities *a, const char *type) +{ + soap_out_PointerTo_apr__ConsoleWatchdogQueryCapabilities(soap, "apr:ConsoleWatchdogQueryCapabilities", -1, &a->apr__ConsoleWatchdogQueryCapabilities, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, struct __apr__ConsoleWatchdogQueryCapabilities *p, const char *tag, const char *type) +{ + if ((p = soap_in___apr__ConsoleWatchdogQueryCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const char *tag, struct __apr__ConsoleWatchdogQueryCapabilities *a, const char *type) +{ + short soap_flag_apr__ConsoleWatchdogQueryCapabilities = 1; + a = (struct __apr__ConsoleWatchdogQueryCapabilities *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apr__ConsoleWatchdogQueryCapabilities, sizeof(struct __apr__ConsoleWatchdogQueryCapabilities), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apr__ConsoleWatchdogQueryCapabilities(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apr__ConsoleWatchdogQueryCapabilities && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apr__ConsoleWatchdogQueryCapabilities(soap, "apr:ConsoleWatchdogQueryCapabilities", &a->apr__ConsoleWatchdogQueryCapabilities, "")) + { soap_flag_apr__ConsoleWatchdogQueryCapabilities--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, int n) +{ return soap_instantiate___apr__ConsoleWatchdogQueryCapabilities(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, struct __apr__ConsoleWatchdogQueryCapabilities *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogQueryCapabilities * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apr__ConsoleWatchdogQueryCapabilities(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apr__ConsoleWatchdogQueryCapabilities, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogQueryCapabilities; + if (size) + *size = sizeof(struct __apr__ConsoleWatchdogQueryCapabilities); + } + else + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogQueryCapabilities[n]; + if (size) + *size = n * sizeof(struct __apr__ConsoleWatchdogQueryCapabilities); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apr__ConsoleWatchdogQueryCapabilities*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apr__ConsoleWatchdogQueryCapabilities %p -> %p\n", q, p)); + *(struct __apr__ConsoleWatchdogQueryCapabilities*)p = *(struct __apr__ConsoleWatchdogQueryCapabilities*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const struct __apr__ConsoleWatchdogGetCbPolicy *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apr__ConsoleWatchdogGetCbPolicy(soap, &a->apr__ConsoleWatchdogGetCbPolicy); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, struct __apr__ConsoleWatchdogGetCbPolicy *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apr__ConsoleWatchdogGetCbPolicy = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const struct __apr__ConsoleWatchdogGetCbPolicy *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apr__ConsoleWatchdogGetCbPolicy(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const char *tag, int id, const struct __apr__ConsoleWatchdogGetCbPolicy *a, const char *type) +{ + soap_out_PointerTo_apr__ConsoleWatchdogGetCbPolicy(soap, "apr:ConsoleWatchdogGetCbPolicy", -1, &a->apr__ConsoleWatchdogGetCbPolicy, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, struct __apr__ConsoleWatchdogGetCbPolicy *p, const char *tag, const char *type) +{ + if ((p = soap_in___apr__ConsoleWatchdogGetCbPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const char *tag, struct __apr__ConsoleWatchdogGetCbPolicy *a, const char *type) +{ + short soap_flag_apr__ConsoleWatchdogGetCbPolicy = 1; + a = (struct __apr__ConsoleWatchdogGetCbPolicy *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apr__ConsoleWatchdogGetCbPolicy, sizeof(struct __apr__ConsoleWatchdogGetCbPolicy), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apr__ConsoleWatchdogGetCbPolicy(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apr__ConsoleWatchdogGetCbPolicy && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apr__ConsoleWatchdogGetCbPolicy(soap, "apr:ConsoleWatchdogGetCbPolicy", &a->apr__ConsoleWatchdogGetCbPolicy, "")) + { soap_flag_apr__ConsoleWatchdogGetCbPolicy--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, int n) +{ return soap_instantiate___apr__ConsoleWatchdogGetCbPolicy(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, struct __apr__ConsoleWatchdogGetCbPolicy *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetCbPolicy * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apr__ConsoleWatchdogGetCbPolicy(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apr__ConsoleWatchdogGetCbPolicy, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogGetCbPolicy; + if (size) + *size = sizeof(struct __apr__ConsoleWatchdogGetCbPolicy); + } + else + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogGetCbPolicy[n]; + if (size) + *size = n * sizeof(struct __apr__ConsoleWatchdogGetCbPolicy); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apr__ConsoleWatchdogGetCbPolicy*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apr__ConsoleWatchdogGetCbPolicy %p -> %p\n", q, p)); + *(struct __apr__ConsoleWatchdogGetCbPolicy*)p = *(struct __apr__ConsoleWatchdogGetCbPolicy*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const struct __apr__ConsoleWatchdogSetCbPolicy *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apr__ConsoleWatchdogSetCbPolicy(soap, &a->apr__ConsoleWatchdogSetCbPolicy); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, struct __apr__ConsoleWatchdogSetCbPolicy *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apr__ConsoleWatchdogSetCbPolicy = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const struct __apr__ConsoleWatchdogSetCbPolicy *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apr__ConsoleWatchdogSetCbPolicy(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const char *tag, int id, const struct __apr__ConsoleWatchdogSetCbPolicy *a, const char *type) +{ + soap_out_PointerTo_apr__ConsoleWatchdogSetCbPolicy(soap, "apr:ConsoleWatchdogSetCbPolicy", -1, &a->apr__ConsoleWatchdogSetCbPolicy, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, struct __apr__ConsoleWatchdogSetCbPolicy *p, const char *tag, const char *type) +{ + if ((p = soap_in___apr__ConsoleWatchdogSetCbPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const char *tag, struct __apr__ConsoleWatchdogSetCbPolicy *a, const char *type) +{ + short soap_flag_apr__ConsoleWatchdogSetCbPolicy = 1; + a = (struct __apr__ConsoleWatchdogSetCbPolicy *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apr__ConsoleWatchdogSetCbPolicy, sizeof(struct __apr__ConsoleWatchdogSetCbPolicy), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apr__ConsoleWatchdogSetCbPolicy(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apr__ConsoleWatchdogSetCbPolicy && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apr__ConsoleWatchdogSetCbPolicy(soap, "apr:ConsoleWatchdogSetCbPolicy", &a->apr__ConsoleWatchdogSetCbPolicy, "")) + { soap_flag_apr__ConsoleWatchdogSetCbPolicy--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, int n) +{ return soap_instantiate___apr__ConsoleWatchdogSetCbPolicy(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, struct __apr__ConsoleWatchdogSetCbPolicy *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetCbPolicy * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apr__ConsoleWatchdogSetCbPolicy(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apr__ConsoleWatchdogSetCbPolicy, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogSetCbPolicy; + if (size) + *size = sizeof(struct __apr__ConsoleWatchdogSetCbPolicy); + } + else + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogSetCbPolicy[n]; + if (size) + *size = n * sizeof(struct __apr__ConsoleWatchdogSetCbPolicy); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apr__ConsoleWatchdogSetCbPolicy*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apr__ConsoleWatchdogSetCbPolicy %p -> %p\n", q, p)); + *(struct __apr__ConsoleWatchdogSetCbPolicy*)p = *(struct __apr__ConsoleWatchdogSetCbPolicy*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogGetActions(struct soap *soap, const struct __apr__ConsoleWatchdogGetActions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apr__ConsoleWatchdogGetActions(soap, &a->apr__ConsoleWatchdogGetActions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogGetActions(struct soap *soap, struct __apr__ConsoleWatchdogGetActions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apr__ConsoleWatchdogGetActions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogGetActions(struct soap *soap, const struct __apr__ConsoleWatchdogGetActions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apr__ConsoleWatchdogGetActions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogGetActions(struct soap *soap, const char *tag, int id, const struct __apr__ConsoleWatchdogGetActions *a, const char *type) +{ + soap_out_PointerTo_apr__ConsoleWatchdogGetActions(soap, "apr:ConsoleWatchdogGetActions", -1, &a->apr__ConsoleWatchdogGetActions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogGetActions(struct soap *soap, struct __apr__ConsoleWatchdogGetActions *p, const char *tag, const char *type) +{ + if ((p = soap_in___apr__ConsoleWatchdogGetActions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogGetActions(struct soap *soap, const char *tag, struct __apr__ConsoleWatchdogGetActions *a, const char *type) +{ + short soap_flag_apr__ConsoleWatchdogGetActions = 1; + a = (struct __apr__ConsoleWatchdogGetActions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apr__ConsoleWatchdogGetActions, sizeof(struct __apr__ConsoleWatchdogGetActions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apr__ConsoleWatchdogGetActions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apr__ConsoleWatchdogGetActions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apr__ConsoleWatchdogGetActions(soap, "apr:ConsoleWatchdogGetActions", &a->apr__ConsoleWatchdogGetActions, "")) + { soap_flag_apr__ConsoleWatchdogGetActions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apr__ConsoleWatchdogGetActions * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogGetActions(struct soap *soap, int n) +{ return soap_instantiate___apr__ConsoleWatchdogGetActions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogGetActions(struct soap *soap, struct __apr__ConsoleWatchdogGetActions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogGetActions * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogGetActions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apr__ConsoleWatchdogGetActions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apr__ConsoleWatchdogGetActions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogGetActions; + if (size) + *size = sizeof(struct __apr__ConsoleWatchdogGetActions); + } + else + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogGetActions[n]; + if (size) + *size = n * sizeof(struct __apr__ConsoleWatchdogGetActions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apr__ConsoleWatchdogGetActions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogGetActions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apr__ConsoleWatchdogGetActions %p -> %p\n", q, p)); + *(struct __apr__ConsoleWatchdogGetActions*)p = *(struct __apr__ConsoleWatchdogGetActions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogSetActions(struct soap *soap, const struct __apr__ConsoleWatchdogSetActions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apr__ConsoleWatchdogSetActions(soap, &a->apr__ConsoleWatchdogSetActions); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogSetActions(struct soap *soap, struct __apr__ConsoleWatchdogSetActions *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apr__ConsoleWatchdogSetActions = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogSetActions(struct soap *soap, const struct __apr__ConsoleWatchdogSetActions *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apr__ConsoleWatchdogSetActions(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogSetActions(struct soap *soap, const char *tag, int id, const struct __apr__ConsoleWatchdogSetActions *a, const char *type) +{ + soap_out_PointerTo_apr__ConsoleWatchdogSetActions(soap, "apr:ConsoleWatchdogSetActions", -1, &a->apr__ConsoleWatchdogSetActions, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogSetActions(struct soap *soap, struct __apr__ConsoleWatchdogSetActions *p, const char *tag, const char *type) +{ + if ((p = soap_in___apr__ConsoleWatchdogSetActions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogSetActions(struct soap *soap, const char *tag, struct __apr__ConsoleWatchdogSetActions *a, const char *type) +{ + short soap_flag_apr__ConsoleWatchdogSetActions = 1; + a = (struct __apr__ConsoleWatchdogSetActions *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apr__ConsoleWatchdogSetActions, sizeof(struct __apr__ConsoleWatchdogSetActions), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apr__ConsoleWatchdogSetActions(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apr__ConsoleWatchdogSetActions && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apr__ConsoleWatchdogSetActions(soap, "apr:ConsoleWatchdogSetActions", &a->apr__ConsoleWatchdogSetActions, "")) + { soap_flag_apr__ConsoleWatchdogSetActions--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apr__ConsoleWatchdogSetActions * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogSetActions(struct soap *soap, int n) +{ return soap_instantiate___apr__ConsoleWatchdogSetActions(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogSetActions(struct soap *soap, struct __apr__ConsoleWatchdogSetActions *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogSetActions * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogSetActions(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apr__ConsoleWatchdogSetActions(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apr__ConsoleWatchdogSetActions, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogSetActions; + if (size) + *size = sizeof(struct __apr__ConsoleWatchdogSetActions); + } + else + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogSetActions[n]; + if (size) + *size = n * sizeof(struct __apr__ConsoleWatchdogSetActions); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apr__ConsoleWatchdogSetActions*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogSetActions(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apr__ConsoleWatchdogSetActions %p -> %p\n", q, p)); + *(struct __apr__ConsoleWatchdogSetActions*)p = *(struct __apr__ConsoleWatchdogSetActions*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogEnumerate(struct soap *soap, const struct __apr__ConsoleWatchdogEnumerate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apr__ConsoleWatchdogEnumerate(soap, &a->apr__ConsoleWatchdogEnumerate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogEnumerate(struct soap *soap, struct __apr__ConsoleWatchdogEnumerate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apr__ConsoleWatchdogEnumerate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogEnumerate(struct soap *soap, const struct __apr__ConsoleWatchdogEnumerate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apr__ConsoleWatchdogEnumerate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogEnumerate(struct soap *soap, const char *tag, int id, const struct __apr__ConsoleWatchdogEnumerate *a, const char *type) +{ + soap_out_PointerTo_apr__ConsoleWatchdogEnumerate(soap, "apr:ConsoleWatchdogEnumerate", -1, &a->apr__ConsoleWatchdogEnumerate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogEnumerate(struct soap *soap, struct __apr__ConsoleWatchdogEnumerate *p, const char *tag, const char *type) +{ + if ((p = soap_in___apr__ConsoleWatchdogEnumerate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogEnumerate(struct soap *soap, const char *tag, struct __apr__ConsoleWatchdogEnumerate *a, const char *type) +{ + short soap_flag_apr__ConsoleWatchdogEnumerate = 1; + a = (struct __apr__ConsoleWatchdogEnumerate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apr__ConsoleWatchdogEnumerate, sizeof(struct __apr__ConsoleWatchdogEnumerate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apr__ConsoleWatchdogEnumerate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apr__ConsoleWatchdogEnumerate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apr__ConsoleWatchdogEnumerate(soap, "apr:ConsoleWatchdogEnumerate", &a->apr__ConsoleWatchdogEnumerate, "")) + { soap_flag_apr__ConsoleWatchdogEnumerate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apr__ConsoleWatchdogEnumerate * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogEnumerate(struct soap *soap, int n) +{ return soap_instantiate___apr__ConsoleWatchdogEnumerate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogEnumerate(struct soap *soap, struct __apr__ConsoleWatchdogEnumerate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogEnumerate * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogEnumerate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apr__ConsoleWatchdogEnumerate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apr__ConsoleWatchdogEnumerate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogEnumerate; + if (size) + *size = sizeof(struct __apr__ConsoleWatchdogEnumerate); + } + else + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogEnumerate[n]; + if (size) + *size = n * sizeof(struct __apr__ConsoleWatchdogEnumerate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apr__ConsoleWatchdogEnumerate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogEnumerate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apr__ConsoleWatchdogEnumerate %p -> %p\n", q, p)); + *(struct __apr__ConsoleWatchdogEnumerate*)p = *(struct __apr__ConsoleWatchdogEnumerate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogDelete(struct soap *soap, const struct __apr__ConsoleWatchdogDelete *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apr__ConsoleWatchdogDelete(soap, &a->apr__ConsoleWatchdogDelete); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogDelete(struct soap *soap, struct __apr__ConsoleWatchdogDelete *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apr__ConsoleWatchdogDelete = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogDelete(struct soap *soap, const struct __apr__ConsoleWatchdogDelete *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apr__ConsoleWatchdogDelete(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogDelete(struct soap *soap, const char *tag, int id, const struct __apr__ConsoleWatchdogDelete *a, const char *type) +{ + soap_out_PointerTo_apr__ConsoleWatchdogDelete(soap, "apr:ConsoleWatchdogDelete", -1, &a->apr__ConsoleWatchdogDelete, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogDelete(struct soap *soap, struct __apr__ConsoleWatchdogDelete *p, const char *tag, const char *type) +{ + if ((p = soap_in___apr__ConsoleWatchdogDelete(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogDelete(struct soap *soap, const char *tag, struct __apr__ConsoleWatchdogDelete *a, const char *type) +{ + short soap_flag_apr__ConsoleWatchdogDelete = 1; + a = (struct __apr__ConsoleWatchdogDelete *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apr__ConsoleWatchdogDelete, sizeof(struct __apr__ConsoleWatchdogDelete), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apr__ConsoleWatchdogDelete(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apr__ConsoleWatchdogDelete && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apr__ConsoleWatchdogDelete(soap, "apr:ConsoleWatchdogDelete", &a->apr__ConsoleWatchdogDelete, "")) + { soap_flag_apr__ConsoleWatchdogDelete--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apr__ConsoleWatchdogDelete * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogDelete(struct soap *soap, int n) +{ return soap_instantiate___apr__ConsoleWatchdogDelete(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogDelete(struct soap *soap, struct __apr__ConsoleWatchdogDelete *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogDelete * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogDelete(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apr__ConsoleWatchdogDelete(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apr__ConsoleWatchdogDelete, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogDelete; + if (size) + *size = sizeof(struct __apr__ConsoleWatchdogDelete); + } + else + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogDelete[n]; + if (size) + *size = n * sizeof(struct __apr__ConsoleWatchdogDelete); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apr__ConsoleWatchdogDelete*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogDelete(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apr__ConsoleWatchdogDelete %p -> %p\n", q, p)); + *(struct __apr__ConsoleWatchdogDelete*)p = *(struct __apr__ConsoleWatchdogDelete*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apr__ConsoleWatchdogCreate(struct soap *soap, const struct __apr__ConsoleWatchdogCreate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apr__ConsoleWatchdogCreate(soap, &a->apr__ConsoleWatchdogCreate); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apr__ConsoleWatchdogCreate(struct soap *soap, struct __apr__ConsoleWatchdogCreate *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apr__ConsoleWatchdogCreate = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apr__ConsoleWatchdogCreate(struct soap *soap, const struct __apr__ConsoleWatchdogCreate *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apr__ConsoleWatchdogCreate(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apr__ConsoleWatchdogCreate(struct soap *soap, const char *tag, int id, const struct __apr__ConsoleWatchdogCreate *a, const char *type) +{ + soap_out_PointerTo_apr__ConsoleWatchdogCreate(soap, "apr:ConsoleWatchdogCreate", -1, &a->apr__ConsoleWatchdogCreate, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_get___apr__ConsoleWatchdogCreate(struct soap *soap, struct __apr__ConsoleWatchdogCreate *p, const char *tag, const char *type) +{ + if ((p = soap_in___apr__ConsoleWatchdogCreate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_in___apr__ConsoleWatchdogCreate(struct soap *soap, const char *tag, struct __apr__ConsoleWatchdogCreate *a, const char *type) +{ + short soap_flag_apr__ConsoleWatchdogCreate = 1; + a = (struct __apr__ConsoleWatchdogCreate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apr__ConsoleWatchdogCreate, sizeof(struct __apr__ConsoleWatchdogCreate), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apr__ConsoleWatchdogCreate(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apr__ConsoleWatchdogCreate && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apr__ConsoleWatchdogCreate(soap, "apr:ConsoleWatchdogCreate", &a->apr__ConsoleWatchdogCreate, "")) + { soap_flag_apr__ConsoleWatchdogCreate--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apr__ConsoleWatchdogCreate * SOAP_FMAC6 soap_new___apr__ConsoleWatchdogCreate(struct soap *soap, int n) +{ return soap_instantiate___apr__ConsoleWatchdogCreate(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apr__ConsoleWatchdogCreate(struct soap *soap, struct __apr__ConsoleWatchdogCreate *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apr__ConsoleWatchdogCreate * SOAP_FMAC4 soap_instantiate___apr__ConsoleWatchdogCreate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apr__ConsoleWatchdogCreate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apr__ConsoleWatchdogCreate, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogCreate; + if (size) + *size = sizeof(struct __apr__ConsoleWatchdogCreate); + } + else + { cp->ptr = (void*)new struct __apr__ConsoleWatchdogCreate[n]; + if (size) + *size = n * sizeof(struct __apr__ConsoleWatchdogCreate); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apr__ConsoleWatchdogCreate*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apr__ConsoleWatchdogCreate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apr__ConsoleWatchdogCreate %p -> %p\n", q, p)); + *(struct __apr__ConsoleWatchdogCreate*)p = *(struct __apr__ConsoleWatchdogCreate*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apl__AgentWatchdogRegister(struct soap *soap, const struct __apl__AgentWatchdogRegister *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apl__AgentWatchdogRegister(soap, &a->apl__AgentWatchdogRegister); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apl__AgentWatchdogRegister(struct soap *soap, struct __apl__AgentWatchdogRegister *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apl__AgentWatchdogRegister = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apl__AgentWatchdogRegister(struct soap *soap, const struct __apl__AgentWatchdogRegister *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apl__AgentWatchdogRegister(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apl__AgentWatchdogRegister(struct soap *soap, const char *tag, int id, const struct __apl__AgentWatchdogRegister *a, const char *type) +{ + soap_out_PointerTo_apl__AgentWatchdogRegister(soap, "apl:AgentWatchdogRegister", -1, &a->apl__AgentWatchdogRegister, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apl__AgentWatchdogRegister * SOAP_FMAC4 soap_get___apl__AgentWatchdogRegister(struct soap *soap, struct __apl__AgentWatchdogRegister *p, const char *tag, const char *type) +{ + if ((p = soap_in___apl__AgentWatchdogRegister(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apl__AgentWatchdogRegister * SOAP_FMAC4 soap_in___apl__AgentWatchdogRegister(struct soap *soap, const char *tag, struct __apl__AgentWatchdogRegister *a, const char *type) +{ + short soap_flag_apl__AgentWatchdogRegister = 1; + a = (struct __apl__AgentWatchdogRegister *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apl__AgentWatchdogRegister, sizeof(struct __apl__AgentWatchdogRegister), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apl__AgentWatchdogRegister(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apl__AgentWatchdogRegister && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apl__AgentWatchdogRegister(soap, "apl:AgentWatchdogRegister", &a->apl__AgentWatchdogRegister, "")) + { soap_flag_apl__AgentWatchdogRegister--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apl__AgentWatchdogRegister * SOAP_FMAC6 soap_new___apl__AgentWatchdogRegister(struct soap *soap, int n) +{ return soap_instantiate___apl__AgentWatchdogRegister(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apl__AgentWatchdogRegister(struct soap *soap, struct __apl__AgentWatchdogRegister *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apl__AgentWatchdogRegister * SOAP_FMAC4 soap_instantiate___apl__AgentWatchdogRegister(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apl__AgentWatchdogRegister(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apl__AgentWatchdogRegister, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apl__AgentWatchdogRegister; + if (size) + *size = sizeof(struct __apl__AgentWatchdogRegister); + } + else + { cp->ptr = (void*)new struct __apl__AgentWatchdogRegister[n]; + if (size) + *size = n * sizeof(struct __apl__AgentWatchdogRegister); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apl__AgentWatchdogRegister*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apl__AgentWatchdogRegister(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apl__AgentWatchdogRegister %p -> %p\n", q, p)); + *(struct __apl__AgentWatchdogRegister*)p = *(struct __apl__AgentWatchdogRegister*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apl__AgentWatchdogHeartbeat(struct soap *soap, const struct __apl__AgentWatchdogHeartbeat *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apl__AgentWatchdogHeartbeat(soap, &a->apl__AgentWatchdogHeartbeat); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apl__AgentWatchdogHeartbeat(struct soap *soap, struct __apl__AgentWatchdogHeartbeat *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apl__AgentWatchdogHeartbeat = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apl__AgentWatchdogHeartbeat(struct soap *soap, const struct __apl__AgentWatchdogHeartbeat *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apl__AgentWatchdogHeartbeat(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apl__AgentWatchdogHeartbeat(struct soap *soap, const char *tag, int id, const struct __apl__AgentWatchdogHeartbeat *a, const char *type) +{ + soap_out_PointerTo_apl__AgentWatchdogHeartbeat(soap, "apl:AgentWatchdogHeartbeat", -1, &a->apl__AgentWatchdogHeartbeat, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_get___apl__AgentWatchdogHeartbeat(struct soap *soap, struct __apl__AgentWatchdogHeartbeat *p, const char *tag, const char *type) +{ + if ((p = soap_in___apl__AgentWatchdogHeartbeat(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_in___apl__AgentWatchdogHeartbeat(struct soap *soap, const char *tag, struct __apl__AgentWatchdogHeartbeat *a, const char *type) +{ + short soap_flag_apl__AgentWatchdogHeartbeat = 1; + a = (struct __apl__AgentWatchdogHeartbeat *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apl__AgentWatchdogHeartbeat, sizeof(struct __apl__AgentWatchdogHeartbeat), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apl__AgentWatchdogHeartbeat(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apl__AgentWatchdogHeartbeat && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apl__AgentWatchdogHeartbeat(soap, "apl:AgentWatchdogHeartbeat", &a->apl__AgentWatchdogHeartbeat, "")) + { soap_flag_apl__AgentWatchdogHeartbeat--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apl__AgentWatchdogHeartbeat * SOAP_FMAC6 soap_new___apl__AgentWatchdogHeartbeat(struct soap *soap, int n) +{ return soap_instantiate___apl__AgentWatchdogHeartbeat(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apl__AgentWatchdogHeartbeat(struct soap *soap, struct __apl__AgentWatchdogHeartbeat *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apl__AgentWatchdogHeartbeat * SOAP_FMAC4 soap_instantiate___apl__AgentWatchdogHeartbeat(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apl__AgentWatchdogHeartbeat(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apl__AgentWatchdogHeartbeat, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apl__AgentWatchdogHeartbeat; + if (size) + *size = sizeof(struct __apl__AgentWatchdogHeartbeat); + } + else + { cp->ptr = (void*)new struct __apl__AgentWatchdogHeartbeat[n]; + if (size) + *size = n * sizeof(struct __apl__AgentWatchdogHeartbeat); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apl__AgentWatchdogHeartbeat*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apl__AgentWatchdogHeartbeat(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apl__AgentWatchdogHeartbeat %p -> %p\n", q, p)); + *(struct __apl__AgentWatchdogHeartbeat*)p = *(struct __apl__AgentWatchdogHeartbeat*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize___apl__AgentWatchdogShutdown(struct soap *soap, const struct __apl__AgentWatchdogShutdown *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + soap_serialize_PointerTo_apl__AgentWatchdogShutdown(soap, &a->apl__AgentWatchdogShutdown); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default___apl__AgentWatchdogShutdown(struct soap *soap, struct __apl__AgentWatchdogShutdown *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + a->apl__AgentWatchdogShutdown = NULL; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put___apl__AgentWatchdogShutdown(struct soap *soap, const struct __apl__AgentWatchdogShutdown *a, const char *tag, const char *type) +{ + register int id = 0; + if (soap_out___apl__AgentWatchdogShutdown(soap, tag, id, a, type)) + return soap->error; + return SOAP_OK; +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out___apl__AgentWatchdogShutdown(struct soap *soap, const char *tag, int id, const struct __apl__AgentWatchdogShutdown *a, const char *type) +{ + soap_out_PointerTo_apl__AgentWatchdogShutdown(soap, "apl:AgentWatchdogShutdown", -1, &a->apl__AgentWatchdogShutdown, ""); + return SOAP_OK; +} + +SOAP_FMAC3 struct __apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_get___apl__AgentWatchdogShutdown(struct soap *soap, struct __apl__AgentWatchdogShutdown *p, const char *tag, const char *type) +{ + if ((p = soap_in___apl__AgentWatchdogShutdown(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct __apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_in___apl__AgentWatchdogShutdown(struct soap *soap, const char *tag, struct __apl__AgentWatchdogShutdown *a, const char *type) +{ + short soap_flag_apl__AgentWatchdogShutdown = 1; + a = (struct __apl__AgentWatchdogShutdown *)soap_id_enter(soap, soap->id, a, SOAP_TYPE___apl__AgentWatchdogShutdown, sizeof(struct __apl__AgentWatchdogShutdown), 0, NULL, NULL, NULL); + if (!a) + return NULL; + soap_default___apl__AgentWatchdogShutdown(soap, a); + for (;;) + { soap->error = SOAP_TAG_MISMATCH; + if (soap_flag_apl__AgentWatchdogShutdown && soap->error == SOAP_TAG_MISMATCH) + if (soap_in_PointerTo_apl__AgentWatchdogShutdown(soap, "apl:AgentWatchdogShutdown", &a->apl__AgentWatchdogShutdown, "")) + { soap_flag_apl__AgentWatchdogShutdown--; + continue; + } + if (soap->error == SOAP_TAG_MISMATCH) + soap->error = soap_ignore_element(soap); + if (soap->error == SOAP_NO_TAG) + break; + if (soap->error) + return NULL; + } + return a; +} + +SOAP_FMAC5 struct __apl__AgentWatchdogShutdown * SOAP_FMAC6 soap_new___apl__AgentWatchdogShutdown(struct soap *soap, int n) +{ return soap_instantiate___apl__AgentWatchdogShutdown(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete___apl__AgentWatchdogShutdown(struct soap *soap, struct __apl__AgentWatchdogShutdown *p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 struct __apl__AgentWatchdogShutdown * SOAP_FMAC4 soap_instantiate___apl__AgentWatchdogShutdown(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate___apl__AgentWatchdogShutdown(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE___apl__AgentWatchdogShutdown, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new struct __apl__AgentWatchdogShutdown; + if (size) + *size = sizeof(struct __apl__AgentWatchdogShutdown); + } + else + { cp->ptr = (void*)new struct __apl__AgentWatchdogShutdown[n]; + if (size) + *size = n * sizeof(struct __apl__AgentWatchdogShutdown); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (struct __apl__AgentWatchdogShutdown*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy___apl__AgentWatchdogShutdown(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct __apl__AgentWatchdogShutdown %p -> %p\n", q, p)); + *(struct __apl__AgentWatchdogShutdown*)p = *(struct __apl__AgentWatchdogShutdown*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_ProfileSecuritySettingsType(struct soap *soap, int choice, const union _wcxs__union_ProfileSecuritySettingsType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__wcxs__union_ProfileSecuritySettingsType_WPA: + soap_serialize_PointerTowcxs__ProfileSecuritySettingWPAType(soap, &a->WPA); + break; + case SOAP_UNION__wcxs__union_ProfileSecuritySettingsType_RSN: + soap_serialize_PointerTowcxs__ProfileSecuritySettingRSNType(soap, &a->RSN); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_ProfileSecuritySettingsType(struct soap *soap, int choice, const union _wcxs__union_ProfileSecuritySettingsType *a) +{ + switch (choice) + { + case SOAP_UNION__wcxs__union_ProfileSecuritySettingsType_WPA: + return soap_out_PointerTowcxs__ProfileSecuritySettingWPAType(soap, "wcxs:WPA", -1, &a->WPA, ""); + case SOAP_UNION__wcxs__union_ProfileSecuritySettingsType_RSN: + return soap_out_PointerTowcxs__ProfileSecuritySettingRSNType(soap, "wcxs:RSN", -1, &a->RSN, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _wcxs__union_ProfileSecuritySettingsType * SOAP_FMAC4 soap_in__wcxs__union_ProfileSecuritySettingsType(struct soap *soap, int *choice, union _wcxs__union_ProfileSecuritySettingsType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->WPA = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__ProfileSecuritySettingWPAType(soap, "wcxs:WPA", &a->WPA, "wcxs:ProfileSecuritySettingWPAType")) + { *choice = SOAP_UNION__wcxs__union_ProfileSecuritySettingsType_WPA; + return a; + } + a->RSN = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__ProfileSecuritySettingRSNType(soap, "wcxs:RSN", &a->RSN, "wcxs:ProfileSecuritySettingRSNType")) + { *choice = SOAP_UNION__wcxs__union_ProfileSecuritySettingsType_RSN; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_ProfileSecuritySettingRSNType(struct soap *soap, int choice, const union _wcxs__union_ProfileSecuritySettingRSNType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__wcxs__union_ProfileSecuritySettingRSNType_DataEncryptionTKIP: + soap_serialize_PointerTowcxs__DataEncryptionTKIPType(soap, &a->DataEncryptionTKIP); + break; + case SOAP_UNION__wcxs__union_ProfileSecuritySettingRSNType_DataEncryptionCCMP: + soap_serialize_PointerTowcxs__DataEncryptionCCMPType(soap, &a->DataEncryptionCCMP); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_ProfileSecuritySettingRSNType(struct soap *soap, int choice, const union _wcxs__union_ProfileSecuritySettingRSNType *a) +{ + switch (choice) + { + case SOAP_UNION__wcxs__union_ProfileSecuritySettingRSNType_DataEncryptionTKIP: + return soap_out_PointerTowcxs__DataEncryptionTKIPType(soap, "wcxs:DataEncryptionTKIP", -1, &a->DataEncryptionTKIP, ""); + case SOAP_UNION__wcxs__union_ProfileSecuritySettingRSNType_DataEncryptionCCMP: + return soap_out_PointerTowcxs__DataEncryptionCCMPType(soap, "wcxs:DataEncryptionCCMP", -1, &a->DataEncryptionCCMP, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _wcxs__union_ProfileSecuritySettingRSNType * SOAP_FMAC4 soap_in__wcxs__union_ProfileSecuritySettingRSNType(struct soap *soap, int *choice, union _wcxs__union_ProfileSecuritySettingRSNType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->DataEncryptionTKIP = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__DataEncryptionTKIPType(soap, "wcxs:DataEncryptionTKIP", &a->DataEncryptionTKIP, "wcxs:DataEncryptionTKIPType")) + { *choice = SOAP_UNION__wcxs__union_ProfileSecuritySettingRSNType_DataEncryptionTKIP; + return a; + } + a->DataEncryptionCCMP = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__DataEncryptionCCMPType(soap, "wcxs:DataEncryptionCCMP", &a->DataEncryptionCCMP, "wcxs:DataEncryptionCCMPType")) + { *choice = SOAP_UNION__wcxs__union_ProfileSecuritySettingRSNType_DataEncryptionCCMP; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_ProfileSecuritySettingWPAType(struct soap *soap, int choice, const union _wcxs__union_ProfileSecuritySettingWPAType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__wcxs__union_ProfileSecuritySettingWPAType_DataEncryptionTKIP: + soap_serialize_PointerTowcxs__DataEncryptionTKIPType(soap, &a->DataEncryptionTKIP); + break; + case SOAP_UNION__wcxs__union_ProfileSecuritySettingWPAType_DataEncryptionCCMP: + soap_serialize_PointerTowcxs__DataEncryptionCCMPType(soap, &a->DataEncryptionCCMP); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_ProfileSecuritySettingWPAType(struct soap *soap, int choice, const union _wcxs__union_ProfileSecuritySettingWPAType *a) +{ + switch (choice) + { + case SOAP_UNION__wcxs__union_ProfileSecuritySettingWPAType_DataEncryptionTKIP: + return soap_out_PointerTowcxs__DataEncryptionTKIPType(soap, "wcxs:DataEncryptionTKIP", -1, &a->DataEncryptionTKIP, ""); + case SOAP_UNION__wcxs__union_ProfileSecuritySettingWPAType_DataEncryptionCCMP: + return soap_out_PointerTowcxs__DataEncryptionCCMPType(soap, "wcxs:DataEncryptionCCMP", -1, &a->DataEncryptionCCMP, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _wcxs__union_ProfileSecuritySettingWPAType * SOAP_FMAC4 soap_in__wcxs__union_ProfileSecuritySettingWPAType(struct soap *soap, int *choice, union _wcxs__union_ProfileSecuritySettingWPAType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->DataEncryptionTKIP = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__DataEncryptionTKIPType(soap, "wcxs:DataEncryptionTKIP", &a->DataEncryptionTKIP, "wcxs:DataEncryptionTKIPType")) + { *choice = SOAP_UNION__wcxs__union_ProfileSecuritySettingWPAType_DataEncryptionTKIP; + return a; + } + a->DataEncryptionCCMP = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__DataEncryptionCCMPType(soap, "wcxs:DataEncryptionCCMP", &a->DataEncryptionCCMP, "wcxs:DataEncryptionCCMPType")) + { *choice = SOAP_UNION__wcxs__union_ProfileSecuritySettingWPAType_DataEncryptionCCMP; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_DataEncryptionCCMPType(struct soap *soap, int choice, const union _wcxs__union_DataEncryptionCCMPType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__wcxs__union_DataEncryptionCCMPType_PassPhrase: + soap_serialize_PointerTowcxs__PassPhrase63Type(soap, &a->PassPhrase); + break; + case SOAP_UNION__wcxs__union_DataEncryptionCCMPType_RawKey: + soap_serialize_PointerTowcxs__RawKey256Type(soap, &a->RawKey); + break; + case SOAP_UNION__wcxs__union_DataEncryptionCCMPType_XProfile: + soap_serialize_PointerToxcfg__XProfileType(soap, &a->XProfile); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_DataEncryptionCCMPType(struct soap *soap, int choice, const union _wcxs__union_DataEncryptionCCMPType *a) +{ + switch (choice) + { + case SOAP_UNION__wcxs__union_DataEncryptionCCMPType_PassPhrase: + return soap_out_PointerTowcxs__PassPhrase63Type(soap, "wcxs:PassPhrase", -1, &a->PassPhrase, ""); + case SOAP_UNION__wcxs__union_DataEncryptionCCMPType_RawKey: + return soap_out_PointerTowcxs__RawKey256Type(soap, "wcxs:RawKey", -1, &a->RawKey, ""); + case SOAP_UNION__wcxs__union_DataEncryptionCCMPType_XProfile: + return soap_out_PointerToxcfg__XProfileType(soap, "wcxs:XProfile", -1, &a->XProfile, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _wcxs__union_DataEncryptionCCMPType * SOAP_FMAC4 soap_in__wcxs__union_DataEncryptionCCMPType(struct soap *soap, int *choice, union _wcxs__union_DataEncryptionCCMPType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->PassPhrase = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__PassPhrase63Type(soap, "wcxs:PassPhrase", &a->PassPhrase, "wcxs:PassPhrase63Type")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionCCMPType_PassPhrase; + return a; + } + a->RawKey = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__RawKey256Type(soap, "wcxs:RawKey", &a->RawKey, "wcxs:RawKey256Type")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionCCMPType_RawKey; + return a; + } + a->XProfile = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfileType(soap, "wcxs:XProfile", &a->XProfile, "xcfg:XProfileType")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionCCMPType_XProfile; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_DataEncryptionTKIPType(struct soap *soap, int choice, const union _wcxs__union_DataEncryptionTKIPType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__wcxs__union_DataEncryptionTKIPType_PassPhrase: + soap_serialize_PointerTowcxs__PassPhrase63Type(soap, &a->PassPhrase); + break; + case SOAP_UNION__wcxs__union_DataEncryptionTKIPType_RawKey: + soap_serialize_PointerTowcxs__RawKey256Type(soap, &a->RawKey); + break; + case SOAP_UNION__wcxs__union_DataEncryptionTKIPType_XProfile: + soap_serialize_PointerToxcfg__XProfileType(soap, &a->XProfile); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_DataEncryptionTKIPType(struct soap *soap, int choice, const union _wcxs__union_DataEncryptionTKIPType *a) +{ + switch (choice) + { + case SOAP_UNION__wcxs__union_DataEncryptionTKIPType_PassPhrase: + return soap_out_PointerTowcxs__PassPhrase63Type(soap, "wcxs:PassPhrase", -1, &a->PassPhrase, ""); + case SOAP_UNION__wcxs__union_DataEncryptionTKIPType_RawKey: + return soap_out_PointerTowcxs__RawKey256Type(soap, "wcxs:RawKey", -1, &a->RawKey, ""); + case SOAP_UNION__wcxs__union_DataEncryptionTKIPType_XProfile: + return soap_out_PointerToxcfg__XProfileType(soap, "wcxs:XProfile", -1, &a->XProfile, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _wcxs__union_DataEncryptionTKIPType * SOAP_FMAC4 soap_in__wcxs__union_DataEncryptionTKIPType(struct soap *soap, int *choice, union _wcxs__union_DataEncryptionTKIPType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->PassPhrase = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__PassPhrase63Type(soap, "wcxs:PassPhrase", &a->PassPhrase, "wcxs:PassPhrase63Type")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionTKIPType_PassPhrase; + return a; + } + a->RawKey = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__RawKey256Type(soap, "wcxs:RawKey", &a->RawKey, "wcxs:RawKey256Type")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionTKIPType_RawKey; + return a; + } + a->XProfile = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfileType(soap, "wcxs:XProfile", &a->XProfile, "xcfg:XProfileType")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionTKIPType_XProfile; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_DataEncryptionWEPType(struct soap *soap, int choice, const union _wcxs__union_DataEncryptionWEPType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__wcxs__union_DataEncryptionWEPType_PassPhrase: + soap_serialize_PointerTowcxs__PassPhrase63Type(soap, &a->PassPhrase); + break; + case SOAP_UNION__wcxs__union_DataEncryptionWEPType_RawKey: + soap_serialize_PointerTowcxs__RawKey128Type(soap, &a->RawKey); + break; + case SOAP_UNION__wcxs__union_DataEncryptionWEPType_XProfile: + soap_serialize_PointerToxcfg__XProfileType(soap, &a->XProfile); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_DataEncryptionWEPType(struct soap *soap, int choice, const union _wcxs__union_DataEncryptionWEPType *a) +{ + switch (choice) + { + case SOAP_UNION__wcxs__union_DataEncryptionWEPType_PassPhrase: + return soap_out_PointerTowcxs__PassPhrase63Type(soap, "wcxs:PassPhrase", -1, &a->PassPhrase, ""); + case SOAP_UNION__wcxs__union_DataEncryptionWEPType_RawKey: + return soap_out_PointerTowcxs__RawKey128Type(soap, "wcxs:RawKey", -1, &a->RawKey, ""); + case SOAP_UNION__wcxs__union_DataEncryptionWEPType_XProfile: + return soap_out_PointerToxcfg__XProfileType(soap, "wcxs:XProfile", -1, &a->XProfile, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _wcxs__union_DataEncryptionWEPType * SOAP_FMAC4 soap_in__wcxs__union_DataEncryptionWEPType(struct soap *soap, int *choice, union _wcxs__union_DataEncryptionWEPType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->PassPhrase = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__PassPhrase63Type(soap, "wcxs:PassPhrase", &a->PassPhrase, "wcxs:PassPhrase63Type")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionWEPType_PassPhrase; + return a; + } + a->RawKey = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__RawKey128Type(soap, "wcxs:RawKey", &a->RawKey, "wcxs:RawKey128Type")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionWEPType_RawKey; + return a; + } + a->XProfile = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfileType(soap, "wcxs:XProfile", &a->XProfile, "xcfg:XProfileType")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionWEPType_XProfile; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_DataEncryptionWEPXType(struct soap *soap, int choice, const union _wcxs__union_DataEncryptionWEPXType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__wcxs__union_DataEncryptionWEPXType_WEP64: + soap_serialize_PointerTowcxs__WEP64Type(soap, &a->WEP64); + break; + case SOAP_UNION__wcxs__union_DataEncryptionWEPXType_WEP128: + soap_serialize_PointerTowcxs__WEP128Type(soap, &a->WEP128); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_DataEncryptionWEPXType(struct soap *soap, int choice, const union _wcxs__union_DataEncryptionWEPXType *a) +{ + switch (choice) + { + case SOAP_UNION__wcxs__union_DataEncryptionWEPXType_WEP64: + return soap_out_PointerTowcxs__WEP64Type(soap, "wcxs:WEP64", -1, &a->WEP64, ""); + case SOAP_UNION__wcxs__union_DataEncryptionWEPXType_WEP128: + return soap_out_PointerTowcxs__WEP128Type(soap, "wcxs:WEP128", -1, &a->WEP128, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _wcxs__union_DataEncryptionWEPXType * SOAP_FMAC4 soap_in__wcxs__union_DataEncryptionWEPXType(struct soap *soap, int *choice, union _wcxs__union_DataEncryptionWEPXType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->WEP64 = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__WEP64Type(soap, "wcxs:WEP64", &a->WEP64, "wcxs:WEP64Type")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionWEPXType_WEP64; + return a; + } + a->WEP128 = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__WEP128Type(soap, "wcxs:WEP128", &a->WEP128, "wcxs:WEP128Type")) + { *choice = SOAP_UNION__wcxs__union_DataEncryptionWEPXType_WEP128; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_WEP128Type(struct soap *soap, int choice, const union _wcxs__union_WEP128Type *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__wcxs__union_WEP128Type_PassPhrase: + soap_serialize_PointerTowcxs__PassPhraseWEP128Type(soap, &a->PassPhrase); + break; + case SOAP_UNION__wcxs__union_WEP128Type_RawKey: + soap_serialize_PointerTowcxs__RawKey128Type(soap, &a->RawKey); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_WEP128Type(struct soap *soap, int choice, const union _wcxs__union_WEP128Type *a) +{ + switch (choice) + { + case SOAP_UNION__wcxs__union_WEP128Type_PassPhrase: + return soap_out_PointerTowcxs__PassPhraseWEP128Type(soap, "wcxs:PassPhrase", -1, &a->PassPhrase, ""); + case SOAP_UNION__wcxs__union_WEP128Type_RawKey: + return soap_out_PointerTowcxs__RawKey128Type(soap, "wcxs:RawKey", -1, &a->RawKey, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _wcxs__union_WEP128Type * SOAP_FMAC4 soap_in__wcxs__union_WEP128Type(struct soap *soap, int *choice, union _wcxs__union_WEP128Type *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->PassPhrase = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__PassPhraseWEP128Type(soap, "wcxs:PassPhrase", &a->PassPhrase, "wcxs:PassPhraseWEP128Type")) + { *choice = SOAP_UNION__wcxs__union_WEP128Type_PassPhrase; + return a; + } + a->RawKey = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__RawKey128Type(soap, "wcxs:RawKey", &a->RawKey, "wcxs:RawKey128Type")) + { *choice = SOAP_UNION__wcxs__union_WEP128Type_RawKey; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__wcxs__union_WEP64Type(struct soap *soap, int choice, const union _wcxs__union_WEP64Type *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__wcxs__union_WEP64Type_PassPhrase: + soap_serialize_PointerTowcxs__PassPhrase5Type(soap, &a->PassPhrase); + break; + case SOAP_UNION__wcxs__union_WEP64Type_RawKey: + soap_serialize_PointerTowcxs__RawKey64Type(soap, &a->RawKey); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__wcxs__union_WEP64Type(struct soap *soap, int choice, const union _wcxs__union_WEP64Type *a) +{ + switch (choice) + { + case SOAP_UNION__wcxs__union_WEP64Type_PassPhrase: + return soap_out_PointerTowcxs__PassPhrase5Type(soap, "wcxs:PassPhrase", -1, &a->PassPhrase, ""); + case SOAP_UNION__wcxs__union_WEP64Type_RawKey: + return soap_out_PointerTowcxs__RawKey64Type(soap, "wcxs:RawKey", -1, &a->RawKey, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _wcxs__union_WEP64Type * SOAP_FMAC4 soap_in__wcxs__union_WEP64Type(struct soap *soap, int *choice, union _wcxs__union_WEP64Type *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->PassPhrase = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__PassPhrase5Type(soap, "wcxs:PassPhrase", &a->PassPhrase, "wcxs:PassPhrase5Type")) + { *choice = SOAP_UNION__wcxs__union_WEP64Type_PassPhrase; + return a; + } + a->RawKey = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTowcxs__RawKey64Type(soap, "wcxs:RawKey", &a->RawKey, "wcxs:RawKey64Type")) + { *choice = SOAP_UNION__wcxs__union_WEP64Type_RawKey; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__union_CircuitBreakerPacketType(struct soap *soap, int choice, const union _cb__union_CircuitBreakerPacketType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketTCP: + soap_serialize_PointerTocb__CircuitBreakerPacketTCPType(soap, &a->PacketTCP); + break; + case SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketUDP: + soap_serialize_PointerTocb__CircuitBreakerPacketUDPType(soap, &a->PacketUDP); + break; + case SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketIP: + soap_serialize_PointerTocb__CircuitBreakerPacketIPType(soap, &a->PacketIP); + break; + case SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketETH: + soap_serialize_PointerTocb__CircuitBreakerPacketETHType(soap, &a->PacketETH); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__union_CircuitBreakerPacketType(struct soap *soap, int choice, const union _cb__union_CircuitBreakerPacketType *a) +{ + switch (choice) + { + case SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketTCP: + return soap_out_PointerTocb__CircuitBreakerPacketTCPType(soap, "cb:PacketTCP", -1, &a->PacketTCP, ""); + case SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketUDP: + return soap_out_PointerTocb__CircuitBreakerPacketUDPType(soap, "cb:PacketUDP", -1, &a->PacketUDP, ""); + case SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketIP: + return soap_out_PointerTocb__CircuitBreakerPacketIPType(soap, "cb:PacketIP", -1, &a->PacketIP, ""); + case SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketETH: + return soap_out_PointerTocb__CircuitBreakerPacketETHType(soap, "cb:PacketETH", -1, &a->PacketETH, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _cb__union_CircuitBreakerPacketType * SOAP_FMAC4 soap_in__cb__union_CircuitBreakerPacketType(struct soap *soap, int *choice, union _cb__union_CircuitBreakerPacketType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->PacketTCP = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocb__CircuitBreakerPacketTCPType(soap, "cb:PacketTCP", &a->PacketTCP, "cb:CircuitBreakerPacketTCPType")) + { *choice = SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketTCP; + return a; + } + a->PacketUDP = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocb__CircuitBreakerPacketUDPType(soap, "cb:PacketUDP", &a->PacketUDP, "cb:CircuitBreakerPacketUDPType")) + { *choice = SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketUDP; + return a; + } + a->PacketIP = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocb__CircuitBreakerPacketIPType(soap, "cb:PacketIP", &a->PacketIP, "cb:CircuitBreakerPacketIPType")) + { *choice = SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketIP; + return a; + } + a->PacketETH = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocb__CircuitBreakerPacketETHType(soap, "cb:PacketETH", &a->PacketETH, "cb:CircuitBreakerPacketETHType")) + { *choice = SOAP_UNION__cb__union_CircuitBreakerPacketType_PacketETH; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__union_CircuitBreakerIPPacketType(struct soap *soap, int choice, const union _cb__union_CircuitBreakerIPPacketType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__cb__union_CircuitBreakerIPPacketType_IPv4: + soap_serialize_PointerTocb__CircuitBreakerIPv4Type(soap, &a->IPv4); + break; + case SOAP_UNION__cb__union_CircuitBreakerIPPacketType_IPv6: + soap_serialize_PointerTocb__CircuitBreakerIPv6Type(soap, &a->IPv6); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__union_CircuitBreakerIPPacketType(struct soap *soap, int choice, const union _cb__union_CircuitBreakerIPPacketType *a) +{ + switch (choice) + { + case SOAP_UNION__cb__union_CircuitBreakerIPPacketType_IPv4: + return soap_out_PointerTocb__CircuitBreakerIPv4Type(soap, "cb:IPv4", -1, &a->IPv4, ""); + case SOAP_UNION__cb__union_CircuitBreakerIPPacketType_IPv6: + return soap_out_PointerTocb__CircuitBreakerIPv6Type(soap, "cb:IPv6", -1, &a->IPv6, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _cb__union_CircuitBreakerIPPacketType * SOAP_FMAC4 soap_in__cb__union_CircuitBreakerIPPacketType(struct soap *soap, int *choice, union _cb__union_CircuitBreakerIPPacketType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->IPv4 = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocb__CircuitBreakerIPv4Type(soap, "cb:IPv4", &a->IPv4, "cb:CircuitBreakerIPv4Type")) + { *choice = SOAP_UNION__cb__union_CircuitBreakerIPPacketType_IPv4; + return a; + } + a->IPv6 = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocb__CircuitBreakerIPv6Type(soap, "cb:IPv6", &a->IPv6, "cb:CircuitBreakerIPv6Type")) + { *choice = SOAP_UNION__cb__union_CircuitBreakerIPPacketType_IPv6; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cb__union_CircuitBreakerIPLayeredPortType(struct soap *soap, int choice, const union _cb__union_CircuitBreakerIPLayeredPortType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortSimple: + soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(soap, &a->IPLayeredPortSimple); + break; + case SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortRangeSource: + soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, &a->IPLayeredPortRangeSource); + break; + case SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortRangeDestination: + soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, &a->IPLayeredPortRangeDestination); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cb__union_CircuitBreakerIPLayeredPortType(struct soap *soap, int choice, const union _cb__union_CircuitBreakerIPLayeredPortType *a) +{ + switch (choice) + { + case SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortSimple: + return soap_out_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(soap, "cb:IPLayeredPortSimple", -1, &a->IPLayeredPortSimple, ""); + case SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortRangeSource: + return soap_out_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, "cb:IPLayeredPortRangeSource", -1, &a->IPLayeredPortRangeSource, ""); + case SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortRangeDestination: + return soap_out_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, "cb:IPLayeredPortRangeDestination", -1, &a->IPLayeredPortRangeDestination, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _cb__union_CircuitBreakerIPLayeredPortType * SOAP_FMAC4 soap_in__cb__union_CircuitBreakerIPLayeredPortType(struct soap *soap, int *choice, union _cb__union_CircuitBreakerIPLayeredPortType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->IPLayeredPortSimple = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(soap, "cb:IPLayeredPortSimple", &a->IPLayeredPortSimple, "cb:CircuitBreakerIPLayeredPortSimpleType")) + { *choice = SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortSimple; + return a; + } + a->IPLayeredPortRangeSource = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, "cb:IPLayeredPortRangeSource", &a->IPLayeredPortRangeSource, "cb:CircuitBreakerIPLayeredPortRangeType")) + { *choice = SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortRangeSource; + return a; + } + a->IPLayeredPortRangeDestination = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, "cb:IPLayeredPortRangeDestination", &a->IPLayeredPortRangeDestination, "cb:CircuitBreakerIPLayeredPortRangeType")) + { *choice = SOAP_UNION__cb__union_CircuitBreakerIPLayeredPortType_IPLayeredPortRangeDestination; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__emi__union_AlertSubscriptionGeneralType(struct soap *soap, int choice, const union _emi__union_AlertSubscriptionGeneralType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__emi__union_AlertSubscriptionGeneralType_AlertSubscriptionSNMP: + soap_serialize_PointerToemi__AlertSubscriptionSNMPType(soap, &a->AlertSubscriptionSNMP); + break; + case SOAP_UNION__emi__union_AlertSubscriptionGeneralType_AlertSubscriptionSoap: + soap_serialize_PointerToemi__AlertSubscriptionSoapType(soap, &a->AlertSubscriptionSoap); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__emi__union_AlertSubscriptionGeneralType(struct soap *soap, int choice, const union _emi__union_AlertSubscriptionGeneralType *a) +{ + switch (choice) + { + case SOAP_UNION__emi__union_AlertSubscriptionGeneralType_AlertSubscriptionSNMP: + return soap_out_PointerToemi__AlertSubscriptionSNMPType(soap, "emi:AlertSubscriptionSNMP", -1, &a->AlertSubscriptionSNMP, ""); + case SOAP_UNION__emi__union_AlertSubscriptionGeneralType_AlertSubscriptionSoap: + return soap_out_PointerToemi__AlertSubscriptionSoapType(soap, "emi:AlertSubscriptionSoap", -1, &a->AlertSubscriptionSoap, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _emi__union_AlertSubscriptionGeneralType * SOAP_FMAC4 soap_in__emi__union_AlertSubscriptionGeneralType(struct soap *soap, int *choice, union _emi__union_AlertSubscriptionGeneralType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->AlertSubscriptionSNMP = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToemi__AlertSubscriptionSNMPType(soap, "emi:AlertSubscriptionSNMP", &a->AlertSubscriptionSNMP, "emi:AlertSubscriptionSNMPType")) + { *choice = SOAP_UNION__emi__union_AlertSubscriptionGeneralType_AlertSubscriptionSNMP; + return a; + } + a->AlertSubscriptionSoap = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToemi__AlertSubscriptionSoapType(soap, "emi:AlertSubscriptionSoap", &a->AlertSubscriptionSoap, "emi:AlertSubscriptionSoapType")) + { *choice = SOAP_UNION__emi__union_AlertSubscriptionGeneralType_AlertSubscriptionSoap; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__xcfg__union_XProfileType(struct soap *soap, int choice, const union _xcfg__union_XProfileType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__xcfg__union_XProfileType_TLS: + soap_serialize_PointerToxcfg__XProfileTLSType(soap, &a->TLS); + break; + case SOAP_UNION__xcfg__union_XProfileType_TTLS_USCOREMSCHAPv2: + soap_serialize_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, &a->TTLS_USCOREMSCHAPv2); + break; + case SOAP_UNION__xcfg__union_XProfileType_PEAP_USCOREMSCHAPv2: + soap_serialize_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, &a->PEAP_USCOREMSCHAPv2); + break; + case SOAP_UNION__xcfg__union_XProfileType_EAP_USCOREGTC: + soap_serialize_PointerToxcfg__XProfileEAP_USCOREGTCType(soap, &a->EAP_USCOREGTC); + break; + case SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCOREMSCHAPv2: + soap_serialize_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, &a->EAPFAST_USCOREMSCHAPv2); + break; + case SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCOREGTC: + soap_serialize_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(soap, &a->EAPFAST_USCOREGTC); + break; + case SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCORETLS: + soap_serialize_PointerToxcfg__XProfileEAPFAST_USCORETLSType(soap, &a->EAPFAST_USCORETLS); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__xcfg__union_XProfileType(struct soap *soap, int choice, const union _xcfg__union_XProfileType *a) +{ + switch (choice) + { + case SOAP_UNION__xcfg__union_XProfileType_TLS: + return soap_out_PointerToxcfg__XProfileTLSType(soap, "xcfg:TLS", -1, &a->TLS, ""); + case SOAP_UNION__xcfg__union_XProfileType_TTLS_USCOREMSCHAPv2: + return soap_out_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, "xcfg:TTLS_MSCHAPv2", -1, &a->TTLS_USCOREMSCHAPv2, ""); + case SOAP_UNION__xcfg__union_XProfileType_PEAP_USCOREMSCHAPv2: + return soap_out_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, "xcfg:PEAP_MSCHAPv2", -1, &a->PEAP_USCOREMSCHAPv2, ""); + case SOAP_UNION__xcfg__union_XProfileType_EAP_USCOREGTC: + return soap_out_PointerToxcfg__XProfileEAP_USCOREGTCType(soap, "xcfg:EAP_GTC", -1, &a->EAP_USCOREGTC, ""); + case SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCOREMSCHAPv2: + return soap_out_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, "xcfg:EAPFAST_MSCHAPv2", -1, &a->EAPFAST_USCOREMSCHAPv2, ""); + case SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCOREGTC: + return soap_out_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(soap, "xcfg:EAPFAST_GTC", -1, &a->EAPFAST_USCOREGTC, ""); + case SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCORETLS: + return soap_out_PointerToxcfg__XProfileEAPFAST_USCORETLSType(soap, "xcfg:EAPFAST_TLS", -1, &a->EAPFAST_USCORETLS, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _xcfg__union_XProfileType * SOAP_FMAC4 soap_in__xcfg__union_XProfileType(struct soap *soap, int *choice, union _xcfg__union_XProfileType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->TLS = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfileTLSType(soap, "xcfg:TLS", &a->TLS, "xcfg:XProfileTLSType")) + { *choice = SOAP_UNION__xcfg__union_XProfileType_TLS; + return a; + } + a->TTLS_USCOREMSCHAPv2 = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, "xcfg:TTLS_MSCHAPv2", &a->TTLS_USCOREMSCHAPv2, "xcfg:XProfileTTLS_MSCHAPv2Type")) + { *choice = SOAP_UNION__xcfg__union_XProfileType_TTLS_USCOREMSCHAPv2; + return a; + } + a->PEAP_USCOREMSCHAPv2 = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, "xcfg:PEAP_MSCHAPv2", &a->PEAP_USCOREMSCHAPv2, "xcfg:XProfilePEAP_MSCHAPv2Type")) + { *choice = SOAP_UNION__xcfg__union_XProfileType_PEAP_USCOREMSCHAPv2; + return a; + } + a->EAP_USCOREGTC = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfileEAP_USCOREGTCType(soap, "xcfg:EAP_GTC", &a->EAP_USCOREGTC, "xcfg:XProfileEAP_GTCType")) + { *choice = SOAP_UNION__xcfg__union_XProfileType_EAP_USCOREGTC; + return a; + } + a->EAPFAST_USCOREMSCHAPv2 = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, "xcfg:EAPFAST_MSCHAPv2", &a->EAPFAST_USCOREMSCHAPv2, "xcfg:XProfileEAPFAST_MSCHAPv2Type")) + { *choice = SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCOREMSCHAPv2; + return a; + } + a->EAPFAST_USCOREGTC = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(soap, "xcfg:EAPFAST_GTC", &a->EAPFAST_USCOREGTC, "xcfg:XProfileEAPFAST_GTCType")) + { *choice = SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCOREGTC; + return a; + } + a->EAPFAST_USCORETLS = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerToxcfg__XProfileEAPFAST_USCORETLSType(soap, "xcfg:EAPFAST_TLS", &a->EAPFAST_USCORETLS, "xcfg:XProfileEAPFAST_TLSType")) + { *choice = SOAP_UNION__xcfg__union_XProfileType_EAPFAST_USCORETLS; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__sai__union_UserAclEntryExType(struct soap *soap, int choice, const union _sai__union_UserAclEntryExType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__sai__union_UserAclEntryExType_DigestUser: + soap_serialize_PointerTosai__UserEntryDigestType(soap, &a->DigestUser); + break; + case SOAP_UNION__sai__union_UserAclEntryExType_KerberosUser: + soap_serialize_PointerTosai__UserEntryKerberosType(soap, &a->KerberosUser); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__sai__union_UserAclEntryExType(struct soap *soap, int choice, const union _sai__union_UserAclEntryExType *a) +{ + switch (choice) + { + case SOAP_UNION__sai__union_UserAclEntryExType_DigestUser: + return soap_out_PointerTosai__UserEntryDigestType(soap, "sai:DigestUser", -1, &a->DigestUser, ""); + case SOAP_UNION__sai__union_UserAclEntryExType_KerberosUser: + return soap_out_PointerTosai__UserEntryKerberosType(soap, "sai:KerberosUser", -1, &a->KerberosUser, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _sai__union_UserAclEntryExType * SOAP_FMAC4 soap_in__sai__union_UserAclEntryExType(struct soap *soap, int *choice, union _sai__union_UserAclEntryExType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->DigestUser = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTosai__UserEntryDigestType(soap, "sai:DigestUser", &a->DigestUser, "sai:UserEntryDigestType")) + { *choice = SOAP_UNION__sai__union_UserAclEntryExType_DigestUser; + return a; + } + a->KerberosUser = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTosai__UserEntryKerberosType(soap, "sai:KerberosUser", &a->KerberosUser, "sai:UserEntryKerberosType")) + { *choice = SOAP_UNION__sai__union_UserAclEntryExType_KerberosUser; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cstr__union_KeyPairType(struct soap *soap, int choice, const union _cstr__union_KeyPairType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__cstr__union_KeyPairType_RSAKeyPair: + soap_serialize_PointerTocstr__RSAKeyPairType(soap, &a->RSAKeyPair); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cstr__union_KeyPairType(struct soap *soap, int choice, const union _cstr__union_KeyPairType *a) +{ + switch (choice) + { + case SOAP_UNION__cstr__union_KeyPairType_RSAKeyPair: + return soap_out_PointerTocstr__RSAKeyPairType(soap, "cstr:RSAKeyPair", -1, &a->RSAKeyPair, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _cstr__union_KeyPairType * SOAP_FMAC4 soap_in__cstr__union_KeyPairType(struct soap *soap, int *choice, union _cstr__union_KeyPairType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->RSAKeyPair = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocstr__RSAKeyPairType(soap, "cstr:RSAKeyPair", &a->RSAKeyPair, "cstr:RSAKeyPairType")) + { *choice = SOAP_UNION__cstr__union_KeyPairType_RSAKeyPair; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__cmn__union_NodeAddressType(struct soap *soap, int choice, const union _cmn__union_NodeAddressType *a) +{ + (void)soap; (void)a; /* appease -Wall -Werror */ + switch (choice) + { + case SOAP_UNION__cmn__union_NodeAddressType_HostName: + soap_serialize_PointerTocmn__HostNameType(soap, &a->HostName); + break; + case SOAP_UNION__cmn__union_NodeAddressType_IPv4Address: + soap_serialize_PointerTocmn__IPv4AddressStringType(soap, &a->IPv4Address); + break; + case SOAP_UNION__cmn__union_NodeAddressType_IPv6Address: + soap_serialize_PointerTocmn__IPv6AddressStringType(soap, &a->IPv6Address); + break; + } +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__cmn__union_NodeAddressType(struct soap *soap, int choice, const union _cmn__union_NodeAddressType *a) +{ + switch (choice) + { + case SOAP_UNION__cmn__union_NodeAddressType_HostName: + return soap_out_PointerTocmn__HostNameType(soap, "cmn:HostName", -1, &a->HostName, ""); + case SOAP_UNION__cmn__union_NodeAddressType_IPv4Address: + return soap_out_PointerTocmn__IPv4AddressStringType(soap, "cmn:IPv4Address", -1, &a->IPv4Address, ""); + case SOAP_UNION__cmn__union_NodeAddressType_IPv6Address: + return soap_out_PointerTocmn__IPv6AddressStringType(soap, "cmn:IPv6Address", -1, &a->IPv6Address, ""); + } + return SOAP_OK; +} + +SOAP_FMAC3 union _cmn__union_NodeAddressType * SOAP_FMAC4 soap_in__cmn__union_NodeAddressType(struct soap *soap, int *choice, union _cmn__union_NodeAddressType *a) +{ soap->error = SOAP_TAG_MISMATCH; + a->HostName = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocmn__HostNameType(soap, "cmn:HostName", &a->HostName, "cmn:HostNameType")) + { *choice = SOAP_UNION__cmn__union_NodeAddressType_HostName; + return a; + } + a->IPv4Address = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocmn__IPv4AddressStringType(soap, "cmn:IPv4Address", &a->IPv4Address, "cmn:IPv4AddressStringType")) + { *choice = SOAP_UNION__cmn__union_NodeAddressType_IPv4Address; + return a; + } + a->IPv6Address = NULL; + if (soap->error == SOAP_TAG_MISMATCH && soap_in_PointerTocmn__IPv6AddressStringType(soap, "cmn:IPv6Address", &a->IPv6Address, "cmn:IPv6AddressStringType")) + { *choice = SOAP_UNION__cmn__union_NodeAddressType_IPv6Address; + return a; + } + *choice = 0; + if (!soap->error) + soap->error = SOAP_TAG_MISMATCH; + return NULL; +} + +#ifndef WITH_NOGLOBAL + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason)) + soap_serialize_SOAP_ENV__Reason(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Reason); + if (soap_out_PointerToSOAP_ENV__Reason(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Reason *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason); + if (id < 0) + return soap->error; + return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type); +} + +SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, struct SOAP_ENV__Reason **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type))) + return NULL; + } + else + { a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +#endif + +#ifndef WITH_NOGLOBAL + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail)) + soap_serialize_SOAP_ENV__Detail(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Detail); + if (soap_out_PointerToSOAP_ENV__Detail(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Detail *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail); + if (id < 0) + return soap->error; + return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type); +} + +SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, struct SOAP_ENV__Detail **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type))) + return NULL; + } + else + { a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +#endif + +#ifndef WITH_NOGLOBAL + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code)) + soap_serialize_SOAP_ENV__Code(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Code); + if (soap_out_PointerToSOAP_ENV__Code(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Code *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code); + if (id < 0) + return soap->error; + return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type); +} + +SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type))) + return NULL; + } + else + { a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +#endif + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap *soap, _wcxs__GetWirelessSettingsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__GetWirelessSettingsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap *soap, _wcxs__GetWirelessSettingsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsResponse); + if (soap_out_PointerTo_wcxs__GetWirelessSettingsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap *soap, const char *tag, int id, _wcxs__GetWirelessSettingsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__GetWirelessSettingsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap *soap, _wcxs__GetWirelessSettingsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__GetWirelessSettingsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessSettingsResponse(struct soap *soap, const char *tag, _wcxs__GetWirelessSettingsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__GetWirelessSettingsResponse **)soap_malloc(soap, sizeof(_wcxs__GetWirelessSettingsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__GetWirelessSettingsResponse *)soap_instantiate__wcxs__GetWirelessSettingsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__GetWirelessSettingsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__GetWirelessSettingsResponse, sizeof(_wcxs__GetWirelessSettingsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap *soap, _wcxs__GetWirelessSettingsRequest *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__GetWirelessSettingsRequest)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap *soap, _wcxs__GetWirelessSettingsRequest *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__GetWirelessSettingsRequest); + if (soap_out_PointerTo_wcxs__GetWirelessSettingsRequest(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap *soap, const char *tag, int id, _wcxs__GetWirelessSettingsRequest *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__GetWirelessSettingsRequest); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap *soap, _wcxs__GetWirelessSettingsRequest **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__GetWirelessSettingsRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__GetWirelessSettingsRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessSettingsRequest(struct soap *soap, const char *tag, _wcxs__GetWirelessSettingsRequest **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__GetWirelessSettingsRequest **)soap_malloc(soap, sizeof(_wcxs__GetWirelessSettingsRequest *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__GetWirelessSettingsRequest *)soap_instantiate__wcxs__GetWirelessSettingsRequest(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__GetWirelessSettingsRequest **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__GetWirelessSettingsRequest, sizeof(_wcxs__GetWirelessSettingsRequest), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, _wcxs__GetWirelessCapabilitiesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, _wcxs__GetWirelessCapabilitiesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesResponse); + if (soap_out_PointerTo_wcxs__GetWirelessCapabilitiesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, const char *tag, int id, _wcxs__GetWirelessCapabilitiesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, _wcxs__GetWirelessCapabilitiesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__GetWirelessCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessCapabilitiesResponse(struct soap *soap, const char *tag, _wcxs__GetWirelessCapabilitiesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__GetWirelessCapabilitiesResponse **)soap_malloc(soap, sizeof(_wcxs__GetWirelessCapabilitiesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__GetWirelessCapabilitiesResponse *)soap_instantiate__wcxs__GetWirelessCapabilitiesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__GetWirelessCapabilitiesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__GetWirelessCapabilitiesResponse, sizeof(_wcxs__GetWirelessCapabilitiesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, _wcxs__GetWirelessCapabilitiesRequest *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, _wcxs__GetWirelessCapabilitiesRequest *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__GetWirelessCapabilitiesRequest); + if (soap_out_PointerTo_wcxs__GetWirelessCapabilitiesRequest(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, const char *tag, int id, _wcxs__GetWirelessCapabilitiesRequest *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, _wcxs__GetWirelessCapabilitiesRequest **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__GetWirelessCapabilitiesRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__GetWirelessCapabilitiesRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessCapabilitiesRequest(struct soap *soap, const char *tag, _wcxs__GetWirelessCapabilitiesRequest **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__GetWirelessCapabilitiesRequest **)soap_malloc(soap, sizeof(_wcxs__GetWirelessCapabilitiesRequest *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__GetWirelessCapabilitiesRequest *)soap_instantiate__wcxs__GetWirelessCapabilitiesRequest(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__GetWirelessCapabilitiesRequest **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__GetWirelessCapabilitiesRequest, sizeof(_wcxs__GetWirelessCapabilitiesRequest), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, _wcxs__EnumerateWirelessProfilesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, _wcxs__EnumerateWirelessProfilesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesResponse); + if (soap_out_PointerTo_wcxs__EnumerateWirelessProfilesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, const char *tag, int id, _wcxs__EnumerateWirelessProfilesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, _wcxs__EnumerateWirelessProfilesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__EnumerateWirelessProfilesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__EnumerateWirelessProfilesResponse(struct soap *soap, const char *tag, _wcxs__EnumerateWirelessProfilesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__EnumerateWirelessProfilesResponse **)soap_malloc(soap, sizeof(_wcxs__EnumerateWirelessProfilesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__EnumerateWirelessProfilesResponse *)soap_instantiate__wcxs__EnumerateWirelessProfilesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__EnumerateWirelessProfilesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__EnumerateWirelessProfilesResponse, sizeof(_wcxs__EnumerateWirelessProfilesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, _wcxs__EnumerateWirelessProfilesRequest *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, _wcxs__EnumerateWirelessProfilesRequest *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__EnumerateWirelessProfilesRequest); + if (soap_out_PointerTo_wcxs__EnumerateWirelessProfilesRequest(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, const char *tag, int id, _wcxs__EnumerateWirelessProfilesRequest *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, _wcxs__EnumerateWirelessProfilesRequest **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__EnumerateWirelessProfilesRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__EnumerateWirelessProfilesRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__EnumerateWirelessProfilesRequest(struct soap *soap, const char *tag, _wcxs__EnumerateWirelessProfilesRequest **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__EnumerateWirelessProfilesRequest **)soap_malloc(soap, sizeof(_wcxs__EnumerateWirelessProfilesRequest *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__EnumerateWirelessProfilesRequest *)soap_instantiate__wcxs__EnumerateWirelessProfilesRequest(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__EnumerateWirelessProfilesRequest **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__EnumerateWirelessProfilesRequest, sizeof(_wcxs__EnumerateWirelessProfilesRequest), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap *soap, _wcxs__UpdateWirelessProfileResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__UpdateWirelessProfileResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap *soap, _wcxs__UpdateWirelessProfileResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileResponse); + if (soap_out_PointerTo_wcxs__UpdateWirelessProfileResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap *soap, const char *tag, int id, _wcxs__UpdateWirelessProfileResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__UpdateWirelessProfileResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap *soap, _wcxs__UpdateWirelessProfileResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__UpdateWirelessProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__UpdateWirelessProfileResponse(struct soap *soap, const char *tag, _wcxs__UpdateWirelessProfileResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__UpdateWirelessProfileResponse **)soap_malloc(soap, sizeof(_wcxs__UpdateWirelessProfileResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__UpdateWirelessProfileResponse *)soap_instantiate__wcxs__UpdateWirelessProfileResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__UpdateWirelessProfileResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__UpdateWirelessProfileResponse, sizeof(_wcxs__UpdateWirelessProfileResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap *soap, _wcxs__UpdateWirelessProfileRequest *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__UpdateWirelessProfileRequest)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap *soap, _wcxs__UpdateWirelessProfileRequest *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__UpdateWirelessProfileRequest); + if (soap_out_PointerTo_wcxs__UpdateWirelessProfileRequest(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap *soap, const char *tag, int id, _wcxs__UpdateWirelessProfileRequest *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__UpdateWirelessProfileRequest); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap *soap, _wcxs__UpdateWirelessProfileRequest **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__UpdateWirelessProfileRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__UpdateWirelessProfileRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__UpdateWirelessProfileRequest(struct soap *soap, const char *tag, _wcxs__UpdateWirelessProfileRequest **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__UpdateWirelessProfileRequest **)soap_malloc(soap, sizeof(_wcxs__UpdateWirelessProfileRequest *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__UpdateWirelessProfileRequest *)soap_instantiate__wcxs__UpdateWirelessProfileRequest(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__UpdateWirelessProfileRequest **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__UpdateWirelessProfileRequest, sizeof(_wcxs__UpdateWirelessProfileRequest), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap *soap, _wcxs__RemoveWirelessProfileResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__RemoveWirelessProfileResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap *soap, _wcxs__RemoveWirelessProfileResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileResponse); + if (soap_out_PointerTo_wcxs__RemoveWirelessProfileResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap *soap, const char *tag, int id, _wcxs__RemoveWirelessProfileResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__RemoveWirelessProfileResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap *soap, _wcxs__RemoveWirelessProfileResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__RemoveWirelessProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__RemoveWirelessProfileResponse(struct soap *soap, const char *tag, _wcxs__RemoveWirelessProfileResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__RemoveWirelessProfileResponse **)soap_malloc(soap, sizeof(_wcxs__RemoveWirelessProfileResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__RemoveWirelessProfileResponse *)soap_instantiate__wcxs__RemoveWirelessProfileResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__RemoveWirelessProfileResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__RemoveWirelessProfileResponse, sizeof(_wcxs__RemoveWirelessProfileResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap *soap, _wcxs__RemoveWirelessProfileRequest *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__RemoveWirelessProfileRequest)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap *soap, _wcxs__RemoveWirelessProfileRequest *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__RemoveWirelessProfileRequest); + if (soap_out_PointerTo_wcxs__RemoveWirelessProfileRequest(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap *soap, const char *tag, int id, _wcxs__RemoveWirelessProfileRequest *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__RemoveWirelessProfileRequest); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap *soap, _wcxs__RemoveWirelessProfileRequest **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__RemoveWirelessProfileRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__RemoveWirelessProfileRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__RemoveWirelessProfileRequest(struct soap *soap, const char *tag, _wcxs__RemoveWirelessProfileRequest **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__RemoveWirelessProfileRequest **)soap_malloc(soap, sizeof(_wcxs__RemoveWirelessProfileRequest *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__RemoveWirelessProfileRequest *)soap_instantiate__wcxs__RemoveWirelessProfileRequest(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__RemoveWirelessProfileRequest **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__RemoveWirelessProfileRequest, sizeof(_wcxs__RemoveWirelessProfileRequest), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessProfileResponse(struct soap *soap, _wcxs__GetWirelessProfileResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__GetWirelessProfileResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessProfileResponse(struct soap *soap, _wcxs__GetWirelessProfileResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileResponse); + if (soap_out_PointerTo_wcxs__GetWirelessProfileResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessProfileResponse(struct soap *soap, const char *tag, int id, _wcxs__GetWirelessProfileResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__GetWirelessProfileResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessProfileResponse(struct soap *soap, _wcxs__GetWirelessProfileResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__GetWirelessProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessProfileResponse(struct soap *soap, const char *tag, _wcxs__GetWirelessProfileResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__GetWirelessProfileResponse **)soap_malloc(soap, sizeof(_wcxs__GetWirelessProfileResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__GetWirelessProfileResponse *)soap_instantiate__wcxs__GetWirelessProfileResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__GetWirelessProfileResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__GetWirelessProfileResponse, sizeof(_wcxs__GetWirelessProfileResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__GetWirelessProfileRequest(struct soap *soap, _wcxs__GetWirelessProfileRequest *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__GetWirelessProfileRequest)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__GetWirelessProfileRequest(struct soap *soap, _wcxs__GetWirelessProfileRequest *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__GetWirelessProfileRequest); + if (soap_out_PointerTo_wcxs__GetWirelessProfileRequest(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__GetWirelessProfileRequest(struct soap *soap, const char *tag, int id, _wcxs__GetWirelessProfileRequest *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__GetWirelessProfileRequest); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__GetWirelessProfileRequest(struct soap *soap, _wcxs__GetWirelessProfileRequest **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__GetWirelessProfileRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__GetWirelessProfileRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__GetWirelessProfileRequest(struct soap *soap, const char *tag, _wcxs__GetWirelessProfileRequest **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__GetWirelessProfileRequest **)soap_malloc(soap, sizeof(_wcxs__GetWirelessProfileRequest *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__GetWirelessProfileRequest *)soap_instantiate__wcxs__GetWirelessProfileRequest(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__GetWirelessProfileRequest **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__GetWirelessProfileRequest, sizeof(_wcxs__GetWirelessProfileRequest), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__AddWirelessProfileResponse(struct soap *soap, _wcxs__AddWirelessProfileResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__AddWirelessProfileResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__AddWirelessProfileResponse(struct soap *soap, _wcxs__AddWirelessProfileResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileResponse); + if (soap_out_PointerTo_wcxs__AddWirelessProfileResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__AddWirelessProfileResponse(struct soap *soap, const char *tag, int id, _wcxs__AddWirelessProfileResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__AddWirelessProfileResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_wcxs__AddWirelessProfileResponse(struct soap *soap, _wcxs__AddWirelessProfileResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__AddWirelessProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_wcxs__AddWirelessProfileResponse(struct soap *soap, const char *tag, _wcxs__AddWirelessProfileResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__AddWirelessProfileResponse **)soap_malloc(soap, sizeof(_wcxs__AddWirelessProfileResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__AddWirelessProfileResponse *)soap_instantiate__wcxs__AddWirelessProfileResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__AddWirelessProfileResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__AddWirelessProfileResponse, sizeof(_wcxs__AddWirelessProfileResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_wcxs__AddWirelessProfileRequest(struct soap *soap, _wcxs__AddWirelessProfileRequest *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__wcxs__AddWirelessProfileRequest)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_wcxs__AddWirelessProfileRequest(struct soap *soap, _wcxs__AddWirelessProfileRequest *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_wcxs__AddWirelessProfileRequest); + if (soap_out_PointerTo_wcxs__AddWirelessProfileRequest(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_wcxs__AddWirelessProfileRequest(struct soap *soap, const char *tag, int id, _wcxs__AddWirelessProfileRequest *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__wcxs__AddWirelessProfileRequest); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest ** SOAP_FMAC4 soap_get_PointerTo_wcxs__AddWirelessProfileRequest(struct soap *soap, _wcxs__AddWirelessProfileRequest **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_wcxs__AddWirelessProfileRequest(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _wcxs__AddWirelessProfileRequest ** SOAP_FMAC4 soap_in_PointerTo_wcxs__AddWirelessProfileRequest(struct soap *soap, const char *tag, _wcxs__AddWirelessProfileRequest **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_wcxs__AddWirelessProfileRequest **)soap_malloc(soap, sizeof(_wcxs__AddWirelessProfileRequest *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_wcxs__AddWirelessProfileRequest *)soap_instantiate__wcxs__AddWirelessProfileRequest(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_wcxs__AddWirelessProfileRequest **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__wcxs__AddWirelessProfileRequest, sizeof(_wcxs__AddWirelessProfileRequest), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, _tim__SetHighAccuracyTimeSynchResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, _tim__SetHighAccuracyTimeSynchResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynchResponse); + if (soap_out_PointerTo_tim__SetHighAccuracyTimeSynchResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, const char *tag, int id, _tim__SetHighAccuracyTimeSynchResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse ** SOAP_FMAC4 soap_get_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, _tim__SetHighAccuracyTimeSynchResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_tim__SetHighAccuracyTimeSynchResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynchResponse ** SOAP_FMAC4 soap_in_PointerTo_tim__SetHighAccuracyTimeSynchResponse(struct soap *soap, const char *tag, _tim__SetHighAccuracyTimeSynchResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_tim__SetHighAccuracyTimeSynchResponse **)soap_malloc(soap, sizeof(_tim__SetHighAccuracyTimeSynchResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_tim__SetHighAccuracyTimeSynchResponse *)soap_instantiate__tim__SetHighAccuracyTimeSynchResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_tim__SetHighAccuracyTimeSynchResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__tim__SetHighAccuracyTimeSynchResponse, sizeof(_tim__SetHighAccuracyTimeSynchResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap *soap, _tim__SetHighAccuracyTimeSynch *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__tim__SetHighAccuracyTimeSynch)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap *soap, _tim__SetHighAccuracyTimeSynch *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_tim__SetHighAccuracyTimeSynch); + if (soap_out_PointerTo_tim__SetHighAccuracyTimeSynch(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap *soap, const char *tag, int id, _tim__SetHighAccuracyTimeSynch *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__tim__SetHighAccuracyTimeSynch); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch ** SOAP_FMAC4 soap_get_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap *soap, _tim__SetHighAccuracyTimeSynch **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_tim__SetHighAccuracyTimeSynch(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _tim__SetHighAccuracyTimeSynch ** SOAP_FMAC4 soap_in_PointerTo_tim__SetHighAccuracyTimeSynch(struct soap *soap, const char *tag, _tim__SetHighAccuracyTimeSynch **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_tim__SetHighAccuracyTimeSynch **)soap_malloc(soap, sizeof(_tim__SetHighAccuracyTimeSynch *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_tim__SetHighAccuracyTimeSynch *)soap_instantiate__tim__SetHighAccuracyTimeSynch(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_tim__SetHighAccuracyTimeSynch **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__tim__SetHighAccuracyTimeSynch, sizeof(_tim__SetHighAccuracyTimeSynch), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, _tim__GetLowAccuracyTimeSynchResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, _tim__GetLowAccuracyTimeSynchResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynchResponse); + if (soap_out_PointerTo_tim__GetLowAccuracyTimeSynchResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, const char *tag, int id, _tim__GetLowAccuracyTimeSynchResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse ** SOAP_FMAC4 soap_get_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, _tim__GetLowAccuracyTimeSynchResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_tim__GetLowAccuracyTimeSynchResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynchResponse ** SOAP_FMAC4 soap_in_PointerTo_tim__GetLowAccuracyTimeSynchResponse(struct soap *soap, const char *tag, _tim__GetLowAccuracyTimeSynchResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_tim__GetLowAccuracyTimeSynchResponse **)soap_malloc(soap, sizeof(_tim__GetLowAccuracyTimeSynchResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_tim__GetLowAccuracyTimeSynchResponse *)soap_instantiate__tim__GetLowAccuracyTimeSynchResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_tim__GetLowAccuracyTimeSynchResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__tim__GetLowAccuracyTimeSynchResponse, sizeof(_tim__GetLowAccuracyTimeSynchResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap *soap, _tim__GetLowAccuracyTimeSynch *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__tim__GetLowAccuracyTimeSynch)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap *soap, _tim__GetLowAccuracyTimeSynch *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_tim__GetLowAccuracyTimeSynch); + if (soap_out_PointerTo_tim__GetLowAccuracyTimeSynch(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap *soap, const char *tag, int id, _tim__GetLowAccuracyTimeSynch *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__tim__GetLowAccuracyTimeSynch); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch ** SOAP_FMAC4 soap_get_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap *soap, _tim__GetLowAccuracyTimeSynch **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_tim__GetLowAccuracyTimeSynch(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _tim__GetLowAccuracyTimeSynch ** SOAP_FMAC4 soap_in_PointerTo_tim__GetLowAccuracyTimeSynch(struct soap *soap, const char *tag, _tim__GetLowAccuracyTimeSynch **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_tim__GetLowAccuracyTimeSynch **)soap_malloc(soap, sizeof(_tim__GetLowAccuracyTimeSynch *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_tim__GetLowAccuracyTimeSynch *)soap_instantiate__tim__GetLowAccuracyTimeSynch(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_tim__GetLowAccuracyTimeSynch **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__tim__GetLowAccuracyTimeSynch, sizeof(_tim__GetLowAccuracyTimeSynch), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap *soap, _stra__RemoveStorageFpaclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap *soap, _stra__RemoveStorageFpaclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntryResponse); + if (soap_out_PointerTo_stra__RemoveStorageFpaclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap *soap, const char *tag, int id, _stra__RemoveStorageFpaclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap *soap, _stra__RemoveStorageFpaclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__RemoveStorageFpaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__RemoveStorageFpaclEntryResponse(struct soap *soap, const char *tag, _stra__RemoveStorageFpaclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__RemoveStorageFpaclEntryResponse **)soap_malloc(soap, sizeof(_stra__RemoveStorageFpaclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__RemoveStorageFpaclEntryResponse *)soap_instantiate__stra__RemoveStorageFpaclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__RemoveStorageFpaclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__RemoveStorageFpaclEntryResponse, sizeof(_stra__RemoveStorageFpaclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__RemoveStorageFpaclEntry(struct soap *soap, _stra__RemoveStorageFpaclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__RemoveStorageFpaclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__RemoveStorageFpaclEntry(struct soap *soap, _stra__RemoveStorageFpaclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__RemoveStorageFpaclEntry); + if (soap_out_PointerTo_stra__RemoveStorageFpaclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__RemoveStorageFpaclEntry(struct soap *soap, const char *tag, int id, _stra__RemoveStorageFpaclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__RemoveStorageFpaclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__RemoveStorageFpaclEntry(struct soap *soap, _stra__RemoveStorageFpaclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__RemoveStorageFpaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__RemoveStorageFpaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__RemoveStorageFpaclEntry(struct soap *soap, const char *tag, _stra__RemoveStorageFpaclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__RemoveStorageFpaclEntry **)soap_malloc(soap, sizeof(_stra__RemoveStorageFpaclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__RemoveStorageFpaclEntry *)soap_instantiate__stra__RemoveStorageFpaclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__RemoveStorageFpaclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__RemoveStorageFpaclEntry, sizeof(_stra__RemoveStorageFpaclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap *soap, _stra__UpdateStorageFpaclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap *soap, _stra__UpdateStorageFpaclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntryResponse); + if (soap_out_PointerTo_stra__UpdateStorageFpaclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap *soap, const char *tag, int id, _stra__UpdateStorageFpaclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap *soap, _stra__UpdateStorageFpaclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__UpdateStorageFpaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__UpdateStorageFpaclEntryResponse(struct soap *soap, const char *tag, _stra__UpdateStorageFpaclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__UpdateStorageFpaclEntryResponse **)soap_malloc(soap, sizeof(_stra__UpdateStorageFpaclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__UpdateStorageFpaclEntryResponse *)soap_instantiate__stra__UpdateStorageFpaclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__UpdateStorageFpaclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__UpdateStorageFpaclEntryResponse, sizeof(_stra__UpdateStorageFpaclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__UpdateStorageFpaclEntry(struct soap *soap, _stra__UpdateStorageFpaclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__UpdateStorageFpaclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__UpdateStorageFpaclEntry(struct soap *soap, _stra__UpdateStorageFpaclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__UpdateStorageFpaclEntry); + if (soap_out_PointerTo_stra__UpdateStorageFpaclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__UpdateStorageFpaclEntry(struct soap *soap, const char *tag, int id, _stra__UpdateStorageFpaclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__UpdateStorageFpaclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__UpdateStorageFpaclEntry(struct soap *soap, _stra__UpdateStorageFpaclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__UpdateStorageFpaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__UpdateStorageFpaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__UpdateStorageFpaclEntry(struct soap *soap, const char *tag, _stra__UpdateStorageFpaclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__UpdateStorageFpaclEntry **)soap_malloc(soap, sizeof(_stra__UpdateStorageFpaclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__UpdateStorageFpaclEntry *)soap_instantiate__stra__UpdateStorageFpaclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__UpdateStorageFpaclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__UpdateStorageFpaclEntry, sizeof(_stra__UpdateStorageFpaclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetStorageAllocEntryResponse(struct soap *soap, _stra__GetStorageAllocEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__GetStorageAllocEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetStorageAllocEntryResponse(struct soap *soap, _stra__GetStorageAllocEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__GetStorageAllocEntryResponse); + if (soap_out_PointerTo_stra__GetStorageAllocEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetStorageAllocEntryResponse(struct soap *soap, const char *tag, int id, _stra__GetStorageAllocEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__GetStorageAllocEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__GetStorageAllocEntryResponse(struct soap *soap, _stra__GetStorageAllocEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__GetStorageAllocEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__GetStorageAllocEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__GetStorageAllocEntryResponse(struct soap *soap, const char *tag, _stra__GetStorageAllocEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__GetStorageAllocEntryResponse **)soap_malloc(soap, sizeof(_stra__GetStorageAllocEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__GetStorageAllocEntryResponse *)soap_instantiate__stra__GetStorageAllocEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__GetStorageAllocEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__GetStorageAllocEntryResponse, sizeof(_stra__GetStorageAllocEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetStorageAllocEntry(struct soap *soap, _stra__GetStorageAllocEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__GetStorageAllocEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetStorageAllocEntry(struct soap *soap, _stra__GetStorageAllocEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__GetStorageAllocEntry); + if (soap_out_PointerTo_stra__GetStorageAllocEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetStorageAllocEntry(struct soap *soap, const char *tag, int id, _stra__GetStorageAllocEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__GetStorageAllocEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__GetStorageAllocEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__GetStorageAllocEntry(struct soap *soap, _stra__GetStorageAllocEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__GetStorageAllocEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__GetStorageAllocEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__GetStorageAllocEntry(struct soap *soap, const char *tag, _stra__GetStorageAllocEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__GetStorageAllocEntry **)soap_malloc(soap, sizeof(_stra__GetStorageAllocEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__GetStorageAllocEntry *)soap_instantiate__stra__GetStorageAllocEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__GetStorageAllocEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__GetStorageAllocEntry, sizeof(_stra__GetStorageAllocEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, _stra__EnumerateStorageAllocEntriesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, _stra__EnumerateStorageAllocEntriesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntriesResponse); + if (soap_out_PointerTo_stra__EnumerateStorageAllocEntriesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, const char *tag, int id, _stra__EnumerateStorageAllocEntriesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, _stra__EnumerateStorageAllocEntriesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__EnumerateStorageAllocEntriesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntriesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__EnumerateStorageAllocEntriesResponse(struct soap *soap, const char *tag, _stra__EnumerateStorageAllocEntriesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__EnumerateStorageAllocEntriesResponse **)soap_malloc(soap, sizeof(_stra__EnumerateStorageAllocEntriesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__EnumerateStorageAllocEntriesResponse *)soap_instantiate__stra__EnumerateStorageAllocEntriesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__EnumerateStorageAllocEntriesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__EnumerateStorageAllocEntriesResponse, sizeof(_stra__EnumerateStorageAllocEntriesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__EnumerateStorageAllocEntries(struct soap *soap, _stra__EnumerateStorageAllocEntries *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__EnumerateStorageAllocEntries)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__EnumerateStorageAllocEntries(struct soap *soap, _stra__EnumerateStorageAllocEntries *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__EnumerateStorageAllocEntries); + if (soap_out_PointerTo_stra__EnumerateStorageAllocEntries(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__EnumerateStorageAllocEntries(struct soap *soap, const char *tag, int id, _stra__EnumerateStorageAllocEntries *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__EnumerateStorageAllocEntries); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries ** SOAP_FMAC4 soap_get_PointerTo_stra__EnumerateStorageAllocEntries(struct soap *soap, _stra__EnumerateStorageAllocEntries **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__EnumerateStorageAllocEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__EnumerateStorageAllocEntries ** SOAP_FMAC4 soap_in_PointerTo_stra__EnumerateStorageAllocEntries(struct soap *soap, const char *tag, _stra__EnumerateStorageAllocEntries **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__EnumerateStorageAllocEntries **)soap_malloc(soap, sizeof(_stra__EnumerateStorageAllocEntries *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__EnumerateStorageAllocEntries *)soap_instantiate__stra__EnumerateStorageAllocEntries(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__EnumerateStorageAllocEntries **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__EnumerateStorageAllocEntries, sizeof(_stra__EnumerateStorageAllocEntries), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap *soap, _stra__AddStorageFpaclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AddStorageFpaclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap *soap, _stra__AddStorageFpaclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntryResponse); + if (soap_out_PointerTo_stra__AddStorageFpaclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap *soap, const char *tag, int id, _stra__AddStorageFpaclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AddStorageFpaclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap *soap, _stra__AddStorageFpaclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AddStorageFpaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AddStorageFpaclEntryResponse(struct soap *soap, const char *tag, _stra__AddStorageFpaclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AddStorageFpaclEntryResponse **)soap_malloc(soap, sizeof(_stra__AddStorageFpaclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AddStorageFpaclEntryResponse *)soap_instantiate__stra__AddStorageFpaclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AddStorageFpaclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AddStorageFpaclEntryResponse, sizeof(_stra__AddStorageFpaclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AddStorageFpaclEntry(struct soap *soap, _stra__AddStorageFpaclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AddStorageFpaclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AddStorageFpaclEntry(struct soap *soap, _stra__AddStorageFpaclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AddStorageFpaclEntry); + if (soap_out_PointerTo_stra__AddStorageFpaclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AddStorageFpaclEntry(struct soap *soap, const char *tag, int id, _stra__AddStorageFpaclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AddStorageFpaclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__AddStorageFpaclEntry(struct soap *soap, _stra__AddStorageFpaclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AddStorageFpaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AddStorageFpaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__AddStorageFpaclEntry(struct soap *soap, const char *tag, _stra__AddStorageFpaclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AddStorageFpaclEntry **)soap_malloc(soap, sizeof(_stra__AddStorageFpaclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AddStorageFpaclEntry *)soap_instantiate__stra__AddStorageFpaclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AddStorageFpaclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AddStorageFpaclEntry, sizeof(_stra__AddStorageFpaclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap *soap, _stra__RemoveStorageEaclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__RemoveStorageEaclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap *soap, _stra__RemoveStorageEaclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntryResponse); + if (soap_out_PointerTo_stra__RemoveStorageEaclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap *soap, const char *tag, int id, _stra__RemoveStorageEaclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__RemoveStorageEaclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap *soap, _stra__RemoveStorageEaclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__RemoveStorageEaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__RemoveStorageEaclEntryResponse(struct soap *soap, const char *tag, _stra__RemoveStorageEaclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__RemoveStorageEaclEntryResponse **)soap_malloc(soap, sizeof(_stra__RemoveStorageEaclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__RemoveStorageEaclEntryResponse *)soap_instantiate__stra__RemoveStorageEaclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__RemoveStorageEaclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__RemoveStorageEaclEntryResponse, sizeof(_stra__RemoveStorageEaclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__RemoveStorageEaclEntry(struct soap *soap, _stra__RemoveStorageEaclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__RemoveStorageEaclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__RemoveStorageEaclEntry(struct soap *soap, _stra__RemoveStorageEaclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__RemoveStorageEaclEntry); + if (soap_out_PointerTo_stra__RemoveStorageEaclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__RemoveStorageEaclEntry(struct soap *soap, const char *tag, int id, _stra__RemoveStorageEaclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__RemoveStorageEaclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__RemoveStorageEaclEntry(struct soap *soap, _stra__RemoveStorageEaclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__RemoveStorageEaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__RemoveStorageEaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__RemoveStorageEaclEntry(struct soap *soap, const char *tag, _stra__RemoveStorageEaclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__RemoveStorageEaclEntry **)soap_malloc(soap, sizeof(_stra__RemoveStorageEaclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__RemoveStorageEaclEntry *)soap_instantiate__stra__RemoveStorageEaclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__RemoveStorageEaclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__RemoveStorageEaclEntry, sizeof(_stra__RemoveStorageEaclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetStorageEaclEntryResponse(struct soap *soap, _stra__GetStorageEaclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__GetStorageEaclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetStorageEaclEntryResponse(struct soap *soap, _stra__GetStorageEaclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__GetStorageEaclEntryResponse); + if (soap_out_PointerTo_stra__GetStorageEaclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetStorageEaclEntryResponse(struct soap *soap, const char *tag, int id, _stra__GetStorageEaclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__GetStorageEaclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__GetStorageEaclEntryResponse(struct soap *soap, _stra__GetStorageEaclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__GetStorageEaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__GetStorageEaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__GetStorageEaclEntryResponse(struct soap *soap, const char *tag, _stra__GetStorageEaclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__GetStorageEaclEntryResponse **)soap_malloc(soap, sizeof(_stra__GetStorageEaclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__GetStorageEaclEntryResponse *)soap_instantiate__stra__GetStorageEaclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__GetStorageEaclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__GetStorageEaclEntryResponse, sizeof(_stra__GetStorageEaclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetStorageEaclEntry(struct soap *soap, _stra__GetStorageEaclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__GetStorageEaclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetStorageEaclEntry(struct soap *soap, _stra__GetStorageEaclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__GetStorageEaclEntry); + if (soap_out_PointerTo_stra__GetStorageEaclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetStorageEaclEntry(struct soap *soap, const char *tag, int id, _stra__GetStorageEaclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__GetStorageEaclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__GetStorageEaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__GetStorageEaclEntry(struct soap *soap, _stra__GetStorageEaclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__GetStorageEaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__GetStorageEaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__GetStorageEaclEntry(struct soap *soap, const char *tag, _stra__GetStorageEaclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__GetStorageEaclEntry **)soap_malloc(soap, sizeof(_stra__GetStorageEaclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__GetStorageEaclEntry *)soap_instantiate__stra__GetStorageEaclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__GetStorageEaclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__GetStorageEaclEntry, sizeof(_stra__GetStorageEaclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, _stra__EnumerateStorageEaclEntriesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, _stra__EnumerateStorageEaclEntriesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntriesResponse); + if (soap_out_PointerTo_stra__EnumerateStorageEaclEntriesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, const char *tag, int id, _stra__EnumerateStorageEaclEntriesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, _stra__EnumerateStorageEaclEntriesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__EnumerateStorageEaclEntriesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntriesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__EnumerateStorageEaclEntriesResponse(struct soap *soap, const char *tag, _stra__EnumerateStorageEaclEntriesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__EnumerateStorageEaclEntriesResponse **)soap_malloc(soap, sizeof(_stra__EnumerateStorageEaclEntriesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__EnumerateStorageEaclEntriesResponse *)soap_instantiate__stra__EnumerateStorageEaclEntriesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__EnumerateStorageEaclEntriesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__EnumerateStorageEaclEntriesResponse, sizeof(_stra__EnumerateStorageEaclEntriesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__EnumerateStorageEaclEntries(struct soap *soap, _stra__EnumerateStorageEaclEntries *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__EnumerateStorageEaclEntries)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__EnumerateStorageEaclEntries(struct soap *soap, _stra__EnumerateStorageEaclEntries *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__EnumerateStorageEaclEntries); + if (soap_out_PointerTo_stra__EnumerateStorageEaclEntries(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__EnumerateStorageEaclEntries(struct soap *soap, const char *tag, int id, _stra__EnumerateStorageEaclEntries *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__EnumerateStorageEaclEntries); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries ** SOAP_FMAC4 soap_get_PointerTo_stra__EnumerateStorageEaclEntries(struct soap *soap, _stra__EnumerateStorageEaclEntries **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__EnumerateStorageEaclEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__EnumerateStorageEaclEntries ** SOAP_FMAC4 soap_in_PointerTo_stra__EnumerateStorageEaclEntries(struct soap *soap, const char *tag, _stra__EnumerateStorageEaclEntries **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__EnumerateStorageEaclEntries **)soap_malloc(soap, sizeof(_stra__EnumerateStorageEaclEntries *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__EnumerateStorageEaclEntries *)soap_instantiate__stra__EnumerateStorageEaclEntries(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__EnumerateStorageEaclEntries **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__EnumerateStorageEaclEntries, sizeof(_stra__EnumerateStorageEaclEntries), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AddStorageEaclEntryResponse(struct soap *soap, _stra__AddStorageEaclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AddStorageEaclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AddStorageEaclEntryResponse(struct soap *soap, _stra__AddStorageEaclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AddStorageEaclEntryResponse); + if (soap_out_PointerTo_stra__AddStorageEaclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AddStorageEaclEntryResponse(struct soap *soap, const char *tag, int id, _stra__AddStorageEaclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AddStorageEaclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AddStorageEaclEntryResponse(struct soap *soap, _stra__AddStorageEaclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AddStorageEaclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AddStorageEaclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AddStorageEaclEntryResponse(struct soap *soap, const char *tag, _stra__AddStorageEaclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AddStorageEaclEntryResponse **)soap_malloc(soap, sizeof(_stra__AddStorageEaclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AddStorageEaclEntryResponse *)soap_instantiate__stra__AddStorageEaclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AddStorageEaclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AddStorageEaclEntryResponse, sizeof(_stra__AddStorageEaclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AddStorageEaclEntry(struct soap *soap, _stra__AddStorageEaclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AddStorageEaclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AddStorageEaclEntry(struct soap *soap, _stra__AddStorageEaclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AddStorageEaclEntry); + if (soap_out_PointerTo_stra__AddStorageEaclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AddStorageEaclEntry(struct soap *soap, const char *tag, int id, _stra__AddStorageEaclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AddStorageEaclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AddStorageEaclEntry ** SOAP_FMAC4 soap_get_PointerTo_stra__AddStorageEaclEntry(struct soap *soap, _stra__AddStorageEaclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AddStorageEaclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AddStorageEaclEntry ** SOAP_FMAC4 soap_in_PointerTo_stra__AddStorageEaclEntry(struct soap *soap, const char *tag, _stra__AddStorageEaclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AddStorageEaclEntry **)soap_malloc(soap, sizeof(_stra__AddStorageEaclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AddStorageEaclEntry *)soap_instantiate__stra__AddStorageEaclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AddStorageEaclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AddStorageEaclEntry, sizeof(_stra__AddStorageEaclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminRemoveApplicationResponse(struct soap *soap, _stra__AdminRemoveApplicationResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AdminRemoveApplicationResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminRemoveApplicationResponse(struct soap *soap, _stra__AdminRemoveApplicationResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AdminRemoveApplicationResponse); + if (soap_out_PointerTo_stra__AdminRemoveApplicationResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminRemoveApplicationResponse(struct soap *soap, const char *tag, int id, _stra__AdminRemoveApplicationResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AdminRemoveApplicationResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminRemoveApplicationResponse(struct soap *soap, _stra__AdminRemoveApplicationResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AdminRemoveApplicationResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AdminRemoveApplicationResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminRemoveApplicationResponse(struct soap *soap, const char *tag, _stra__AdminRemoveApplicationResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AdminRemoveApplicationResponse **)soap_malloc(soap, sizeof(_stra__AdminRemoveApplicationResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AdminRemoveApplicationResponse *)soap_instantiate__stra__AdminRemoveApplicationResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AdminRemoveApplicationResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AdminRemoveApplicationResponse, sizeof(_stra__AdminRemoveApplicationResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminRemoveApplication(struct soap *soap, _stra__AdminRemoveApplication *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AdminRemoveApplication)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminRemoveApplication(struct soap *soap, _stra__AdminRemoveApplication *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AdminRemoveApplication); + if (soap_out_PointerTo_stra__AdminRemoveApplication(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminRemoveApplication(struct soap *soap, const char *tag, int id, _stra__AdminRemoveApplication *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AdminRemoveApplication); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AdminRemoveApplication ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminRemoveApplication(struct soap *soap, _stra__AdminRemoveApplication **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AdminRemoveApplication(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AdminRemoveApplication ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminRemoveApplication(struct soap *soap, const char *tag, _stra__AdminRemoveApplication **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AdminRemoveApplication **)soap_malloc(soap, sizeof(_stra__AdminRemoveApplication *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AdminRemoveApplication *)soap_instantiate__stra__AdminRemoveApplication(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AdminRemoveApplication **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AdminRemoveApplication, sizeof(_stra__AdminRemoveApplication), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap *soap, _stra__AdminGetApplicationAttributesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AdminGetApplicationAttributesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap *soap, _stra__AdminGetApplicationAttributesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributesResponse); + if (soap_out_PointerTo_stra__AdminGetApplicationAttributesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap *soap, const char *tag, int id, _stra__AdminGetApplicationAttributesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AdminGetApplicationAttributesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap *soap, _stra__AdminGetApplicationAttributesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AdminGetApplicationAttributesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminGetApplicationAttributesResponse(struct soap *soap, const char *tag, _stra__AdminGetApplicationAttributesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AdminGetApplicationAttributesResponse **)soap_malloc(soap, sizeof(_stra__AdminGetApplicationAttributesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AdminGetApplicationAttributesResponse *)soap_instantiate__stra__AdminGetApplicationAttributesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AdminGetApplicationAttributesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AdminGetApplicationAttributesResponse, sizeof(_stra__AdminGetApplicationAttributesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminGetApplicationAttributes(struct soap *soap, _stra__AdminGetApplicationAttributes *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AdminGetApplicationAttributes)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminGetApplicationAttributes(struct soap *soap, _stra__AdminGetApplicationAttributes *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AdminGetApplicationAttributes); + if (soap_out_PointerTo_stra__AdminGetApplicationAttributes(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminGetApplicationAttributes(struct soap *soap, const char *tag, int id, _stra__AdminGetApplicationAttributes *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AdminGetApplicationAttributes); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributes ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminGetApplicationAttributes(struct soap *soap, _stra__AdminGetApplicationAttributes **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AdminGetApplicationAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AdminGetApplicationAttributes ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminGetApplicationAttributes(struct soap *soap, const char *tag, _stra__AdminGetApplicationAttributes **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AdminGetApplicationAttributes **)soap_malloc(soap, sizeof(_stra__AdminGetApplicationAttributes *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AdminGetApplicationAttributes *)soap_instantiate__stra__AdminGetApplicationAttributes(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AdminGetApplicationAttributes **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AdminGetApplicationAttributes, sizeof(_stra__AdminGetApplicationAttributes), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, _stra__AdminGetRegisteredApplicationsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, _stra__AdminGetRegisteredApplicationsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplicationsResponse); + if (soap_out_PointerTo_stra__AdminGetRegisteredApplicationsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, const char *tag, int id, _stra__AdminGetRegisteredApplicationsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, _stra__AdminGetRegisteredApplicationsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AdminGetRegisteredApplicationsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplicationsResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminGetRegisteredApplicationsResponse(struct soap *soap, const char *tag, _stra__AdminGetRegisteredApplicationsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AdminGetRegisteredApplicationsResponse **)soap_malloc(soap, sizeof(_stra__AdminGetRegisteredApplicationsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AdminGetRegisteredApplicationsResponse *)soap_instantiate__stra__AdminGetRegisteredApplicationsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AdminGetRegisteredApplicationsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AdminGetRegisteredApplicationsResponse, sizeof(_stra__AdminGetRegisteredApplicationsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__AdminGetRegisteredApplications(struct soap *soap, _stra__AdminGetRegisteredApplications *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__AdminGetRegisteredApplications)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__AdminGetRegisteredApplications(struct soap *soap, _stra__AdminGetRegisteredApplications *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__AdminGetRegisteredApplications); + if (soap_out_PointerTo_stra__AdminGetRegisteredApplications(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__AdminGetRegisteredApplications(struct soap *soap, const char *tag, int id, _stra__AdminGetRegisteredApplications *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__AdminGetRegisteredApplications); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplications ** SOAP_FMAC4 soap_get_PointerTo_stra__AdminGetRegisteredApplications(struct soap *soap, _stra__AdminGetRegisteredApplications **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__AdminGetRegisteredApplications(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__AdminGetRegisteredApplications ** SOAP_FMAC4 soap_in_PointerTo_stra__AdminGetRegisteredApplications(struct soap *soap, const char *tag, _stra__AdminGetRegisteredApplications **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__AdminGetRegisteredApplications **)soap_malloc(soap, sizeof(_stra__AdminGetRegisteredApplications *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__AdminGetRegisteredApplications *)soap_instantiate__stra__AdminGetRegisteredApplications(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__AdminGetRegisteredApplications **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__AdminGetRegisteredApplications, sizeof(_stra__AdminGetRegisteredApplications), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap *soap, _stra__SetGlobalStorageAttributesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__SetGlobalStorageAttributesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap *soap, _stra__SetGlobalStorageAttributesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributesResponse); + if (soap_out_PointerTo_stra__SetGlobalStorageAttributesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap *soap, const char *tag, int id, _stra__SetGlobalStorageAttributesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__SetGlobalStorageAttributesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap *soap, _stra__SetGlobalStorageAttributesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__SetGlobalStorageAttributesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__SetGlobalStorageAttributesResponse(struct soap *soap, const char *tag, _stra__SetGlobalStorageAttributesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__SetGlobalStorageAttributesResponse **)soap_malloc(soap, sizeof(_stra__SetGlobalStorageAttributesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__SetGlobalStorageAttributesResponse *)soap_instantiate__stra__SetGlobalStorageAttributesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__SetGlobalStorageAttributesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__SetGlobalStorageAttributesResponse, sizeof(_stra__SetGlobalStorageAttributesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__SetGlobalStorageAttributes(struct soap *soap, _stra__SetGlobalStorageAttributes *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__SetGlobalStorageAttributes)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__SetGlobalStorageAttributes(struct soap *soap, _stra__SetGlobalStorageAttributes *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__SetGlobalStorageAttributes); + if (soap_out_PointerTo_stra__SetGlobalStorageAttributes(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__SetGlobalStorageAttributes(struct soap *soap, const char *tag, int id, _stra__SetGlobalStorageAttributes *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__SetGlobalStorageAttributes); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributes ** SOAP_FMAC4 soap_get_PointerTo_stra__SetGlobalStorageAttributes(struct soap *soap, _stra__SetGlobalStorageAttributes **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__SetGlobalStorageAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__SetGlobalStorageAttributes ** SOAP_FMAC4 soap_in_PointerTo_stra__SetGlobalStorageAttributes(struct soap *soap, const char *tag, _stra__SetGlobalStorageAttributes **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__SetGlobalStorageAttributes **)soap_malloc(soap, sizeof(_stra__SetGlobalStorageAttributes *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__SetGlobalStorageAttributes *)soap_instantiate__stra__SetGlobalStorageAttributes(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__SetGlobalStorageAttributes **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__SetGlobalStorageAttributes, sizeof(_stra__SetGlobalStorageAttributes), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap *soap, _stra__GetGlobalStorageAttributesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__GetGlobalStorageAttributesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap *soap, _stra__GetGlobalStorageAttributesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributesResponse); + if (soap_out_PointerTo_stra__GetGlobalStorageAttributesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap *soap, const char *tag, int id, _stra__GetGlobalStorageAttributesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__GetGlobalStorageAttributesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse ** SOAP_FMAC4 soap_get_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap *soap, _stra__GetGlobalStorageAttributesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__GetGlobalStorageAttributesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributesResponse ** SOAP_FMAC4 soap_in_PointerTo_stra__GetGlobalStorageAttributesResponse(struct soap *soap, const char *tag, _stra__GetGlobalStorageAttributesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__GetGlobalStorageAttributesResponse **)soap_malloc(soap, sizeof(_stra__GetGlobalStorageAttributesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__GetGlobalStorageAttributesResponse *)soap_instantiate__stra__GetGlobalStorageAttributesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__GetGlobalStorageAttributesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__GetGlobalStorageAttributesResponse, sizeof(_stra__GetGlobalStorageAttributesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_stra__GetGlobalStorageAttributes(struct soap *soap, _stra__GetGlobalStorageAttributes *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__stra__GetGlobalStorageAttributes)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_stra__GetGlobalStorageAttributes(struct soap *soap, _stra__GetGlobalStorageAttributes *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_stra__GetGlobalStorageAttributes); + if (soap_out_PointerTo_stra__GetGlobalStorageAttributes(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_stra__GetGlobalStorageAttributes(struct soap *soap, const char *tag, int id, _stra__GetGlobalStorageAttributes *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__stra__GetGlobalStorageAttributes); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributes ** SOAP_FMAC4 soap_get_PointerTo_stra__GetGlobalStorageAttributes(struct soap *soap, _stra__GetGlobalStorageAttributes **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_stra__GetGlobalStorageAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _stra__GetGlobalStorageAttributes ** SOAP_FMAC4 soap_in_PointerTo_stra__GetGlobalStorageAttributes(struct soap *soap, const char *tag, _stra__GetGlobalStorageAttributes **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_stra__GetGlobalStorageAttributes **)soap_malloc(soap, sizeof(_stra__GetGlobalStorageAttributes *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_stra__GetGlobalStorageAttributes *)soap_instantiate__stra__GetGlobalStorageAttributes(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_stra__GetGlobalStorageAttributes **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__stra__GetGlobalStorageAttributes, sizeof(_stra__GetGlobalStorageAttributes), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_str__ExecuteStorageOperationResponse(struct soap *soap, _str__ExecuteStorageOperationResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__str__ExecuteStorageOperationResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_str__ExecuteStorageOperationResponse(struct soap *soap, _str__ExecuteStorageOperationResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_str__ExecuteStorageOperationResponse); + if (soap_out_PointerTo_str__ExecuteStorageOperationResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_str__ExecuteStorageOperationResponse(struct soap *soap, const char *tag, int id, _str__ExecuteStorageOperationResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__str__ExecuteStorageOperationResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _str__ExecuteStorageOperationResponse ** SOAP_FMAC4 soap_get_PointerTo_str__ExecuteStorageOperationResponse(struct soap *soap, _str__ExecuteStorageOperationResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_str__ExecuteStorageOperationResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _str__ExecuteStorageOperationResponse ** SOAP_FMAC4 soap_in_PointerTo_str__ExecuteStorageOperationResponse(struct soap *soap, const char *tag, _str__ExecuteStorageOperationResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_str__ExecuteStorageOperationResponse **)soap_malloc(soap, sizeof(_str__ExecuteStorageOperationResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_str__ExecuteStorageOperationResponse *)soap_instantiate__str__ExecuteStorageOperationResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_str__ExecuteStorageOperationResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__str__ExecuteStorageOperationResponse, sizeof(_str__ExecuteStorageOperationResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_str__ExecuteStorageOperation(struct soap *soap, _str__ExecuteStorageOperation *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__str__ExecuteStorageOperation)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_str__ExecuteStorageOperation(struct soap *soap, _str__ExecuteStorageOperation *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_str__ExecuteStorageOperation); + if (soap_out_PointerTo_str__ExecuteStorageOperation(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_str__ExecuteStorageOperation(struct soap *soap, const char *tag, int id, _str__ExecuteStorageOperation *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__str__ExecuteStorageOperation); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _str__ExecuteStorageOperation ** SOAP_FMAC4 soap_get_PointerTo_str__ExecuteStorageOperation(struct soap *soap, _str__ExecuteStorageOperation **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_str__ExecuteStorageOperation(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _str__ExecuteStorageOperation ** SOAP_FMAC4 soap_in_PointerTo_str__ExecuteStorageOperation(struct soap *soap, const char *tag, _str__ExecuteStorageOperation **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_str__ExecuteStorageOperation **)soap_malloc(soap, sizeof(_str__ExecuteStorageOperation *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_str__ExecuteStorageOperation *)soap_instantiate__str__ExecuteStorageOperation(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_str__ExecuteStorageOperation **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__str__ExecuteStorageOperation, sizeof(_str__ExecuteStorageOperation), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetAclEnabledStateResponse(struct soap *soap, _sai__GetAclEnabledStateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetAclEnabledStateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetAclEnabledStateResponse(struct soap *soap, _sai__GetAclEnabledStateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetAclEnabledStateResponse); + if (soap_out_PointerTo_sai__GetAclEnabledStateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetAclEnabledStateResponse(struct soap *soap, const char *tag, int id, _sai__GetAclEnabledStateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetAclEnabledStateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetAclEnabledStateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetAclEnabledStateResponse(struct soap *soap, _sai__GetAclEnabledStateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetAclEnabledStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetAclEnabledStateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetAclEnabledStateResponse(struct soap *soap, const char *tag, _sai__GetAclEnabledStateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetAclEnabledStateResponse **)soap_malloc(soap, sizeof(_sai__GetAclEnabledStateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetAclEnabledStateResponse *)soap_instantiate__sai__GetAclEnabledStateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetAclEnabledStateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetAclEnabledStateResponse, sizeof(_sai__GetAclEnabledStateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetAclEnabledState(struct soap *soap, _sai__GetAclEnabledState *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetAclEnabledState)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetAclEnabledState(struct soap *soap, _sai__GetAclEnabledState *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetAclEnabledState); + if (soap_out_PointerTo_sai__GetAclEnabledState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetAclEnabledState(struct soap *soap, const char *tag, int id, _sai__GetAclEnabledState *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetAclEnabledState); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetAclEnabledState ** SOAP_FMAC4 soap_get_PointerTo_sai__GetAclEnabledState(struct soap *soap, _sai__GetAclEnabledState **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetAclEnabledState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetAclEnabledState ** SOAP_FMAC4 soap_in_PointerTo_sai__GetAclEnabledState(struct soap *soap, const char *tag, _sai__GetAclEnabledState **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetAclEnabledState **)soap_malloc(soap, sizeof(_sai__GetAclEnabledState *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetAclEnabledState *)soap_instantiate__sai__GetAclEnabledState(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetAclEnabledState **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetAclEnabledState, sizeof(_sai__GetAclEnabledState), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAclEnabledStateResponse(struct soap *soap, _sai__SetAclEnabledStateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetAclEnabledStateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAclEnabledStateResponse(struct soap *soap, _sai__SetAclEnabledStateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetAclEnabledStateResponse); + if (soap_out_PointerTo_sai__SetAclEnabledStateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAclEnabledStateResponse(struct soap *soap, const char *tag, int id, _sai__SetAclEnabledStateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetAclEnabledStateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetAclEnabledStateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAclEnabledStateResponse(struct soap *soap, _sai__SetAclEnabledStateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetAclEnabledStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetAclEnabledStateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAclEnabledStateResponse(struct soap *soap, const char *tag, _sai__SetAclEnabledStateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetAclEnabledStateResponse **)soap_malloc(soap, sizeof(_sai__SetAclEnabledStateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetAclEnabledStateResponse *)soap_instantiate__sai__SetAclEnabledStateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetAclEnabledStateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetAclEnabledStateResponse, sizeof(_sai__SetAclEnabledStateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAclEnabledState(struct soap *soap, _sai__SetAclEnabledState *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetAclEnabledState)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAclEnabledState(struct soap *soap, _sai__SetAclEnabledState *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetAclEnabledState); + if (soap_out_PointerTo_sai__SetAclEnabledState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAclEnabledState(struct soap *soap, const char *tag, int id, _sai__SetAclEnabledState *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetAclEnabledState); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetAclEnabledState ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAclEnabledState(struct soap *soap, _sai__SetAclEnabledState **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetAclEnabledState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetAclEnabledState ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAclEnabledState(struct soap *soap, const char *tag, _sai__SetAclEnabledState **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetAclEnabledState **)soap_malloc(soap, sizeof(_sai__SetAclEnabledState *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetAclEnabledState *)soap_instantiate__sai__SetAclEnabledState(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetAclEnabledState **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetAclEnabledState, sizeof(_sai__SetAclEnabledState), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap *soap, _sai__SetConfigurationServerFQDNResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetConfigurationServerFQDNResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap *soap, _sai__SetConfigurationServerFQDNResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDNResponse); + if (soap_out_PointerTo_sai__SetConfigurationServerFQDNResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap *soap, const char *tag, int id, _sai__SetConfigurationServerFQDNResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetConfigurationServerFQDNResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap *soap, _sai__SetConfigurationServerFQDNResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetConfigurationServerFQDNResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDNResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetConfigurationServerFQDNResponse(struct soap *soap, const char *tag, _sai__SetConfigurationServerFQDNResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetConfigurationServerFQDNResponse **)soap_malloc(soap, sizeof(_sai__SetConfigurationServerFQDNResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetConfigurationServerFQDNResponse *)soap_instantiate__sai__SetConfigurationServerFQDNResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetConfigurationServerFQDNResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetConfigurationServerFQDNResponse, sizeof(_sai__SetConfigurationServerFQDNResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetConfigurationServerFQDN(struct soap *soap, _sai__SetConfigurationServerFQDN *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetConfigurationServerFQDN)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetConfigurationServerFQDN(struct soap *soap, _sai__SetConfigurationServerFQDN *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetConfigurationServerFQDN); + if (soap_out_PointerTo_sai__SetConfigurationServerFQDN(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetConfigurationServerFQDN(struct soap *soap, const char *tag, int id, _sai__SetConfigurationServerFQDN *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetConfigurationServerFQDN); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDN ** SOAP_FMAC4 soap_get_PointerTo_sai__SetConfigurationServerFQDN(struct soap *soap, _sai__SetConfigurationServerFQDN **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetConfigurationServerFQDN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetConfigurationServerFQDN ** SOAP_FMAC4 soap_in_PointerTo_sai__SetConfigurationServerFQDN(struct soap *soap, const char *tag, _sai__SetConfigurationServerFQDN **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetConfigurationServerFQDN **)soap_malloc(soap, sizeof(_sai__SetConfigurationServerFQDN *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetConfigurationServerFQDN *)soap_instantiate__sai__SetConfigurationServerFQDN(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetConfigurationServerFQDN **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetConfigurationServerFQDN, sizeof(_sai__SetConfigurationServerFQDN), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap *soap, _sai__GetConfigurationServerFQDNResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetConfigurationServerFQDNResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap *soap, _sai__GetConfigurationServerFQDNResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDNResponse); + if (soap_out_PointerTo_sai__GetConfigurationServerFQDNResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap *soap, const char *tag, int id, _sai__GetConfigurationServerFQDNResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetConfigurationServerFQDNResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap *soap, _sai__GetConfigurationServerFQDNResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetConfigurationServerFQDNResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDNResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetConfigurationServerFQDNResponse(struct soap *soap, const char *tag, _sai__GetConfigurationServerFQDNResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetConfigurationServerFQDNResponse **)soap_malloc(soap, sizeof(_sai__GetConfigurationServerFQDNResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetConfigurationServerFQDNResponse *)soap_instantiate__sai__GetConfigurationServerFQDNResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetConfigurationServerFQDNResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetConfigurationServerFQDNResponse, sizeof(_sai__GetConfigurationServerFQDNResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetConfigurationServerFQDN(struct soap *soap, _sai__GetConfigurationServerFQDN *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetConfigurationServerFQDN)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetConfigurationServerFQDN(struct soap *soap, _sai__GetConfigurationServerFQDN *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetConfigurationServerFQDN); + if (soap_out_PointerTo_sai__GetConfigurationServerFQDN(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetConfigurationServerFQDN(struct soap *soap, const char *tag, int id, _sai__GetConfigurationServerFQDN *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetConfigurationServerFQDN); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDN ** SOAP_FMAC4 soap_get_PointerTo_sai__GetConfigurationServerFQDN(struct soap *soap, _sai__GetConfigurationServerFQDN **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetConfigurationServerFQDN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetConfigurationServerFQDN ** SOAP_FMAC4 soap_in_PointerTo_sai__GetConfigurationServerFQDN(struct soap *soap, const char *tag, _sai__GetConfigurationServerFQDN **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetConfigurationServerFQDN **)soap_malloc(soap, sizeof(_sai__GetConfigurationServerFQDN *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetConfigurationServerFQDN *)soap_instantiate__sai__GetConfigurationServerFQDN(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetConfigurationServerFQDN **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetConfigurationServerFQDN, sizeof(_sai__GetConfigurationServerFQDN), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnableVpnRoutingResponse(struct soap *soap, _sai__EnableVpnRoutingResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnableVpnRoutingResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnableVpnRoutingResponse(struct soap *soap, _sai__EnableVpnRoutingResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnableVpnRoutingResponse); + if (soap_out_PointerTo_sai__EnableVpnRoutingResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnableVpnRoutingResponse(struct soap *soap, const char *tag, int id, _sai__EnableVpnRoutingResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnableVpnRoutingResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnableVpnRoutingResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnableVpnRoutingResponse(struct soap *soap, _sai__EnableVpnRoutingResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnableVpnRoutingResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnableVpnRoutingResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnableVpnRoutingResponse(struct soap *soap, const char *tag, _sai__EnableVpnRoutingResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnableVpnRoutingResponse **)soap_malloc(soap, sizeof(_sai__EnableVpnRoutingResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnableVpnRoutingResponse *)soap_instantiate__sai__EnableVpnRoutingResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnableVpnRoutingResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnableVpnRoutingResponse, sizeof(_sai__EnableVpnRoutingResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnableVpnRouting(struct soap *soap, _sai__EnableVpnRouting *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnableVpnRouting)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnableVpnRouting(struct soap *soap, _sai__EnableVpnRouting *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnableVpnRouting); + if (soap_out_PointerTo_sai__EnableVpnRouting(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnableVpnRouting(struct soap *soap, const char *tag, int id, _sai__EnableVpnRouting *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnableVpnRouting); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnableVpnRouting ** SOAP_FMAC4 soap_get_PointerTo_sai__EnableVpnRouting(struct soap *soap, _sai__EnableVpnRouting **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnableVpnRouting(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnableVpnRouting ** SOAP_FMAC4 soap_in_PointerTo_sai__EnableVpnRouting(struct soap *soap, const char *tag, _sai__EnableVpnRouting **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnableVpnRouting **)soap_malloc(soap, sizeof(_sai__EnableVpnRouting *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnableVpnRouting *)soap_instantiate__sai__EnableVpnRouting(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnableVpnRouting **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnableVpnRouting, sizeof(_sai__EnableVpnRouting), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTLSCredentialsResponse(struct soap *soap, _sai__GetTLSCredentialsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTLSCredentialsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTLSCredentialsResponse(struct soap *soap, _sai__GetTLSCredentialsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTLSCredentialsResponse); + if (soap_out_PointerTo_sai__GetTLSCredentialsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTLSCredentialsResponse(struct soap *soap, const char *tag, int id, _sai__GetTLSCredentialsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTLSCredentialsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTLSCredentialsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTLSCredentialsResponse(struct soap *soap, _sai__GetTLSCredentialsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTLSCredentialsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTLSCredentialsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTLSCredentialsResponse(struct soap *soap, const char *tag, _sai__GetTLSCredentialsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTLSCredentialsResponse **)soap_malloc(soap, sizeof(_sai__GetTLSCredentialsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTLSCredentialsResponse *)soap_instantiate__sai__GetTLSCredentialsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTLSCredentialsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTLSCredentialsResponse, sizeof(_sai__GetTLSCredentialsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTLSCredentials(struct soap *soap, _sai__GetTLSCredentials *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTLSCredentials)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTLSCredentials(struct soap *soap, _sai__GetTLSCredentials *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTLSCredentials); + if (soap_out_PointerTo_sai__GetTLSCredentials(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTLSCredentials(struct soap *soap, const char *tag, int id, _sai__GetTLSCredentials *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTLSCredentials); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTLSCredentials ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTLSCredentials(struct soap *soap, _sai__GetTLSCredentials **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTLSCredentials(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTLSCredentials ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTLSCredentials(struct soap *soap, const char *tag, _sai__GetTLSCredentials **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTLSCredentials **)soap_malloc(soap, sizeof(_sai__GetTLSCredentials *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTLSCredentials *)soap_instantiate__sai__GetTLSCredentials(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTLSCredentials **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTLSCredentials, sizeof(_sai__GetTLSCredentials), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSCredentialsResponse(struct soap *soap, _sai__SetTLSCredentialsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTLSCredentialsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSCredentialsResponse(struct soap *soap, _sai__SetTLSCredentialsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTLSCredentialsResponse); + if (soap_out_PointerTo_sai__SetTLSCredentialsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSCredentialsResponse(struct soap *soap, const char *tag, int id, _sai__SetTLSCredentialsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTLSCredentialsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTLSCredentialsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSCredentialsResponse(struct soap *soap, _sai__SetTLSCredentialsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTLSCredentialsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTLSCredentialsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSCredentialsResponse(struct soap *soap, const char *tag, _sai__SetTLSCredentialsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTLSCredentialsResponse **)soap_malloc(soap, sizeof(_sai__SetTLSCredentialsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTLSCredentialsResponse *)soap_instantiate__sai__SetTLSCredentialsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTLSCredentialsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTLSCredentialsResponse, sizeof(_sai__SetTLSCredentialsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSCredentials(struct soap *soap, _sai__SetTLSCredentials *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTLSCredentials)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSCredentials(struct soap *soap, _sai__SetTLSCredentials *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTLSCredentials); + if (soap_out_PointerTo_sai__SetTLSCredentials(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSCredentials(struct soap *soap, const char *tag, int id, _sai__SetTLSCredentials *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTLSCredentials); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTLSCredentials ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSCredentials(struct soap *soap, _sai__SetTLSCredentials **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTLSCredentials(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTLSCredentials ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSCredentials(struct soap *soap, const char *tag, _sai__SetTLSCredentials **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTLSCredentials **)soap_malloc(soap, sizeof(_sai__SetTLSCredentials *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTLSCredentials *)soap_instantiate__sai__SetTLSCredentials(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTLSCredentials **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTLSCredentials, sizeof(_sai__SetTLSCredentials), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap *soap, _sai__CertStoreUpdateCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreUpdateCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap *soap, _sai__CertStoreUpdateCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificateResponse); + if (soap_out_PointerTo_sai__CertStoreUpdateCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreUpdateCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreUpdateCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap *soap, _sai__CertStoreUpdateCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreUpdateCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreUpdateCertificateResponse(struct soap *soap, const char *tag, _sai__CertStoreUpdateCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreUpdateCertificateResponse **)soap_malloc(soap, sizeof(_sai__CertStoreUpdateCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreUpdateCertificateResponse *)soap_instantiate__sai__CertStoreUpdateCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreUpdateCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreUpdateCertificateResponse, sizeof(_sai__CertStoreUpdateCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreUpdateCertificate(struct soap *soap, _sai__CertStoreUpdateCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreUpdateCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreUpdateCertificate(struct soap *soap, _sai__CertStoreUpdateCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreUpdateCertificate); + if (soap_out_PointerTo_sai__CertStoreUpdateCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreUpdateCertificate(struct soap *soap, const char *tag, int id, _sai__CertStoreUpdateCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreUpdateCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreUpdateCertificate(struct soap *soap, _sai__CertStoreUpdateCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreUpdateCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreUpdateCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreUpdateCertificate(struct soap *soap, const char *tag, _sai__CertStoreUpdateCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreUpdateCertificate **)soap_malloc(soap, sizeof(_sai__CertStoreUpdateCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreUpdateCertificate *)soap_instantiate__sai__CertStoreUpdateCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreUpdateCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreUpdateCertificate, sizeof(_sai__CertStoreUpdateCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, _sai__CertStoreGetPKCS10RequestResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, _sai__CertStoreGetPKCS10RequestResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10RequestResponse); + if (soap_out_PointerTo_sai__CertStoreGetPKCS10RequestResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreGetPKCS10RequestResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, _sai__CertStoreGetPKCS10RequestResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreGetPKCS10RequestResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10RequestResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetPKCS10RequestResponse(struct soap *soap, const char *tag, _sai__CertStoreGetPKCS10RequestResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreGetPKCS10RequestResponse **)soap_malloc(soap, sizeof(_sai__CertStoreGetPKCS10RequestResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreGetPKCS10RequestResponse *)soap_instantiate__sai__CertStoreGetPKCS10RequestResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreGetPKCS10RequestResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreGetPKCS10RequestResponse, sizeof(_sai__CertStoreGetPKCS10RequestResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetPKCS10Request(struct soap *soap, _sai__CertStoreGetPKCS10Request *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreGetPKCS10Request)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetPKCS10Request(struct soap *soap, _sai__CertStoreGetPKCS10Request *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreGetPKCS10Request); + if (soap_out_PointerTo_sai__CertStoreGetPKCS10Request(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetPKCS10Request(struct soap *soap, const char *tag, int id, _sai__CertStoreGetPKCS10Request *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreGetPKCS10Request); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetPKCS10Request(struct soap *soap, _sai__CertStoreGetPKCS10Request **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreGetPKCS10Request(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreGetPKCS10Request ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetPKCS10Request(struct soap *soap, const char *tag, _sai__CertStoreGetPKCS10Request **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreGetPKCS10Request **)soap_malloc(soap, sizeof(_sai__CertStoreGetPKCS10Request *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreGetPKCS10Request *)soap_instantiate__sai__CertStoreGetPKCS10Request(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreGetPKCS10Request **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreGetPKCS10Request, sizeof(_sai__CertStoreGetPKCS10Request), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap *soap, _sai__CertStoreRemoveCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreRemoveCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap *soap, _sai__CertStoreRemoveCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificateResponse); + if (soap_out_PointerTo_sai__CertStoreRemoveCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreRemoveCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreRemoveCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap *soap, _sai__CertStoreRemoveCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreRemoveCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreRemoveCertificateResponse(struct soap *soap, const char *tag, _sai__CertStoreRemoveCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreRemoveCertificateResponse **)soap_malloc(soap, sizeof(_sai__CertStoreRemoveCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreRemoveCertificateResponse *)soap_instantiate__sai__CertStoreRemoveCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreRemoveCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreRemoveCertificateResponse, sizeof(_sai__CertStoreRemoveCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreRemoveCertificate(struct soap *soap, _sai__CertStoreRemoveCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreRemoveCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreRemoveCertificate(struct soap *soap, _sai__CertStoreRemoveCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreRemoveCertificate); + if (soap_out_PointerTo_sai__CertStoreRemoveCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreRemoveCertificate(struct soap *soap, const char *tag, int id, _sai__CertStoreRemoveCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreRemoveCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreRemoveCertificate(struct soap *soap, _sai__CertStoreRemoveCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreRemoveCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreRemoveCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreRemoveCertificate(struct soap *soap, const char *tag, _sai__CertStoreRemoveCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreRemoveCertificate **)soap_malloc(soap, sizeof(_sai__CertStoreRemoveCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreRemoveCertificate *)soap_instantiate__sai__CertStoreRemoveCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreRemoveCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreRemoveCertificate, sizeof(_sai__CertStoreRemoveCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, _sai__CertStoreEnumerateCertificatesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, _sai__CertStoreEnumerateCertificatesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificatesResponse); + if (soap_out_PointerTo_sai__CertStoreEnumerateCertificatesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreEnumerateCertificatesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, _sai__CertStoreEnumerateCertificatesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreEnumerateCertificatesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificatesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreEnumerateCertificatesResponse(struct soap *soap, const char *tag, _sai__CertStoreEnumerateCertificatesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreEnumerateCertificatesResponse **)soap_malloc(soap, sizeof(_sai__CertStoreEnumerateCertificatesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreEnumerateCertificatesResponse *)soap_instantiate__sai__CertStoreEnumerateCertificatesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreEnumerateCertificatesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreEnumerateCertificatesResponse, sizeof(_sai__CertStoreEnumerateCertificatesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreEnumerateCertificates(struct soap *soap, _sai__CertStoreEnumerateCertificates *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreEnumerateCertificates)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreEnumerateCertificates(struct soap *soap, _sai__CertStoreEnumerateCertificates *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreEnumerateCertificates); + if (soap_out_PointerTo_sai__CertStoreEnumerateCertificates(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreEnumerateCertificates(struct soap *soap, const char *tag, int id, _sai__CertStoreEnumerateCertificates *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreEnumerateCertificates); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreEnumerateCertificates(struct soap *soap, _sai__CertStoreEnumerateCertificates **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreEnumerateCertificates(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreEnumerateCertificates ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreEnumerateCertificates(struct soap *soap, const char *tag, _sai__CertStoreEnumerateCertificates **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreEnumerateCertificates **)soap_malloc(soap, sizeof(_sai__CertStoreEnumerateCertificates *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreEnumerateCertificates *)soap_instantiate__sai__CertStoreEnumerateCertificates(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreEnumerateCertificates **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreEnumerateCertificates, sizeof(_sai__CertStoreEnumerateCertificates), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetCertificateResponse(struct soap *soap, _sai__CertStoreGetCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreGetCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetCertificateResponse(struct soap *soap, _sai__CertStoreGetCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreGetCertificateResponse); + if (soap_out_PointerTo_sai__CertStoreGetCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetCertificateResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreGetCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreGetCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetCertificateResponse(struct soap *soap, _sai__CertStoreGetCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreGetCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreGetCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetCertificateResponse(struct soap *soap, const char *tag, _sai__CertStoreGetCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreGetCertificateResponse **)soap_malloc(soap, sizeof(_sai__CertStoreGetCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreGetCertificateResponse *)soap_instantiate__sai__CertStoreGetCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreGetCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreGetCertificateResponse, sizeof(_sai__CertStoreGetCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetCertificate(struct soap *soap, _sai__CertStoreGetCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreGetCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetCertificate(struct soap *soap, _sai__CertStoreGetCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreGetCertificate); + if (soap_out_PointerTo_sai__CertStoreGetCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetCertificate(struct soap *soap, const char *tag, int id, _sai__CertStoreGetCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreGetCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreGetCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetCertificate(struct soap *soap, _sai__CertStoreGetCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreGetCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreGetCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetCertificate(struct soap *soap, const char *tag, _sai__CertStoreGetCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreGetCertificate **)soap_malloc(soap, sizeof(_sai__CertStoreGetCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreGetCertificate *)soap_instantiate__sai__CertStoreGetCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreGetCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreGetCertificate, sizeof(_sai__CertStoreGetCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreAddCertificateResponse(struct soap *soap, _sai__CertStoreAddCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreAddCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreAddCertificateResponse(struct soap *soap, _sai__CertStoreAddCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreAddCertificateResponse); + if (soap_out_PointerTo_sai__CertStoreAddCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreAddCertificateResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreAddCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreAddCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreAddCertificateResponse(struct soap *soap, _sai__CertStoreAddCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreAddCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreAddCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreAddCertificateResponse(struct soap *soap, const char *tag, _sai__CertStoreAddCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreAddCertificateResponse **)soap_malloc(soap, sizeof(_sai__CertStoreAddCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreAddCertificateResponse *)soap_instantiate__sai__CertStoreAddCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreAddCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreAddCertificateResponse, sizeof(_sai__CertStoreAddCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreAddCertificate(struct soap *soap, _sai__CertStoreAddCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreAddCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreAddCertificate(struct soap *soap, _sai__CertStoreAddCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreAddCertificate); + if (soap_out_PointerTo_sai__CertStoreAddCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreAddCertificate(struct soap *soap, const char *tag, int id, _sai__CertStoreAddCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreAddCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreAddCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreAddCertificate(struct soap *soap, _sai__CertStoreAddCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreAddCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreAddCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreAddCertificate(struct soap *soap, const char *tag, _sai__CertStoreAddCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreAddCertificate **)soap_malloc(soap, sizeof(_sai__CertStoreAddCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreAddCertificate *)soap_instantiate__sai__CertStoreAddCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreAddCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreAddCertificate, sizeof(_sai__CertStoreAddCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap *soap, _sai__CertStoreRemoveKeyResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreRemoveKeyResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap *soap, _sai__CertStoreRemoveKeyResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreRemoveKeyResponse); + if (soap_out_PointerTo_sai__CertStoreRemoveKeyResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreRemoveKeyResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreRemoveKeyResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap *soap, _sai__CertStoreRemoveKeyResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreRemoveKeyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreRemoveKeyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreRemoveKeyResponse(struct soap *soap, const char *tag, _sai__CertStoreRemoveKeyResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreRemoveKeyResponse **)soap_malloc(soap, sizeof(_sai__CertStoreRemoveKeyResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreRemoveKeyResponse *)soap_instantiate__sai__CertStoreRemoveKeyResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreRemoveKeyResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreRemoveKeyResponse, sizeof(_sai__CertStoreRemoveKeyResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreRemoveKey(struct soap *soap, _sai__CertStoreRemoveKey *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreRemoveKey)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreRemoveKey(struct soap *soap, _sai__CertStoreRemoveKey *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreRemoveKey); + if (soap_out_PointerTo_sai__CertStoreRemoveKey(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreRemoveKey(struct soap *soap, const char *tag, int id, _sai__CertStoreRemoveKey *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreRemoveKey); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreRemoveKey ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreRemoveKey(struct soap *soap, _sai__CertStoreRemoveKey **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreRemoveKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreRemoveKey ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreRemoveKey(struct soap *soap, const char *tag, _sai__CertStoreRemoveKey **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreRemoveKey **)soap_malloc(soap, sizeof(_sai__CertStoreRemoveKey *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreRemoveKey *)soap_instantiate__sai__CertStoreRemoveKey(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreRemoveKey **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreRemoveKey, sizeof(_sai__CertStoreRemoveKey), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetKeyResponse(struct soap *soap, _sai__CertStoreGetKeyResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreGetKeyResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetKeyResponse(struct soap *soap, _sai__CertStoreGetKeyResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreGetKeyResponse); + if (soap_out_PointerTo_sai__CertStoreGetKeyResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetKeyResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreGetKeyResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreGetKeyResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreGetKeyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetKeyResponse(struct soap *soap, _sai__CertStoreGetKeyResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreGetKeyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreGetKeyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetKeyResponse(struct soap *soap, const char *tag, _sai__CertStoreGetKeyResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreGetKeyResponse **)soap_malloc(soap, sizeof(_sai__CertStoreGetKeyResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreGetKeyResponse *)soap_instantiate__sai__CertStoreGetKeyResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreGetKeyResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreGetKeyResponse, sizeof(_sai__CertStoreGetKeyResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreGetKey(struct soap *soap, _sai__CertStoreGetKey *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreGetKey)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreGetKey(struct soap *soap, _sai__CertStoreGetKey *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreGetKey); + if (soap_out_PointerTo_sai__CertStoreGetKey(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreGetKey(struct soap *soap, const char *tag, int id, _sai__CertStoreGetKey *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreGetKey); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreGetKey ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreGetKey(struct soap *soap, _sai__CertStoreGetKey **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreGetKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreGetKey ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreGetKey(struct soap *soap, const char *tag, _sai__CertStoreGetKey **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreGetKey **)soap_malloc(soap, sizeof(_sai__CertStoreGetKey *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreGetKey *)soap_instantiate__sai__CertStoreGetKey(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreGetKey **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreGetKey, sizeof(_sai__CertStoreGetKey), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap *soap, _sai__CertStoreEnumerateKeysResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreEnumerateKeysResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap *soap, _sai__CertStoreEnumerateKeysResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeysResponse); + if (soap_out_PointerTo_sai__CertStoreEnumerateKeysResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreEnumerateKeysResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreEnumerateKeysResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap *soap, _sai__CertStoreEnumerateKeysResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreEnumerateKeysResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeysResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreEnumerateKeysResponse(struct soap *soap, const char *tag, _sai__CertStoreEnumerateKeysResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreEnumerateKeysResponse **)soap_malloc(soap, sizeof(_sai__CertStoreEnumerateKeysResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreEnumerateKeysResponse *)soap_instantiate__sai__CertStoreEnumerateKeysResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreEnumerateKeysResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreEnumerateKeysResponse, sizeof(_sai__CertStoreEnumerateKeysResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreEnumerateKeys(struct soap *soap, _sai__CertStoreEnumerateKeys *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreEnumerateKeys)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreEnumerateKeys(struct soap *soap, _sai__CertStoreEnumerateKeys *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreEnumerateKeys); + if (soap_out_PointerTo_sai__CertStoreEnumerateKeys(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreEnumerateKeys(struct soap *soap, const char *tag, int id, _sai__CertStoreEnumerateKeys *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreEnumerateKeys); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeys ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreEnumerateKeys(struct soap *soap, _sai__CertStoreEnumerateKeys **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreEnumerateKeys(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreEnumerateKeys ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreEnumerateKeys(struct soap *soap, const char *tag, _sai__CertStoreEnumerateKeys **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreEnumerateKeys **)soap_malloc(soap, sizeof(_sai__CertStoreEnumerateKeys *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreEnumerateKeys *)soap_instantiate__sai__CertStoreEnumerateKeys(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreEnumerateKeys **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreEnumerateKeys, sizeof(_sai__CertStoreEnumerateKeys), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreAddKeyResponse(struct soap *soap, _sai__CertStoreAddKeyResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreAddKeyResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreAddKeyResponse(struct soap *soap, _sai__CertStoreAddKeyResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreAddKeyResponse); + if (soap_out_PointerTo_sai__CertStoreAddKeyResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreAddKeyResponse(struct soap *soap, const char *tag, int id, _sai__CertStoreAddKeyResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreAddKeyResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreAddKeyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreAddKeyResponse(struct soap *soap, _sai__CertStoreAddKeyResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreAddKeyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreAddKeyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreAddKeyResponse(struct soap *soap, const char *tag, _sai__CertStoreAddKeyResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreAddKeyResponse **)soap_malloc(soap, sizeof(_sai__CertStoreAddKeyResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreAddKeyResponse *)soap_instantiate__sai__CertStoreAddKeyResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreAddKeyResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreAddKeyResponse, sizeof(_sai__CertStoreAddKeyResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CertStoreAddKey(struct soap *soap, _sai__CertStoreAddKey *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CertStoreAddKey)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CertStoreAddKey(struct soap *soap, _sai__CertStoreAddKey *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CertStoreAddKey); + if (soap_out_PointerTo_sai__CertStoreAddKey(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CertStoreAddKey(struct soap *soap, const char *tag, int id, _sai__CertStoreAddKey *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CertStoreAddKey); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CertStoreAddKey ** SOAP_FMAC4 soap_get_PointerTo_sai__CertStoreAddKey(struct soap *soap, _sai__CertStoreAddKey **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CertStoreAddKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CertStoreAddKey ** SOAP_FMAC4 soap_in_PointerTo_sai__CertStoreAddKey(struct soap *soap, const char *tag, _sai__CertStoreAddKey **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CertStoreAddKey **)soap_malloc(soap, sizeof(_sai__CertStoreAddKey *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CertStoreAddKey *)soap_instantiate__sai__CertStoreAddKey(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CertStoreAddKey **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CertStoreAddKey, sizeof(_sai__CertStoreAddKey), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap *soap, _sai__GetGlobalPowerPolicyResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetGlobalPowerPolicyResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap *soap, _sai__GetGlobalPowerPolicyResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicyResponse); + if (soap_out_PointerTo_sai__GetGlobalPowerPolicyResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap *soap, const char *tag, int id, _sai__GetGlobalPowerPolicyResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetGlobalPowerPolicyResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap *soap, _sai__GetGlobalPowerPolicyResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetGlobalPowerPolicyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetGlobalPowerPolicyResponse(struct soap *soap, const char *tag, _sai__GetGlobalPowerPolicyResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetGlobalPowerPolicyResponse **)soap_malloc(soap, sizeof(_sai__GetGlobalPowerPolicyResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetGlobalPowerPolicyResponse *)soap_instantiate__sai__GetGlobalPowerPolicyResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetGlobalPowerPolicyResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetGlobalPowerPolicyResponse, sizeof(_sai__GetGlobalPowerPolicyResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetGlobalPowerPolicy(struct soap *soap, _sai__GetGlobalPowerPolicy *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetGlobalPowerPolicy)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetGlobalPowerPolicy(struct soap *soap, _sai__GetGlobalPowerPolicy *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetGlobalPowerPolicy); + if (soap_out_PointerTo_sai__GetGlobalPowerPolicy(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetGlobalPowerPolicy(struct soap *soap, const char *tag, int id, _sai__GetGlobalPowerPolicy *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetGlobalPowerPolicy); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicy ** SOAP_FMAC4 soap_get_PointerTo_sai__GetGlobalPowerPolicy(struct soap *soap, _sai__GetGlobalPowerPolicy **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetGlobalPowerPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetGlobalPowerPolicy ** SOAP_FMAC4 soap_in_PointerTo_sai__GetGlobalPowerPolicy(struct soap *soap, const char *tag, _sai__GetGlobalPowerPolicy **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetGlobalPowerPolicy **)soap_malloc(soap, sizeof(_sai__GetGlobalPowerPolicy *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetGlobalPowerPolicy *)soap_instantiate__sai__GetGlobalPowerPolicy(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetGlobalPowerPolicy **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetGlobalPowerPolicy, sizeof(_sai__GetGlobalPowerPolicy), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap *soap, _sai__SetGlobalPowerPolicyResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetGlobalPowerPolicyResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap *soap, _sai__SetGlobalPowerPolicyResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicyResponse); + if (soap_out_PointerTo_sai__SetGlobalPowerPolicyResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap *soap, const char *tag, int id, _sai__SetGlobalPowerPolicyResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetGlobalPowerPolicyResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap *soap, _sai__SetGlobalPowerPolicyResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetGlobalPowerPolicyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetGlobalPowerPolicyResponse(struct soap *soap, const char *tag, _sai__SetGlobalPowerPolicyResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetGlobalPowerPolicyResponse **)soap_malloc(soap, sizeof(_sai__SetGlobalPowerPolicyResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetGlobalPowerPolicyResponse *)soap_instantiate__sai__SetGlobalPowerPolicyResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetGlobalPowerPolicyResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetGlobalPowerPolicyResponse, sizeof(_sai__SetGlobalPowerPolicyResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetGlobalPowerPolicy(struct soap *soap, _sai__SetGlobalPowerPolicy *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetGlobalPowerPolicy)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetGlobalPowerPolicy(struct soap *soap, _sai__SetGlobalPowerPolicy *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetGlobalPowerPolicy); + if (soap_out_PointerTo_sai__SetGlobalPowerPolicy(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetGlobalPowerPolicy(struct soap *soap, const char *tag, int id, _sai__SetGlobalPowerPolicy *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetGlobalPowerPolicy); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicy ** SOAP_FMAC4 soap_get_PointerTo_sai__SetGlobalPowerPolicy(struct soap *soap, _sai__SetGlobalPowerPolicy **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetGlobalPowerPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetGlobalPowerPolicy ** SOAP_FMAC4 soap_in_PointerTo_sai__SetGlobalPowerPolicy(struct soap *soap, const char *tag, _sai__SetGlobalPowerPolicy **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetGlobalPowerPolicy **)soap_malloc(soap, sizeof(_sai__SetGlobalPowerPolicy *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetGlobalPowerPolicy *)soap_instantiate__sai__SetGlobalPowerPolicy(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetGlobalPowerPolicy **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetGlobalPowerPolicy, sizeof(_sai__SetGlobalPowerPolicy), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetActivePowerPackageResponse(struct soap *soap, _sai__SetActivePowerPackageResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetActivePowerPackageResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetActivePowerPackageResponse(struct soap *soap, _sai__SetActivePowerPackageResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetActivePowerPackageResponse); + if (soap_out_PointerTo_sai__SetActivePowerPackageResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetActivePowerPackageResponse(struct soap *soap, const char *tag, int id, _sai__SetActivePowerPackageResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetActivePowerPackageResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetActivePowerPackageResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetActivePowerPackageResponse(struct soap *soap, _sai__SetActivePowerPackageResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetActivePowerPackageResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetActivePowerPackageResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetActivePowerPackageResponse(struct soap *soap, const char *tag, _sai__SetActivePowerPackageResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetActivePowerPackageResponse **)soap_malloc(soap, sizeof(_sai__SetActivePowerPackageResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetActivePowerPackageResponse *)soap_instantiate__sai__SetActivePowerPackageResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetActivePowerPackageResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetActivePowerPackageResponse, sizeof(_sai__SetActivePowerPackageResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetActivePowerPackage(struct soap *soap, _sai__SetActivePowerPackage *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetActivePowerPackage)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetActivePowerPackage(struct soap *soap, _sai__SetActivePowerPackage *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetActivePowerPackage); + if (soap_out_PointerTo_sai__SetActivePowerPackage(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetActivePowerPackage(struct soap *soap, const char *tag, int id, _sai__SetActivePowerPackage *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetActivePowerPackage); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetActivePowerPackage ** SOAP_FMAC4 soap_get_PointerTo_sai__SetActivePowerPackage(struct soap *soap, _sai__SetActivePowerPackage **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetActivePowerPackage(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetActivePowerPackage ** SOAP_FMAC4 soap_in_PointerTo_sai__SetActivePowerPackage(struct soap *soap, const char *tag, _sai__SetActivePowerPackage **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetActivePowerPackage **)soap_malloc(soap, sizeof(_sai__SetActivePowerPackage *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetActivePowerPackage *)soap_instantiate__sai__SetActivePowerPackage(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetActivePowerPackage **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetActivePowerPackage, sizeof(_sai__SetActivePowerPackage), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetActivePowerPackageResponse(struct soap *soap, _sai__GetActivePowerPackageResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetActivePowerPackageResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetActivePowerPackageResponse(struct soap *soap, _sai__GetActivePowerPackageResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetActivePowerPackageResponse); + if (soap_out_PointerTo_sai__GetActivePowerPackageResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetActivePowerPackageResponse(struct soap *soap, const char *tag, int id, _sai__GetActivePowerPackageResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetActivePowerPackageResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetActivePowerPackageResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetActivePowerPackageResponse(struct soap *soap, _sai__GetActivePowerPackageResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetActivePowerPackageResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetActivePowerPackageResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetActivePowerPackageResponse(struct soap *soap, const char *tag, _sai__GetActivePowerPackageResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetActivePowerPackageResponse **)soap_malloc(soap, sizeof(_sai__GetActivePowerPackageResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetActivePowerPackageResponse *)soap_instantiate__sai__GetActivePowerPackageResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetActivePowerPackageResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetActivePowerPackageResponse, sizeof(_sai__GetActivePowerPackageResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetActivePowerPackage(struct soap *soap, _sai__GetActivePowerPackage *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetActivePowerPackage)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetActivePowerPackage(struct soap *soap, _sai__GetActivePowerPackage *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetActivePowerPackage); + if (soap_out_PointerTo_sai__GetActivePowerPackage(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetActivePowerPackage(struct soap *soap, const char *tag, int id, _sai__GetActivePowerPackage *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetActivePowerPackage); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetActivePowerPackage ** SOAP_FMAC4 soap_get_PointerTo_sai__GetActivePowerPackage(struct soap *soap, _sai__GetActivePowerPackage **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetActivePowerPackage(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetActivePowerPackage ** SOAP_FMAC4 soap_in_PointerTo_sai__GetActivePowerPackage(struct soap *soap, const char *tag, _sai__GetActivePowerPackage **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetActivePowerPackage **)soap_malloc(soap, sizeof(_sai__GetActivePowerPackage *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetActivePowerPackage *)soap_instantiate__sai__GetActivePowerPackage(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetActivePowerPackage **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetActivePowerPackage, sizeof(_sai__GetActivePowerPackage), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPowerPackageResponse(struct soap *soap, _sai__GetPowerPackageResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetPowerPackageResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPowerPackageResponse(struct soap *soap, _sai__GetPowerPackageResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetPowerPackageResponse); + if (soap_out_PointerTo_sai__GetPowerPackageResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPowerPackageResponse(struct soap *soap, const char *tag, int id, _sai__GetPowerPackageResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetPowerPackageResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetPowerPackageResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPowerPackageResponse(struct soap *soap, _sai__GetPowerPackageResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetPowerPackageResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetPowerPackageResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPowerPackageResponse(struct soap *soap, const char *tag, _sai__GetPowerPackageResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetPowerPackageResponse **)soap_malloc(soap, sizeof(_sai__GetPowerPackageResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetPowerPackageResponse *)soap_instantiate__sai__GetPowerPackageResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetPowerPackageResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetPowerPackageResponse, sizeof(_sai__GetPowerPackageResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPowerPackage(struct soap *soap, _sai__GetPowerPackage *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetPowerPackage)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPowerPackage(struct soap *soap, _sai__GetPowerPackage *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetPowerPackage); + if (soap_out_PointerTo_sai__GetPowerPackage(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPowerPackage(struct soap *soap, const char *tag, int id, _sai__GetPowerPackage *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetPowerPackage); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetPowerPackage ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPowerPackage(struct soap *soap, _sai__GetPowerPackage **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetPowerPackage(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetPowerPackage ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPowerPackage(struct soap *soap, const char *tag, _sai__GetPowerPackage **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetPowerPackage **)soap_malloc(soap, sizeof(_sai__GetPowerPackage *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetPowerPackage *)soap_instantiate__sai__GetPowerPackage(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetPowerPackage **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetPowerPackage, sizeof(_sai__GetPowerPackage), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap *soap, _sai__EnumeratePowerPackagesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnumeratePowerPackagesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap *soap, _sai__EnumeratePowerPackagesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnumeratePowerPackagesResponse); + if (soap_out_PointerTo_sai__EnumeratePowerPackagesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap *soap, const char *tag, int id, _sai__EnumeratePowerPackagesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnumeratePowerPackagesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap *soap, _sai__EnumeratePowerPackagesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnumeratePowerPackagesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnumeratePowerPackagesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumeratePowerPackagesResponse(struct soap *soap, const char *tag, _sai__EnumeratePowerPackagesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnumeratePowerPackagesResponse **)soap_malloc(soap, sizeof(_sai__EnumeratePowerPackagesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnumeratePowerPackagesResponse *)soap_instantiate__sai__EnumeratePowerPackagesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnumeratePowerPackagesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnumeratePowerPackagesResponse, sizeof(_sai__EnumeratePowerPackagesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumeratePowerPackages(struct soap *soap, _sai__EnumeratePowerPackages *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnumeratePowerPackages)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumeratePowerPackages(struct soap *soap, _sai__EnumeratePowerPackages *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnumeratePowerPackages); + if (soap_out_PointerTo_sai__EnumeratePowerPackages(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumeratePowerPackages(struct soap *soap, const char *tag, int id, _sai__EnumeratePowerPackages *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnumeratePowerPackages); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnumeratePowerPackages ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumeratePowerPackages(struct soap *soap, _sai__EnumeratePowerPackages **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnumeratePowerPackages(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnumeratePowerPackages ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumeratePowerPackages(struct soap *soap, const char *tag, _sai__EnumeratePowerPackages **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnumeratePowerPackages **)soap_malloc(soap, sizeof(_sai__EnumeratePowerPackages *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnumeratePowerPackages *)soap_instantiate__sai__EnumeratePowerPackages(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnumeratePowerPackages **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnumeratePowerPackages, sizeof(_sai__EnumeratePowerPackages), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap *soap, _sai__GetEnvironmentDetectionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetEnvironmentDetectionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap *soap, _sai__GetEnvironmentDetectionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetEnvironmentDetectionResponse); + if (soap_out_PointerTo_sai__GetEnvironmentDetectionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap *soap, const char *tag, int id, _sai__GetEnvironmentDetectionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetEnvironmentDetectionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap *soap, _sai__GetEnvironmentDetectionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetEnvironmentDetectionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetEnvironmentDetectionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetEnvironmentDetectionResponse(struct soap *soap, const char *tag, _sai__GetEnvironmentDetectionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetEnvironmentDetectionResponse **)soap_malloc(soap, sizeof(_sai__GetEnvironmentDetectionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetEnvironmentDetectionResponse *)soap_instantiate__sai__GetEnvironmentDetectionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetEnvironmentDetectionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetEnvironmentDetectionResponse, sizeof(_sai__GetEnvironmentDetectionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetEnvironmentDetection(struct soap *soap, _sai__GetEnvironmentDetection *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetEnvironmentDetection)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetEnvironmentDetection(struct soap *soap, _sai__GetEnvironmentDetection *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetEnvironmentDetection); + if (soap_out_PointerTo_sai__GetEnvironmentDetection(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetEnvironmentDetection(struct soap *soap, const char *tag, int id, _sai__GetEnvironmentDetection *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetEnvironmentDetection); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetEnvironmentDetection ** SOAP_FMAC4 soap_get_PointerTo_sai__GetEnvironmentDetection(struct soap *soap, _sai__GetEnvironmentDetection **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetEnvironmentDetection(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetEnvironmentDetection ** SOAP_FMAC4 soap_in_PointerTo_sai__GetEnvironmentDetection(struct soap *soap, const char *tag, _sai__GetEnvironmentDetection **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetEnvironmentDetection **)soap_malloc(soap, sizeof(_sai__GetEnvironmentDetection *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetEnvironmentDetection *)soap_instantiate__sai__GetEnvironmentDetection(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetEnvironmentDetection **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetEnvironmentDetection, sizeof(_sai__GetEnvironmentDetection), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap *soap, _sai__SetEnvironmentDetectionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetEnvironmentDetectionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap *soap, _sai__SetEnvironmentDetectionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetEnvironmentDetectionResponse); + if (soap_out_PointerTo_sai__SetEnvironmentDetectionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap *soap, const char *tag, int id, _sai__SetEnvironmentDetectionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetEnvironmentDetectionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap *soap, _sai__SetEnvironmentDetectionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetEnvironmentDetectionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetEnvironmentDetectionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetEnvironmentDetectionResponse(struct soap *soap, const char *tag, _sai__SetEnvironmentDetectionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetEnvironmentDetectionResponse **)soap_malloc(soap, sizeof(_sai__SetEnvironmentDetectionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetEnvironmentDetectionResponse *)soap_instantiate__sai__SetEnvironmentDetectionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetEnvironmentDetectionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetEnvironmentDetectionResponse, sizeof(_sai__SetEnvironmentDetectionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetEnvironmentDetection(struct soap *soap, _sai__SetEnvironmentDetection *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetEnvironmentDetection)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetEnvironmentDetection(struct soap *soap, _sai__SetEnvironmentDetection *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetEnvironmentDetection); + if (soap_out_PointerTo_sai__SetEnvironmentDetection(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetEnvironmentDetection(struct soap *soap, const char *tag, int id, _sai__SetEnvironmentDetection *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetEnvironmentDetection); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetEnvironmentDetection ** SOAP_FMAC4 soap_get_PointerTo_sai__SetEnvironmentDetection(struct soap *soap, _sai__SetEnvironmentDetection **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetEnvironmentDetection(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetEnvironmentDetection ** SOAP_FMAC4 soap_in_PointerTo_sai__SetEnvironmentDetection(struct soap *soap, const char *tag, _sai__SetEnvironmentDetection **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetEnvironmentDetection **)soap_malloc(soap, sizeof(_sai__SetEnvironmentDetection *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetEnvironmentDetection *)soap_instantiate__sai__SetEnvironmentDetection(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetEnvironmentDetection **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetEnvironmentDetection, sizeof(_sai__SetEnvironmentDetection), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap *soap, _sai__SetRealmAuthOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetRealmAuthOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap *soap, _sai__SetRealmAuthOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetRealmAuthOptionsResponse); + if (soap_out_PointerTo_sai__SetRealmAuthOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap *soap, const char *tag, int id, _sai__SetRealmAuthOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetRealmAuthOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap *soap, _sai__SetRealmAuthOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetRealmAuthOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetRealmAuthOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetRealmAuthOptionsResponse(struct soap *soap, const char *tag, _sai__SetRealmAuthOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetRealmAuthOptionsResponse **)soap_malloc(soap, sizeof(_sai__SetRealmAuthOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetRealmAuthOptionsResponse *)soap_instantiate__sai__SetRealmAuthOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetRealmAuthOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetRealmAuthOptionsResponse, sizeof(_sai__SetRealmAuthOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetRealmAuthOptions(struct soap *soap, _sai__SetRealmAuthOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetRealmAuthOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetRealmAuthOptions(struct soap *soap, _sai__SetRealmAuthOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetRealmAuthOptions); + if (soap_out_PointerTo_sai__SetRealmAuthOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetRealmAuthOptions(struct soap *soap, const char *tag, int id, _sai__SetRealmAuthOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetRealmAuthOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetRealmAuthOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__SetRealmAuthOptions(struct soap *soap, _sai__SetRealmAuthOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetRealmAuthOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetRealmAuthOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__SetRealmAuthOptions(struct soap *soap, const char *tag, _sai__SetRealmAuthOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetRealmAuthOptions **)soap_malloc(soap, sizeof(_sai__SetRealmAuthOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetRealmAuthOptions *)soap_instantiate__sai__SetRealmAuthOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetRealmAuthOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetRealmAuthOptions, sizeof(_sai__SetRealmAuthOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap *soap, _sai__GetRealmAuthOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetRealmAuthOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap *soap, _sai__GetRealmAuthOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetRealmAuthOptionsResponse); + if (soap_out_PointerTo_sai__GetRealmAuthOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap *soap, const char *tag, int id, _sai__GetRealmAuthOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetRealmAuthOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap *soap, _sai__GetRealmAuthOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetRealmAuthOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetRealmAuthOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetRealmAuthOptionsResponse(struct soap *soap, const char *tag, _sai__GetRealmAuthOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetRealmAuthOptionsResponse **)soap_malloc(soap, sizeof(_sai__GetRealmAuthOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetRealmAuthOptionsResponse *)soap_instantiate__sai__GetRealmAuthOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetRealmAuthOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetRealmAuthOptionsResponse, sizeof(_sai__GetRealmAuthOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetRealmAuthOptions(struct soap *soap, _sai__GetRealmAuthOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetRealmAuthOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetRealmAuthOptions(struct soap *soap, _sai__GetRealmAuthOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetRealmAuthOptions); + if (soap_out_PointerTo_sai__GetRealmAuthOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetRealmAuthOptions(struct soap *soap, const char *tag, int id, _sai__GetRealmAuthOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetRealmAuthOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetRealmAuthOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__GetRealmAuthOptions(struct soap *soap, _sai__GetRealmAuthOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetRealmAuthOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetRealmAuthOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__GetRealmAuthOptions(struct soap *soap, const char *tag, _sai__GetRealmAuthOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetRealmAuthOptions **)soap_malloc(soap, sizeof(_sai__GetRealmAuthOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetRealmAuthOptions *)soap_instantiate__sai__GetRealmAuthOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetRealmAuthOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetRealmAuthOptions, sizeof(_sai__GetRealmAuthOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap *soap, _sai__ExtendProvisioningPeriodResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__ExtendProvisioningPeriodResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap *soap, _sai__ExtendProvisioningPeriodResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriodResponse); + if (soap_out_PointerTo_sai__ExtendProvisioningPeriodResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap *soap, const char *tag, int id, _sai__ExtendProvisioningPeriodResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__ExtendProvisioningPeriodResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap *soap, _sai__ExtendProvisioningPeriodResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__ExtendProvisioningPeriodResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriodResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__ExtendProvisioningPeriodResponse(struct soap *soap, const char *tag, _sai__ExtendProvisioningPeriodResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__ExtendProvisioningPeriodResponse **)soap_malloc(soap, sizeof(_sai__ExtendProvisioningPeriodResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__ExtendProvisioningPeriodResponse *)soap_instantiate__sai__ExtendProvisioningPeriodResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__ExtendProvisioningPeriodResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__ExtendProvisioningPeriodResponse, sizeof(_sai__ExtendProvisioningPeriodResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__ExtendProvisioningPeriod(struct soap *soap, _sai__ExtendProvisioningPeriod *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__ExtendProvisioningPeriod)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__ExtendProvisioningPeriod(struct soap *soap, _sai__ExtendProvisioningPeriod *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__ExtendProvisioningPeriod); + if (soap_out_PointerTo_sai__ExtendProvisioningPeriod(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__ExtendProvisioningPeriod(struct soap *soap, const char *tag, int id, _sai__ExtendProvisioningPeriod *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__ExtendProvisioningPeriod); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriod ** SOAP_FMAC4 soap_get_PointerTo_sai__ExtendProvisioningPeriod(struct soap *soap, _sai__ExtendProvisioningPeriod **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__ExtendProvisioningPeriod(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__ExtendProvisioningPeriod ** SOAP_FMAC4 soap_in_PointerTo_sai__ExtendProvisioningPeriod(struct soap *soap, const char *tag, _sai__ExtendProvisioningPeriod **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__ExtendProvisioningPeriod **)soap_malloc(soap, sizeof(_sai__ExtendProvisioningPeriod *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__ExtendProvisioningPeriod *)soap_instantiate__sai__ExtendProvisioningPeriod(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__ExtendProvisioningPeriod **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__ExtendProvisioningPeriod, sizeof(_sai__ExtendProvisioningPeriod), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningPIDResponse(struct soap *soap, _sai__GetProvisioningPIDResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetProvisioningPIDResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningPIDResponse(struct soap *soap, _sai__GetProvisioningPIDResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetProvisioningPIDResponse); + if (soap_out_PointerTo_sai__GetProvisioningPIDResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningPIDResponse(struct soap *soap, const char *tag, int id, _sai__GetProvisioningPIDResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetProvisioningPIDResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetProvisioningPIDResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningPIDResponse(struct soap *soap, _sai__GetProvisioningPIDResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetProvisioningPIDResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetProvisioningPIDResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningPIDResponse(struct soap *soap, const char *tag, _sai__GetProvisioningPIDResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetProvisioningPIDResponse **)soap_malloc(soap, sizeof(_sai__GetProvisioningPIDResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetProvisioningPIDResponse *)soap_instantiate__sai__GetProvisioningPIDResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetProvisioningPIDResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetProvisioningPIDResponse, sizeof(_sai__GetProvisioningPIDResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningPID(struct soap *soap, _sai__GetProvisioningPID *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetProvisioningPID)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningPID(struct soap *soap, _sai__GetProvisioningPID *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetProvisioningPID); + if (soap_out_PointerTo_sai__GetProvisioningPID(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningPID(struct soap *soap, const char *tag, int id, _sai__GetProvisioningPID *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetProvisioningPID); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetProvisioningPID ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningPID(struct soap *soap, _sai__GetProvisioningPID **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetProvisioningPID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetProvisioningPID ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningPID(struct soap *soap, const char *tag, _sai__GetProvisioningPID **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetProvisioningPID **)soap_malloc(soap, sizeof(_sai__GetProvisioningPID *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetProvisioningPID *)soap_instantiate__sai__GetProvisioningPID(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetProvisioningPID **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetProvisioningPID, sizeof(_sai__GetProvisioningPID), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap *soap, _sai__GetProvisioningAuditRecordResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetProvisioningAuditRecordResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap *soap, _sai__GetProvisioningAuditRecordResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecordResponse); + if (soap_out_PointerTo_sai__GetProvisioningAuditRecordResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap *soap, const char *tag, int id, _sai__GetProvisioningAuditRecordResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetProvisioningAuditRecordResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap *soap, _sai__GetProvisioningAuditRecordResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetProvisioningAuditRecordResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecordResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningAuditRecordResponse(struct soap *soap, const char *tag, _sai__GetProvisioningAuditRecordResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetProvisioningAuditRecordResponse **)soap_malloc(soap, sizeof(_sai__GetProvisioningAuditRecordResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetProvisioningAuditRecordResponse *)soap_instantiate__sai__GetProvisioningAuditRecordResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetProvisioningAuditRecordResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetProvisioningAuditRecordResponse, sizeof(_sai__GetProvisioningAuditRecordResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningAuditRecord(struct soap *soap, _sai__GetProvisioningAuditRecord *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetProvisioningAuditRecord)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningAuditRecord(struct soap *soap, _sai__GetProvisioningAuditRecord *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetProvisioningAuditRecord); + if (soap_out_PointerTo_sai__GetProvisioningAuditRecord(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningAuditRecord(struct soap *soap, const char *tag, int id, _sai__GetProvisioningAuditRecord *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetProvisioningAuditRecord); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecord ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningAuditRecord(struct soap *soap, _sai__GetProvisioningAuditRecord **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetProvisioningAuditRecord(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetProvisioningAuditRecord ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningAuditRecord(struct soap *soap, const char *tag, _sai__GetProvisioningAuditRecord **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetProvisioningAuditRecord **)soap_malloc(soap, sizeof(_sai__GetProvisioningAuditRecord *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetProvisioningAuditRecord *)soap_instantiate__sai__GetProvisioningAuditRecord(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetProvisioningAuditRecord **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetProvisioningAuditRecord, sizeof(_sai__GetProvisioningAuditRecord), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__SetZeroTouchConfigurationModeResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__SetZeroTouchConfigurationModeResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationModeResponse); + if (soap_out_PointerTo_sai__SetZeroTouchConfigurationModeResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, const char *tag, int id, _sai__SetZeroTouchConfigurationModeResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__SetZeroTouchConfigurationModeResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetZeroTouchConfigurationModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationModeResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetZeroTouchConfigurationModeResponse(struct soap *soap, const char *tag, _sai__SetZeroTouchConfigurationModeResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetZeroTouchConfigurationModeResponse **)soap_malloc(soap, sizeof(_sai__SetZeroTouchConfigurationModeResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetZeroTouchConfigurationModeResponse *)soap_instantiate__sai__SetZeroTouchConfigurationModeResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetZeroTouchConfigurationModeResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetZeroTouchConfigurationModeResponse, sizeof(_sai__SetZeroTouchConfigurationModeResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap *soap, _sai__SetZeroTouchConfigurationMode *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetZeroTouchConfigurationMode)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap *soap, _sai__SetZeroTouchConfigurationMode *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetZeroTouchConfigurationMode); + if (soap_out_PointerTo_sai__SetZeroTouchConfigurationMode(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap *soap, const char *tag, int id, _sai__SetZeroTouchConfigurationMode *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetZeroTouchConfigurationMode); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode ** SOAP_FMAC4 soap_get_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap *soap, _sai__SetZeroTouchConfigurationMode **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetZeroTouchConfigurationMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetZeroTouchConfigurationMode ** SOAP_FMAC4 soap_in_PointerTo_sai__SetZeroTouchConfigurationMode(struct soap *soap, const char *tag, _sai__SetZeroTouchConfigurationMode **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetZeroTouchConfigurationMode **)soap_malloc(soap, sizeof(_sai__SetZeroTouchConfigurationMode *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetZeroTouchConfigurationMode *)soap_instantiate__sai__SetZeroTouchConfigurationMode(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetZeroTouchConfigurationMode **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetZeroTouchConfigurationMode, sizeof(_sai__SetZeroTouchConfigurationMode), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__GetZeroTouchConfigurationModeResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__GetZeroTouchConfigurationModeResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationModeResponse); + if (soap_out_PointerTo_sai__GetZeroTouchConfigurationModeResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, const char *tag, int id, _sai__GetZeroTouchConfigurationModeResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, _sai__GetZeroTouchConfigurationModeResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetZeroTouchConfigurationModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationModeResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetZeroTouchConfigurationModeResponse(struct soap *soap, const char *tag, _sai__GetZeroTouchConfigurationModeResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetZeroTouchConfigurationModeResponse **)soap_malloc(soap, sizeof(_sai__GetZeroTouchConfigurationModeResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetZeroTouchConfigurationModeResponse *)soap_instantiate__sai__GetZeroTouchConfigurationModeResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetZeroTouchConfigurationModeResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetZeroTouchConfigurationModeResponse, sizeof(_sai__GetZeroTouchConfigurationModeResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap *soap, _sai__GetZeroTouchConfigurationMode *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetZeroTouchConfigurationMode)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap *soap, _sai__GetZeroTouchConfigurationMode *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetZeroTouchConfigurationMode); + if (soap_out_PointerTo_sai__GetZeroTouchConfigurationMode(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap *soap, const char *tag, int id, _sai__GetZeroTouchConfigurationMode *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetZeroTouchConfigurationMode); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode ** SOAP_FMAC4 soap_get_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap *soap, _sai__GetZeroTouchConfigurationMode **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetZeroTouchConfigurationMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetZeroTouchConfigurationMode ** SOAP_FMAC4 soap_in_PointerTo_sai__GetZeroTouchConfigurationMode(struct soap *soap, const char *tag, _sai__GetZeroTouchConfigurationMode **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetZeroTouchConfigurationMode **)soap_malloc(soap, sizeof(_sai__GetZeroTouchConfigurationMode *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetZeroTouchConfigurationMode *)soap_instantiate__sai__GetZeroTouchConfigurationMode(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetZeroTouchConfigurationMode **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetZeroTouchConfigurationMode, sizeof(_sai__GetZeroTouchConfigurationMode), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap *soap, _sai__EnableCertificateHashEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnableCertificateHashEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap *soap, _sai__EnableCertificateHashEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntryResponse); + if (soap_out_PointerTo_sai__EnableCertificateHashEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap *soap, const char *tag, int id, _sai__EnableCertificateHashEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnableCertificateHashEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap *soap, _sai__EnableCertificateHashEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnableCertificateHashEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnableCertificateHashEntryResponse(struct soap *soap, const char *tag, _sai__EnableCertificateHashEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnableCertificateHashEntryResponse **)soap_malloc(soap, sizeof(_sai__EnableCertificateHashEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnableCertificateHashEntryResponse *)soap_instantiate__sai__EnableCertificateHashEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnableCertificateHashEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnableCertificateHashEntryResponse, sizeof(_sai__EnableCertificateHashEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnableCertificateHashEntry(struct soap *soap, _sai__EnableCertificateHashEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnableCertificateHashEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnableCertificateHashEntry(struct soap *soap, _sai__EnableCertificateHashEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnableCertificateHashEntry); + if (soap_out_PointerTo_sai__EnableCertificateHashEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnableCertificateHashEntry(struct soap *soap, const char *tag, int id, _sai__EnableCertificateHashEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnableCertificateHashEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__EnableCertificateHashEntry(struct soap *soap, _sai__EnableCertificateHashEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnableCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnableCertificateHashEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__EnableCertificateHashEntry(struct soap *soap, const char *tag, _sai__EnableCertificateHashEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnableCertificateHashEntry **)soap_malloc(soap, sizeof(_sai__EnableCertificateHashEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnableCertificateHashEntry *)soap_instantiate__sai__EnableCertificateHashEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnableCertificateHashEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnableCertificateHashEntry, sizeof(_sai__EnableCertificateHashEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap *soap, _sai__DeleteCertificateHashEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__DeleteCertificateHashEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap *soap, _sai__DeleteCertificateHashEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntryResponse); + if (soap_out_PointerTo_sai__DeleteCertificateHashEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap *soap, const char *tag, int id, _sai__DeleteCertificateHashEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__DeleteCertificateHashEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap *soap, _sai__DeleteCertificateHashEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__DeleteCertificateHashEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__DeleteCertificateHashEntryResponse(struct soap *soap, const char *tag, _sai__DeleteCertificateHashEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__DeleteCertificateHashEntryResponse **)soap_malloc(soap, sizeof(_sai__DeleteCertificateHashEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__DeleteCertificateHashEntryResponse *)soap_instantiate__sai__DeleteCertificateHashEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__DeleteCertificateHashEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__DeleteCertificateHashEntryResponse, sizeof(_sai__DeleteCertificateHashEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__DeleteCertificateHashEntry(struct soap *soap, _sai__DeleteCertificateHashEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__DeleteCertificateHashEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__DeleteCertificateHashEntry(struct soap *soap, _sai__DeleteCertificateHashEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__DeleteCertificateHashEntry); + if (soap_out_PointerTo_sai__DeleteCertificateHashEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__DeleteCertificateHashEntry(struct soap *soap, const char *tag, int id, _sai__DeleteCertificateHashEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__DeleteCertificateHashEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__DeleteCertificateHashEntry(struct soap *soap, _sai__DeleteCertificateHashEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__DeleteCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__DeleteCertificateHashEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__DeleteCertificateHashEntry(struct soap *soap, const char *tag, _sai__DeleteCertificateHashEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__DeleteCertificateHashEntry **)soap_malloc(soap, sizeof(_sai__DeleteCertificateHashEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__DeleteCertificateHashEntry *)soap_instantiate__sai__DeleteCertificateHashEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__DeleteCertificateHashEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__DeleteCertificateHashEntry, sizeof(_sai__DeleteCertificateHashEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddCertificateHashEntryResponse(struct soap *soap, _sai__AddCertificateHashEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__AddCertificateHashEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddCertificateHashEntryResponse(struct soap *soap, _sai__AddCertificateHashEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__AddCertificateHashEntryResponse); + if (soap_out_PointerTo_sai__AddCertificateHashEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddCertificateHashEntryResponse(struct soap *soap, const char *tag, int id, _sai__AddCertificateHashEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__AddCertificateHashEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__AddCertificateHashEntryResponse(struct soap *soap, _sai__AddCertificateHashEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__AddCertificateHashEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__AddCertificateHashEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__AddCertificateHashEntryResponse(struct soap *soap, const char *tag, _sai__AddCertificateHashEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__AddCertificateHashEntryResponse **)soap_malloc(soap, sizeof(_sai__AddCertificateHashEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__AddCertificateHashEntryResponse *)soap_instantiate__sai__AddCertificateHashEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__AddCertificateHashEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__AddCertificateHashEntryResponse, sizeof(_sai__AddCertificateHashEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddCertificateHashEntry(struct soap *soap, _sai__AddCertificateHashEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__AddCertificateHashEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddCertificateHashEntry(struct soap *soap, _sai__AddCertificateHashEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__AddCertificateHashEntry); + if (soap_out_PointerTo_sai__AddCertificateHashEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddCertificateHashEntry(struct soap *soap, const char *tag, int id, _sai__AddCertificateHashEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__AddCertificateHashEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__AddCertificateHashEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__AddCertificateHashEntry(struct soap *soap, _sai__AddCertificateHashEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__AddCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__AddCertificateHashEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__AddCertificateHashEntry(struct soap *soap, const char *tag, _sai__AddCertificateHashEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__AddCertificateHashEntry **)soap_malloc(soap, sizeof(_sai__AddCertificateHashEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__AddCertificateHashEntry *)soap_instantiate__sai__AddCertificateHashEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__AddCertificateHashEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__AddCertificateHashEntry, sizeof(_sai__AddCertificateHashEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCertificateHashEntryResponse(struct soap *soap, _sai__GetCertificateHashEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetCertificateHashEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCertificateHashEntryResponse(struct soap *soap, _sai__GetCertificateHashEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetCertificateHashEntryResponse); + if (soap_out_PointerTo_sai__GetCertificateHashEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCertificateHashEntryResponse(struct soap *soap, const char *tag, int id, _sai__GetCertificateHashEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetCertificateHashEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCertificateHashEntryResponse(struct soap *soap, _sai__GetCertificateHashEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetCertificateHashEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetCertificateHashEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCertificateHashEntryResponse(struct soap *soap, const char *tag, _sai__GetCertificateHashEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetCertificateHashEntryResponse **)soap_malloc(soap, sizeof(_sai__GetCertificateHashEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetCertificateHashEntryResponse *)soap_instantiate__sai__GetCertificateHashEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetCertificateHashEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetCertificateHashEntryResponse, sizeof(_sai__GetCertificateHashEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCertificateHashEntry(struct soap *soap, _sai__GetCertificateHashEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetCertificateHashEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCertificateHashEntry(struct soap *soap, _sai__GetCertificateHashEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetCertificateHashEntry); + if (soap_out_PointerTo_sai__GetCertificateHashEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCertificateHashEntry(struct soap *soap, const char *tag, int id, _sai__GetCertificateHashEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetCertificateHashEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetCertificateHashEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCertificateHashEntry(struct soap *soap, _sai__GetCertificateHashEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetCertificateHashEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetCertificateHashEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCertificateHashEntry(struct soap *soap, const char *tag, _sai__GetCertificateHashEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetCertificateHashEntry **)soap_malloc(soap, sizeof(_sai__GetCertificateHashEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetCertificateHashEntry *)soap_instantiate__sai__GetCertificateHashEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetCertificateHashEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetCertificateHashEntry, sizeof(_sai__GetCertificateHashEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, _sai__EnumerateCertificateHashEntriesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, _sai__EnumerateCertificateHashEntriesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntriesResponse); + if (soap_out_PointerTo_sai__EnumerateCertificateHashEntriesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, const char *tag, int id, _sai__EnumerateCertificateHashEntriesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, _sai__EnumerateCertificateHashEntriesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnumerateCertificateHashEntriesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntriesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateCertificateHashEntriesResponse(struct soap *soap, const char *tag, _sai__EnumerateCertificateHashEntriesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnumerateCertificateHashEntriesResponse **)soap_malloc(soap, sizeof(_sai__EnumerateCertificateHashEntriesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnumerateCertificateHashEntriesResponse *)soap_instantiate__sai__EnumerateCertificateHashEntriesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnumerateCertificateHashEntriesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnumerateCertificateHashEntriesResponse, sizeof(_sai__EnumerateCertificateHashEntriesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateCertificateHashEntries(struct soap *soap, _sai__EnumerateCertificateHashEntries *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnumerateCertificateHashEntries)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateCertificateHashEntries(struct soap *soap, _sai__EnumerateCertificateHashEntries *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnumerateCertificateHashEntries); + if (soap_out_PointerTo_sai__EnumerateCertificateHashEntries(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateCertificateHashEntries(struct soap *soap, const char *tag, int id, _sai__EnumerateCertificateHashEntries *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnumerateCertificateHashEntries); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateCertificateHashEntries(struct soap *soap, _sai__EnumerateCertificateHashEntries **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnumerateCertificateHashEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnumerateCertificateHashEntries ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateCertificateHashEntries(struct soap *soap, const char *tag, _sai__EnumerateCertificateHashEntries **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnumerateCertificateHashEntries **)soap_malloc(soap, sizeof(_sai__EnumerateCertificateHashEntries *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnumerateCertificateHashEntries *)soap_instantiate__sai__EnumerateCertificateHashEntries(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnumerateCertificateHashEntries **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnumerateCertificateHashEntries, sizeof(_sai__EnumerateCertificateHashEntries), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap *soap, _sai__GetProvisioningServerOTPResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetProvisioningServerOTPResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap *soap, _sai__GetProvisioningServerOTPResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTPResponse); + if (soap_out_PointerTo_sai__GetProvisioningServerOTPResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap *soap, const char *tag, int id, _sai__GetProvisioningServerOTPResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetProvisioningServerOTPResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap *soap, _sai__GetProvisioningServerOTPResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetProvisioningServerOTPResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTPResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningServerOTPResponse(struct soap *soap, const char *tag, _sai__GetProvisioningServerOTPResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetProvisioningServerOTPResponse **)soap_malloc(soap, sizeof(_sai__GetProvisioningServerOTPResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetProvisioningServerOTPResponse *)soap_instantiate__sai__GetProvisioningServerOTPResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetProvisioningServerOTPResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetProvisioningServerOTPResponse, sizeof(_sai__GetProvisioningServerOTPResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningServerOTP(struct soap *soap, _sai__GetProvisioningServerOTP *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetProvisioningServerOTP)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningServerOTP(struct soap *soap, _sai__GetProvisioningServerOTP *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetProvisioningServerOTP); + if (soap_out_PointerTo_sai__GetProvisioningServerOTP(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningServerOTP(struct soap *soap, const char *tag, int id, _sai__GetProvisioningServerOTP *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetProvisioningServerOTP); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTP ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningServerOTP(struct soap *soap, _sai__GetProvisioningServerOTP **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetProvisioningServerOTP(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetProvisioningServerOTP ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningServerOTP(struct soap *soap, const char *tag, _sai__GetProvisioningServerOTP **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetProvisioningServerOTP **)soap_malloc(soap, sizeof(_sai__GetProvisioningServerOTP *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetProvisioningServerOTP *)soap_instantiate__sai__GetProvisioningServerOTP(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetProvisioningServerOTP **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetProvisioningServerOTP, sizeof(_sai__GetProvisioningServerOTP), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap *soap, _sai__SetProvisioningServerOTPResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetProvisioningServerOTPResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap *soap, _sai__SetProvisioningServerOTPResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTPResponse); + if (soap_out_PointerTo_sai__SetProvisioningServerOTPResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap *soap, const char *tag, int id, _sai__SetProvisioningServerOTPResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetProvisioningServerOTPResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap *soap, _sai__SetProvisioningServerOTPResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetProvisioningServerOTPResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTPResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetProvisioningServerOTPResponse(struct soap *soap, const char *tag, _sai__SetProvisioningServerOTPResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetProvisioningServerOTPResponse **)soap_malloc(soap, sizeof(_sai__SetProvisioningServerOTPResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetProvisioningServerOTPResponse *)soap_instantiate__sai__SetProvisioningServerOTPResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetProvisioningServerOTPResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetProvisioningServerOTPResponse, sizeof(_sai__SetProvisioningServerOTPResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetProvisioningServerOTP(struct soap *soap, _sai__SetProvisioningServerOTP *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetProvisioningServerOTP)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetProvisioningServerOTP(struct soap *soap, _sai__SetProvisioningServerOTP *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetProvisioningServerOTP); + if (soap_out_PointerTo_sai__SetProvisioningServerOTP(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetProvisioningServerOTP(struct soap *soap, const char *tag, int id, _sai__SetProvisioningServerOTP *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetProvisioningServerOTP); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTP ** SOAP_FMAC4 soap_get_PointerTo_sai__SetProvisioningServerOTP(struct soap *soap, _sai__SetProvisioningServerOTP **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetProvisioningServerOTP(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetProvisioningServerOTP ** SOAP_FMAC4 soap_in_PointerTo_sai__SetProvisioningServerOTP(struct soap *soap, const char *tag, _sai__SetProvisioningServerOTP **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetProvisioningServerOTP **)soap_malloc(soap, sizeof(_sai__SetProvisioningServerOTP *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetProvisioningServerOTP *)soap_instantiate__sai__SetProvisioningServerOTP(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetProvisioningServerOTP **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetProvisioningServerOTP, sizeof(_sai__SetProvisioningServerOTP), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetMEBxPasswordResponse(struct soap *soap, _sai__SetMEBxPasswordResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetMEBxPasswordResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetMEBxPasswordResponse(struct soap *soap, _sai__SetMEBxPasswordResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetMEBxPasswordResponse); + if (soap_out_PointerTo_sai__SetMEBxPasswordResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetMEBxPasswordResponse(struct soap *soap, const char *tag, int id, _sai__SetMEBxPasswordResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetMEBxPasswordResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetMEBxPasswordResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetMEBxPasswordResponse(struct soap *soap, _sai__SetMEBxPasswordResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetMEBxPasswordResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetMEBxPasswordResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetMEBxPasswordResponse(struct soap *soap, const char *tag, _sai__SetMEBxPasswordResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetMEBxPasswordResponse **)soap_malloc(soap, sizeof(_sai__SetMEBxPasswordResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetMEBxPasswordResponse *)soap_instantiate__sai__SetMEBxPasswordResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetMEBxPasswordResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetMEBxPasswordResponse, sizeof(_sai__SetMEBxPasswordResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetMEBxPassword(struct soap *soap, _sai__SetMEBxPassword *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetMEBxPassword)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetMEBxPassword(struct soap *soap, _sai__SetMEBxPassword *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetMEBxPassword); + if (soap_out_PointerTo_sai__SetMEBxPassword(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetMEBxPassword(struct soap *soap, const char *tag, int id, _sai__SetMEBxPassword *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetMEBxPassword); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetMEBxPassword ** SOAP_FMAC4 soap_get_PointerTo_sai__SetMEBxPassword(struct soap *soap, _sai__SetMEBxPassword **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetMEBxPassword(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetMEBxPassword ** SOAP_FMAC4 soap_in_PointerTo_sai__SetMEBxPassword(struct soap *soap, const char *tag, _sai__SetMEBxPassword **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetMEBxPassword **)soap_malloc(soap, sizeof(_sai__SetMEBxPassword *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetMEBxPassword *)soap_instantiate__sai__SetMEBxPassword(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetMEBxPassword **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetMEBxPassword, sizeof(_sai__SetMEBxPassword), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__PartialUnprovisionResponse(struct soap *soap, _sai__PartialUnprovisionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__PartialUnprovisionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__PartialUnprovisionResponse(struct soap *soap, _sai__PartialUnprovisionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__PartialUnprovisionResponse); + if (soap_out_PointerTo_sai__PartialUnprovisionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__PartialUnprovisionResponse(struct soap *soap, const char *tag, int id, _sai__PartialUnprovisionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__PartialUnprovisionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__PartialUnprovisionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__PartialUnprovisionResponse(struct soap *soap, _sai__PartialUnprovisionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__PartialUnprovisionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__PartialUnprovisionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__PartialUnprovisionResponse(struct soap *soap, const char *tag, _sai__PartialUnprovisionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__PartialUnprovisionResponse **)soap_malloc(soap, sizeof(_sai__PartialUnprovisionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__PartialUnprovisionResponse *)soap_instantiate__sai__PartialUnprovisionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__PartialUnprovisionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__PartialUnprovisionResponse, sizeof(_sai__PartialUnprovisionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__PartialUnprovision(struct soap *soap, _sai__PartialUnprovision *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__PartialUnprovision)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__PartialUnprovision(struct soap *soap, _sai__PartialUnprovision *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__PartialUnprovision); + if (soap_out_PointerTo_sai__PartialUnprovision(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__PartialUnprovision(struct soap *soap, const char *tag, int id, _sai__PartialUnprovision *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__PartialUnprovision); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__PartialUnprovision ** SOAP_FMAC4 soap_get_PointerTo_sai__PartialUnprovision(struct soap *soap, _sai__PartialUnprovision **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__PartialUnprovision(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__PartialUnprovision ** SOAP_FMAC4 soap_in_PointerTo_sai__PartialUnprovision(struct soap *soap, const char *tag, _sai__PartialUnprovision **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__PartialUnprovision **)soap_malloc(soap, sizeof(_sai__PartialUnprovision *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__PartialUnprovision *)soap_instantiate__sai__PartialUnprovision(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__PartialUnprovision **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__PartialUnprovision, sizeof(_sai__PartialUnprovision), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSPSKResponse(struct soap *soap, _sai__SetTLSPSKResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTLSPSKResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSPSKResponse(struct soap *soap, _sai__SetTLSPSKResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTLSPSKResponse); + if (soap_out_PointerTo_sai__SetTLSPSKResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSPSKResponse(struct soap *soap, const char *tag, int id, _sai__SetTLSPSKResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTLSPSKResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTLSPSKResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSPSKResponse(struct soap *soap, _sai__SetTLSPSKResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTLSPSKResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTLSPSKResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSPSKResponse(struct soap *soap, const char *tag, _sai__SetTLSPSKResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTLSPSKResponse **)soap_malloc(soap, sizeof(_sai__SetTLSPSKResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTLSPSKResponse *)soap_instantiate__sai__SetTLSPSKResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTLSPSKResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTLSPSKResponse, sizeof(_sai__SetTLSPSKResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSPSK(struct soap *soap, _sai__SetTLSPSK *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTLSPSK)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSPSK(struct soap *soap, _sai__SetTLSPSK *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTLSPSK); + if (soap_out_PointerTo_sai__SetTLSPSK(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSPSK(struct soap *soap, const char *tag, int id, _sai__SetTLSPSK *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTLSPSK); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTLSPSK ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSPSK(struct soap *soap, _sai__SetTLSPSK **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTLSPSK(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTLSPSK ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSPSK(struct soap *soap, const char *tag, _sai__SetTLSPSK **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTLSPSK **)soap_malloc(soap, sizeof(_sai__SetTLSPSK *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTLSPSK *)soap_instantiate__sai__SetTLSPSK(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTLSPSK **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTLSPSK, sizeof(_sai__SetTLSPSK), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap *soap, _sai__GetPowerSavingOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetPowerSavingOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap *soap, _sai__GetPowerSavingOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetPowerSavingOptionsResponse); + if (soap_out_PointerTo_sai__GetPowerSavingOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap *soap, const char *tag, int id, _sai__GetPowerSavingOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetPowerSavingOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap *soap, _sai__GetPowerSavingOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetPowerSavingOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetPowerSavingOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPowerSavingOptionsResponse(struct soap *soap, const char *tag, _sai__GetPowerSavingOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetPowerSavingOptionsResponse **)soap_malloc(soap, sizeof(_sai__GetPowerSavingOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetPowerSavingOptionsResponse *)soap_instantiate__sai__GetPowerSavingOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetPowerSavingOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetPowerSavingOptionsResponse, sizeof(_sai__GetPowerSavingOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPowerSavingOptions(struct soap *soap, _sai__GetPowerSavingOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetPowerSavingOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPowerSavingOptions(struct soap *soap, _sai__GetPowerSavingOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetPowerSavingOptions); + if (soap_out_PointerTo_sai__GetPowerSavingOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPowerSavingOptions(struct soap *soap, const char *tag, int id, _sai__GetPowerSavingOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetPowerSavingOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetPowerSavingOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPowerSavingOptions(struct soap *soap, _sai__GetPowerSavingOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetPowerSavingOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetPowerSavingOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPowerSavingOptions(struct soap *soap, const char *tag, _sai__GetPowerSavingOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetPowerSavingOptions **)soap_malloc(soap, sizeof(_sai__GetPowerSavingOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetPowerSavingOptions *)soap_instantiate__sai__GetPowerSavingOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetPowerSavingOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetPowerSavingOptions, sizeof(_sai__GetPowerSavingOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap *soap, _sai__SetPowerSavingOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetPowerSavingOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap *soap, _sai__SetPowerSavingOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetPowerSavingOptionsResponse); + if (soap_out_PointerTo_sai__SetPowerSavingOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap *soap, const char *tag, int id, _sai__SetPowerSavingOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetPowerSavingOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap *soap, _sai__SetPowerSavingOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetPowerSavingOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetPowerSavingOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetPowerSavingOptionsResponse(struct soap *soap, const char *tag, _sai__SetPowerSavingOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetPowerSavingOptionsResponse **)soap_malloc(soap, sizeof(_sai__SetPowerSavingOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetPowerSavingOptionsResponse *)soap_instantiate__sai__SetPowerSavingOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetPowerSavingOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetPowerSavingOptionsResponse, sizeof(_sai__SetPowerSavingOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetPowerSavingOptions(struct soap *soap, _sai__SetPowerSavingOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetPowerSavingOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetPowerSavingOptions(struct soap *soap, _sai__SetPowerSavingOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetPowerSavingOptions); + if (soap_out_PointerTo_sai__SetPowerSavingOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetPowerSavingOptions(struct soap *soap, const char *tag, int id, _sai__SetPowerSavingOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetPowerSavingOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetPowerSavingOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__SetPowerSavingOptions(struct soap *soap, _sai__SetPowerSavingOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetPowerSavingOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetPowerSavingOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__SetPowerSavingOptions(struct soap *soap, const char *tag, _sai__SetPowerSavingOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetPowerSavingOptions **)soap_malloc(soap, sizeof(_sai__SetPowerSavingOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetPowerSavingOptions *)soap_instantiate__sai__SetPowerSavingOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetPowerSavingOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetPowerSavingOptions, sizeof(_sai__SetPowerSavingOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap *soap, _sai__GetPkiCapabilitiesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetPkiCapabilitiesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap *soap, _sai__GetPkiCapabilitiesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetPkiCapabilitiesResponse); + if (soap_out_PointerTo_sai__GetPkiCapabilitiesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap *soap, const char *tag, int id, _sai__GetPkiCapabilitiesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetPkiCapabilitiesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap *soap, _sai__GetPkiCapabilitiesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetPkiCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetPkiCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPkiCapabilitiesResponse(struct soap *soap, const char *tag, _sai__GetPkiCapabilitiesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetPkiCapabilitiesResponse **)soap_malloc(soap, sizeof(_sai__GetPkiCapabilitiesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetPkiCapabilitiesResponse *)soap_instantiate__sai__GetPkiCapabilitiesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetPkiCapabilitiesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetPkiCapabilitiesResponse, sizeof(_sai__GetPkiCapabilitiesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetPkiCapabilities(struct soap *soap, _sai__GetPkiCapabilities *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetPkiCapabilities)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetPkiCapabilities(struct soap *soap, _sai__GetPkiCapabilities *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetPkiCapabilities); + if (soap_out_PointerTo_sai__GetPkiCapabilities(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetPkiCapabilities(struct soap *soap, const char *tag, int id, _sai__GetPkiCapabilities *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetPkiCapabilities); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetPkiCapabilities ** SOAP_FMAC4 soap_get_PointerTo_sai__GetPkiCapabilities(struct soap *soap, _sai__GetPkiCapabilities **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetPkiCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetPkiCapabilities ** SOAP_FMAC4 soap_in_PointerTo_sai__GetPkiCapabilities(struct soap *soap, const char *tag, _sai__GetPkiCapabilities **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetPkiCapabilities **)soap_malloc(soap, sizeof(_sai__GetPkiCapabilities *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetPkiCapabilities *)soap_instantiate__sai__GetPkiCapabilities(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetPkiCapabilities **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetPkiCapabilities, sizeof(_sai__GetPkiCapabilities), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetServerCertificateReqResponse(struct soap *soap, _sai__GetServerCertificateReqResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetServerCertificateReqResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetServerCertificateReqResponse(struct soap *soap, _sai__GetServerCertificateReqResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetServerCertificateReqResponse); + if (soap_out_PointerTo_sai__GetServerCertificateReqResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetServerCertificateReqResponse(struct soap *soap, const char *tag, int id, _sai__GetServerCertificateReqResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetServerCertificateReqResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetServerCertificateReqResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetServerCertificateReqResponse(struct soap *soap, _sai__GetServerCertificateReqResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetServerCertificateReqResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetServerCertificateReqResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetServerCertificateReqResponse(struct soap *soap, const char *tag, _sai__GetServerCertificateReqResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetServerCertificateReqResponse **)soap_malloc(soap, sizeof(_sai__GetServerCertificateReqResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetServerCertificateReqResponse *)soap_instantiate__sai__GetServerCertificateReqResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetServerCertificateReqResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetServerCertificateReqResponse, sizeof(_sai__GetServerCertificateReqResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetServerCertificateReq(struct soap *soap, _sai__GetServerCertificateReq *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetServerCertificateReq)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetServerCertificateReq(struct soap *soap, _sai__GetServerCertificateReq *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetServerCertificateReq); + if (soap_out_PointerTo_sai__GetServerCertificateReq(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetServerCertificateReq(struct soap *soap, const char *tag, int id, _sai__GetServerCertificateReq *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetServerCertificateReq); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetServerCertificateReq ** SOAP_FMAC4 soap_get_PointerTo_sai__GetServerCertificateReq(struct soap *soap, _sai__GetServerCertificateReq **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetServerCertificateReq(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetServerCertificateReq ** SOAP_FMAC4 soap_in_PointerTo_sai__GetServerCertificateReq(struct soap *soap, const char *tag, _sai__GetServerCertificateReq **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetServerCertificateReq **)soap_malloc(soap, sizeof(_sai__GetServerCertificateReq *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetServerCertificateReq *)soap_instantiate__sai__GetServerCertificateReq(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetServerCertificateReq **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetServerCertificateReq, sizeof(_sai__GetServerCertificateReq), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCRLResponse(struct soap *soap, _sai__GetCRLResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetCRLResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCRLResponse(struct soap *soap, _sai__GetCRLResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetCRLResponse); + if (soap_out_PointerTo_sai__GetCRLResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCRLResponse(struct soap *soap, const char *tag, int id, _sai__GetCRLResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetCRLResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetCRLResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCRLResponse(struct soap *soap, _sai__GetCRLResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetCRLResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetCRLResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCRLResponse(struct soap *soap, const char *tag, _sai__GetCRLResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetCRLResponse **)soap_malloc(soap, sizeof(_sai__GetCRLResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetCRLResponse *)soap_instantiate__sai__GetCRLResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetCRLResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetCRLResponse, sizeof(_sai__GetCRLResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCRL(struct soap *soap, _sai__GetCRL *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetCRL)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCRL(struct soap *soap, _sai__GetCRL *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetCRL); + if (soap_out_PointerTo_sai__GetCRL(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCRL(struct soap *soap, const char *tag, int id, _sai__GetCRL *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetCRL); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetCRL ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCRL(struct soap *soap, _sai__GetCRL **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetCRL(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetCRL ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCRL(struct soap *soap, const char *tag, _sai__GetCRL **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetCRL **)soap_malloc(soap, sizeof(_sai__GetCRL *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetCRL *)soap_instantiate__sai__GetCRL(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetCRL **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetCRL, sizeof(_sai__GetCRL), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetCRLResponse(struct soap *soap, _sai__SetCRLResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetCRLResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetCRLResponse(struct soap *soap, _sai__SetCRLResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetCRLResponse); + if (soap_out_PointerTo_sai__SetCRLResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetCRLResponse(struct soap *soap, const char *tag, int id, _sai__SetCRLResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetCRLResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetCRLResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetCRLResponse(struct soap *soap, _sai__SetCRLResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetCRLResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetCRLResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetCRLResponse(struct soap *soap, const char *tag, _sai__SetCRLResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetCRLResponse **)soap_malloc(soap, sizeof(_sai__SetCRLResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetCRLResponse *)soap_instantiate__sai__SetCRLResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetCRLResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetCRLResponse, sizeof(_sai__SetCRLResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetCRL(struct soap *soap, _sai__SetCRL *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetCRL)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetCRL(struct soap *soap, _sai__SetCRL *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetCRL); + if (soap_out_PointerTo_sai__SetCRL(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetCRL(struct soap *soap, const char *tag, int id, _sai__SetCRL *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetCRL); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetCRL ** SOAP_FMAC4 soap_get_PointerTo_sai__SetCRL(struct soap *soap, _sai__SetCRL **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetCRL(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetCRL ** SOAP_FMAC4 soap_in_PointerTo_sai__SetCRL(struct soap *soap, const char *tag, _sai__SetCRL **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetCRL **)soap_malloc(soap, sizeof(_sai__SetCRL *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetCRL *)soap_instantiate__sai__SetCRL(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetCRL **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetCRL, sizeof(_sai__SetCRL), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap *soap, _sai__GetTrustedFqdnCNResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTrustedFqdnCNResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap *soap, _sai__GetTrustedFqdnCNResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCNResponse); + if (soap_out_PointerTo_sai__GetTrustedFqdnCNResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap *soap, const char *tag, int id, _sai__GetTrustedFqdnCNResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTrustedFqdnCNResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap *soap, _sai__GetTrustedFqdnCNResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTrustedFqdnCNResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCNResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTrustedFqdnCNResponse(struct soap *soap, const char *tag, _sai__GetTrustedFqdnCNResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTrustedFqdnCNResponse **)soap_malloc(soap, sizeof(_sai__GetTrustedFqdnCNResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTrustedFqdnCNResponse *)soap_instantiate__sai__GetTrustedFqdnCNResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTrustedFqdnCNResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTrustedFqdnCNResponse, sizeof(_sai__GetTrustedFqdnCNResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTrustedFqdnCN(struct soap *soap, _sai__GetTrustedFqdnCN *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTrustedFqdnCN)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTrustedFqdnCN(struct soap *soap, _sai__GetTrustedFqdnCN *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTrustedFqdnCN); + if (soap_out_PointerTo_sai__GetTrustedFqdnCN(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTrustedFqdnCN(struct soap *soap, const char *tag, int id, _sai__GetTrustedFqdnCN *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTrustedFqdnCN); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCN ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTrustedFqdnCN(struct soap *soap, _sai__GetTrustedFqdnCN **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTrustedFqdnCN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTrustedFqdnCN ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTrustedFqdnCN(struct soap *soap, const char *tag, _sai__GetTrustedFqdnCN **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTrustedFqdnCN **)soap_malloc(soap, sizeof(_sai__GetTrustedFqdnCN *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTrustedFqdnCN *)soap_instantiate__sai__GetTrustedFqdnCN(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTrustedFqdnCN **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTrustedFqdnCN, sizeof(_sai__GetTrustedFqdnCN), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap *soap, _sai__SetTrustedFqdnCNResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTrustedFqdnCNResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap *soap, _sai__SetTrustedFqdnCNResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCNResponse); + if (soap_out_PointerTo_sai__SetTrustedFqdnCNResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap *soap, const char *tag, int id, _sai__SetTrustedFqdnCNResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTrustedFqdnCNResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap *soap, _sai__SetTrustedFqdnCNResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTrustedFqdnCNResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCNResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTrustedFqdnCNResponse(struct soap *soap, const char *tag, _sai__SetTrustedFqdnCNResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTrustedFqdnCNResponse **)soap_malloc(soap, sizeof(_sai__SetTrustedFqdnCNResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTrustedFqdnCNResponse *)soap_instantiate__sai__SetTrustedFqdnCNResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTrustedFqdnCNResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTrustedFqdnCNResponse, sizeof(_sai__SetTrustedFqdnCNResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTrustedFqdnCN(struct soap *soap, _sai__SetTrustedFqdnCN *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTrustedFqdnCN)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTrustedFqdnCN(struct soap *soap, _sai__SetTrustedFqdnCN *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTrustedFqdnCN); + if (soap_out_PointerTo_sai__SetTrustedFqdnCN(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTrustedFqdnCN(struct soap *soap, const char *tag, int id, _sai__SetTrustedFqdnCN *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTrustedFqdnCN); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCN ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTrustedFqdnCN(struct soap *soap, _sai__SetTrustedFqdnCN **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTrustedFqdnCN(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTrustedFqdnCN ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTrustedFqdnCN(struct soap *soap, const char *tag, _sai__SetTrustedFqdnCN **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTrustedFqdnCN **)soap_malloc(soap, sizeof(_sai__SetTrustedFqdnCN *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTrustedFqdnCN *)soap_instantiate__sai__SetTrustedFqdnCN(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTrustedFqdnCN **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTrustedFqdnCN, sizeof(_sai__SetTrustedFqdnCN), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, _sai__EnumerateTrustedRootCertificatesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, _sai__EnumerateTrustedRootCertificatesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificatesResponse); + if (soap_out_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, const char *tag, int id, _sai__EnumerateTrustedRootCertificatesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, _sai__EnumerateTrustedRootCertificatesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificatesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateTrustedRootCertificatesResponse(struct soap *soap, const char *tag, _sai__EnumerateTrustedRootCertificatesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnumerateTrustedRootCertificatesResponse **)soap_malloc(soap, sizeof(_sai__EnumerateTrustedRootCertificatesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnumerateTrustedRootCertificatesResponse *)soap_instantiate__sai__EnumerateTrustedRootCertificatesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnumerateTrustedRootCertificatesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnumerateTrustedRootCertificatesResponse, sizeof(_sai__EnumerateTrustedRootCertificatesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap *soap, _sai__EnumerateTrustedRootCertificates *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnumerateTrustedRootCertificates)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap *soap, _sai__EnumerateTrustedRootCertificates *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnumerateTrustedRootCertificates); + if (soap_out_PointerTo_sai__EnumerateTrustedRootCertificates(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap *soap, const char *tag, int id, _sai__EnumerateTrustedRootCertificates *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnumerateTrustedRootCertificates); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap *soap, _sai__EnumerateTrustedRootCertificates **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnumerateTrustedRootCertificates(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnumerateTrustedRootCertificates ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateTrustedRootCertificates(struct soap *soap, const char *tag, _sai__EnumerateTrustedRootCertificates **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnumerateTrustedRootCertificates **)soap_malloc(soap, sizeof(_sai__EnumerateTrustedRootCertificates *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnumerateTrustedRootCertificates *)soap_instantiate__sai__EnumerateTrustedRootCertificates(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnumerateTrustedRootCertificates **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnumerateTrustedRootCertificates, sizeof(_sai__EnumerateTrustedRootCertificates), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap *soap, _sai__DeleteTrustedRootCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap *soap, _sai__DeleteTrustedRootCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificateResponse); + if (soap_out_PointerTo_sai__DeleteTrustedRootCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap *soap, const char *tag, int id, _sai__DeleteTrustedRootCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap *soap, _sai__DeleteTrustedRootCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__DeleteTrustedRootCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__DeleteTrustedRootCertificateResponse(struct soap *soap, const char *tag, _sai__DeleteTrustedRootCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__DeleteTrustedRootCertificateResponse **)soap_malloc(soap, sizeof(_sai__DeleteTrustedRootCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__DeleteTrustedRootCertificateResponse *)soap_instantiate__sai__DeleteTrustedRootCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__DeleteTrustedRootCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__DeleteTrustedRootCertificateResponse, sizeof(_sai__DeleteTrustedRootCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__DeleteTrustedRootCertificate(struct soap *soap, _sai__DeleteTrustedRootCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__DeleteTrustedRootCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__DeleteTrustedRootCertificate(struct soap *soap, _sai__DeleteTrustedRootCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__DeleteTrustedRootCertificate); + if (soap_out_PointerTo_sai__DeleteTrustedRootCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__DeleteTrustedRootCertificate(struct soap *soap, const char *tag, int id, _sai__DeleteTrustedRootCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__DeleteTrustedRootCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__DeleteTrustedRootCertificate(struct soap *soap, _sai__DeleteTrustedRootCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__DeleteTrustedRootCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__DeleteTrustedRootCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__DeleteTrustedRootCertificate(struct soap *soap, const char *tag, _sai__DeleteTrustedRootCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__DeleteTrustedRootCertificate **)soap_malloc(soap, sizeof(_sai__DeleteTrustedRootCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__DeleteTrustedRootCertificate *)soap_instantiate__sai__DeleteTrustedRootCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__DeleteTrustedRootCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__DeleteTrustedRootCertificate, sizeof(_sai__DeleteTrustedRootCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap *soap, _sai__GetTrustedRootCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTrustedRootCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap *soap, _sai__GetTrustedRootCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificateResponse); + if (soap_out_PointerTo_sai__GetTrustedRootCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap *soap, const char *tag, int id, _sai__GetTrustedRootCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTrustedRootCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap *soap, _sai__GetTrustedRootCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTrustedRootCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTrustedRootCertificateResponse(struct soap *soap, const char *tag, _sai__GetTrustedRootCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTrustedRootCertificateResponse **)soap_malloc(soap, sizeof(_sai__GetTrustedRootCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTrustedRootCertificateResponse *)soap_instantiate__sai__GetTrustedRootCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTrustedRootCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTrustedRootCertificateResponse, sizeof(_sai__GetTrustedRootCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTrustedRootCertificate(struct soap *soap, _sai__GetTrustedRootCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTrustedRootCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTrustedRootCertificate(struct soap *soap, _sai__GetTrustedRootCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTrustedRootCertificate); + if (soap_out_PointerTo_sai__GetTrustedRootCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTrustedRootCertificate(struct soap *soap, const char *tag, int id, _sai__GetTrustedRootCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTrustedRootCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTrustedRootCertificate(struct soap *soap, _sai__GetTrustedRootCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTrustedRootCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTrustedRootCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTrustedRootCertificate(struct soap *soap, const char *tag, _sai__GetTrustedRootCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTrustedRootCertificate **)soap_malloc(soap, sizeof(_sai__GetTrustedRootCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTrustedRootCertificate *)soap_instantiate__sai__GetTrustedRootCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTrustedRootCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTrustedRootCertificate, sizeof(_sai__GetTrustedRootCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap *soap, _sai__AddTrustedRootCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__AddTrustedRootCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap *soap, _sai__AddTrustedRootCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificateResponse); + if (soap_out_PointerTo_sai__AddTrustedRootCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap *soap, const char *tag, int id, _sai__AddTrustedRootCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__AddTrustedRootCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap *soap, _sai__AddTrustedRootCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__AddTrustedRootCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__AddTrustedRootCertificateResponse(struct soap *soap, const char *tag, _sai__AddTrustedRootCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__AddTrustedRootCertificateResponse **)soap_malloc(soap, sizeof(_sai__AddTrustedRootCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__AddTrustedRootCertificateResponse *)soap_instantiate__sai__AddTrustedRootCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__AddTrustedRootCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__AddTrustedRootCertificateResponse, sizeof(_sai__AddTrustedRootCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddTrustedRootCertificate(struct soap *soap, _sai__AddTrustedRootCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__AddTrustedRootCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddTrustedRootCertificate(struct soap *soap, _sai__AddTrustedRootCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__AddTrustedRootCertificate); + if (soap_out_PointerTo_sai__AddTrustedRootCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddTrustedRootCertificate(struct soap *soap, const char *tag, int id, _sai__AddTrustedRootCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__AddTrustedRootCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__AddTrustedRootCertificate(struct soap *soap, _sai__AddTrustedRootCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__AddTrustedRootCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__AddTrustedRootCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__AddTrustedRootCertificate(struct soap *soap, const char *tag, _sai__AddTrustedRootCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__AddTrustedRootCertificate **)soap_malloc(soap, sizeof(_sai__AddTrustedRootCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__AddTrustedRootCertificate *)soap_instantiate__sai__AddTrustedRootCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__AddTrustedRootCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__AddTrustedRootCertificate, sizeof(_sai__AddTrustedRootCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTlsOptionsResponse(struct soap *soap, _sai__GetTlsOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTlsOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTlsOptionsResponse(struct soap *soap, _sai__GetTlsOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTlsOptionsResponse); + if (soap_out_PointerTo_sai__GetTlsOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTlsOptionsResponse(struct soap *soap, const char *tag, int id, _sai__GetTlsOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTlsOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTlsOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTlsOptionsResponse(struct soap *soap, _sai__GetTlsOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTlsOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTlsOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTlsOptionsResponse(struct soap *soap, const char *tag, _sai__GetTlsOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTlsOptionsResponse **)soap_malloc(soap, sizeof(_sai__GetTlsOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTlsOptionsResponse *)soap_instantiate__sai__GetTlsOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTlsOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTlsOptionsResponse, sizeof(_sai__GetTlsOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTlsOptions(struct soap *soap, _sai__GetTlsOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTlsOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTlsOptions(struct soap *soap, _sai__GetTlsOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTlsOptions); + if (soap_out_PointerTo_sai__GetTlsOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTlsOptions(struct soap *soap, const char *tag, int id, _sai__GetTlsOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTlsOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTlsOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTlsOptions(struct soap *soap, _sai__GetTlsOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTlsOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTlsOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTlsOptions(struct soap *soap, const char *tag, _sai__GetTlsOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTlsOptions **)soap_malloc(soap, sizeof(_sai__GetTlsOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTlsOptions *)soap_instantiate__sai__GetTlsOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTlsOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTlsOptions, sizeof(_sai__GetTlsOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTlsOptionsResponse(struct soap *soap, _sai__SetTlsOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTlsOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTlsOptionsResponse(struct soap *soap, _sai__SetTlsOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTlsOptionsResponse); + if (soap_out_PointerTo_sai__SetTlsOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTlsOptionsResponse(struct soap *soap, const char *tag, int id, _sai__SetTlsOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTlsOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTlsOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTlsOptionsResponse(struct soap *soap, _sai__SetTlsOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTlsOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTlsOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTlsOptionsResponse(struct soap *soap, const char *tag, _sai__SetTlsOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTlsOptionsResponse **)soap_malloc(soap, sizeof(_sai__SetTlsOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTlsOptionsResponse *)soap_instantiate__sai__SetTlsOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTlsOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTlsOptionsResponse, sizeof(_sai__SetTlsOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTlsOptions(struct soap *soap, _sai__SetTlsOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTlsOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTlsOptions(struct soap *soap, _sai__SetTlsOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTlsOptions); + if (soap_out_PointerTo_sai__SetTlsOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTlsOptions(struct soap *soap, const char *tag, int id, _sai__SetTlsOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTlsOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTlsOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTlsOptions(struct soap *soap, _sai__SetTlsOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTlsOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTlsOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTlsOptions(struct soap *soap, const char *tag, _sai__SetTlsOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTlsOptions **)soap_malloc(soap, sizeof(_sai__SetTlsOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTlsOptions *)soap_instantiate__sai__SetTlsOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTlsOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTlsOptions, sizeof(_sai__SetTlsOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetEnabledInterfacesResponse(struct soap *soap, _sai__GetEnabledInterfacesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetEnabledInterfacesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetEnabledInterfacesResponse(struct soap *soap, _sai__GetEnabledInterfacesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetEnabledInterfacesResponse); + if (soap_out_PointerTo_sai__GetEnabledInterfacesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetEnabledInterfacesResponse(struct soap *soap, const char *tag, int id, _sai__GetEnabledInterfacesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetEnabledInterfacesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetEnabledInterfacesResponse(struct soap *soap, _sai__GetEnabledInterfacesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetEnabledInterfacesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetEnabledInterfacesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetEnabledInterfacesResponse(struct soap *soap, const char *tag, _sai__GetEnabledInterfacesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetEnabledInterfacesResponse **)soap_malloc(soap, sizeof(_sai__GetEnabledInterfacesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetEnabledInterfacesResponse *)soap_instantiate__sai__GetEnabledInterfacesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetEnabledInterfacesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetEnabledInterfacesResponse, sizeof(_sai__GetEnabledInterfacesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetEnabledInterfaces(struct soap *soap, _sai__GetEnabledInterfaces *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetEnabledInterfaces)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetEnabledInterfaces(struct soap *soap, _sai__GetEnabledInterfaces *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetEnabledInterfaces); + if (soap_out_PointerTo_sai__GetEnabledInterfaces(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetEnabledInterfaces(struct soap *soap, const char *tag, int id, _sai__GetEnabledInterfaces *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetEnabledInterfaces); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetEnabledInterfaces ** SOAP_FMAC4 soap_get_PointerTo_sai__GetEnabledInterfaces(struct soap *soap, _sai__GetEnabledInterfaces **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetEnabledInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetEnabledInterfaces ** SOAP_FMAC4 soap_in_PointerTo_sai__GetEnabledInterfaces(struct soap *soap, const char *tag, _sai__GetEnabledInterfaces **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetEnabledInterfaces **)soap_malloc(soap, sizeof(_sai__GetEnabledInterfaces *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetEnabledInterfaces *)soap_instantiate__sai__GetEnabledInterfaces(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetEnabledInterfaces **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetEnabledInterfaces, sizeof(_sai__GetEnabledInterfaces), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetEnabledInterfacesResponse(struct soap *soap, _sai__SetEnabledInterfacesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetEnabledInterfacesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetEnabledInterfacesResponse(struct soap *soap, _sai__SetEnabledInterfacesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetEnabledInterfacesResponse); + if (soap_out_PointerTo_sai__SetEnabledInterfacesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetEnabledInterfacesResponse(struct soap *soap, const char *tag, int id, _sai__SetEnabledInterfacesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetEnabledInterfacesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetEnabledInterfacesResponse(struct soap *soap, _sai__SetEnabledInterfacesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetEnabledInterfacesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetEnabledInterfacesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetEnabledInterfacesResponse(struct soap *soap, const char *tag, _sai__SetEnabledInterfacesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetEnabledInterfacesResponse **)soap_malloc(soap, sizeof(_sai__SetEnabledInterfacesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetEnabledInterfacesResponse *)soap_instantiate__sai__SetEnabledInterfacesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetEnabledInterfacesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetEnabledInterfacesResponse, sizeof(_sai__SetEnabledInterfacesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetEnabledInterfaces(struct soap *soap, _sai__SetEnabledInterfaces *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetEnabledInterfaces)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetEnabledInterfaces(struct soap *soap, _sai__SetEnabledInterfaces *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetEnabledInterfaces); + if (soap_out_PointerTo_sai__SetEnabledInterfaces(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetEnabledInterfaces(struct soap *soap, const char *tag, int id, _sai__SetEnabledInterfaces *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetEnabledInterfaces); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetEnabledInterfaces ** SOAP_FMAC4 soap_get_PointerTo_sai__SetEnabledInterfaces(struct soap *soap, _sai__SetEnabledInterfaces **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetEnabledInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetEnabledInterfaces ** SOAP_FMAC4 soap_in_PointerTo_sai__SetEnabledInterfaces(struct soap *soap, const char *tag, _sai__SetEnabledInterfaces **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetEnabledInterfaces **)soap_malloc(soap, sizeof(_sai__SetEnabledInterfaces *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetEnabledInterfaces *)soap_instantiate__sai__SetEnabledInterfaces(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetEnabledInterfaces **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetEnabledInterfaces, sizeof(_sai__SetEnabledInterfaces), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetKerberosOptionsResponse(struct soap *soap, _sai__GetKerberosOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetKerberosOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetKerberosOptionsResponse(struct soap *soap, _sai__GetKerberosOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetKerberosOptionsResponse); + if (soap_out_PointerTo_sai__GetKerberosOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetKerberosOptionsResponse(struct soap *soap, const char *tag, int id, _sai__GetKerberosOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetKerberosOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetKerberosOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetKerberosOptionsResponse(struct soap *soap, _sai__GetKerberosOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetKerberosOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetKerberosOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetKerberosOptionsResponse(struct soap *soap, const char *tag, _sai__GetKerberosOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetKerberosOptionsResponse **)soap_malloc(soap, sizeof(_sai__GetKerberosOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetKerberosOptionsResponse *)soap_instantiate__sai__GetKerberosOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetKerberosOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetKerberosOptionsResponse, sizeof(_sai__GetKerberosOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetKerberosOptions(struct soap *soap, _sai__GetKerberosOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetKerberosOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetKerberosOptions(struct soap *soap, _sai__GetKerberosOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetKerberosOptions); + if (soap_out_PointerTo_sai__GetKerberosOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetKerberosOptions(struct soap *soap, const char *tag, int id, _sai__GetKerberosOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetKerberosOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetKerberosOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__GetKerberosOptions(struct soap *soap, _sai__GetKerberosOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetKerberosOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetKerberosOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__GetKerberosOptions(struct soap *soap, const char *tag, _sai__GetKerberosOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetKerberosOptions **)soap_malloc(soap, sizeof(_sai__GetKerberosOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetKerberosOptions *)soap_instantiate__sai__GetKerberosOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetKerberosOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetKerberosOptions, sizeof(_sai__GetKerberosOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetKerberosOptionsResponse(struct soap *soap, _sai__SetKerberosOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetKerberosOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetKerberosOptionsResponse(struct soap *soap, _sai__SetKerberosOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetKerberosOptionsResponse); + if (soap_out_PointerTo_sai__SetKerberosOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetKerberosOptionsResponse(struct soap *soap, const char *tag, int id, _sai__SetKerberosOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetKerberosOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetKerberosOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetKerberosOptionsResponse(struct soap *soap, _sai__SetKerberosOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetKerberosOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetKerberosOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetKerberosOptionsResponse(struct soap *soap, const char *tag, _sai__SetKerberosOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetKerberosOptionsResponse **)soap_malloc(soap, sizeof(_sai__SetKerberosOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetKerberosOptionsResponse *)soap_instantiate__sai__SetKerberosOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetKerberosOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetKerberosOptionsResponse, sizeof(_sai__SetKerberosOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetKerberosOptions(struct soap *soap, _sai__SetKerberosOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetKerberosOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetKerberosOptions(struct soap *soap, _sai__SetKerberosOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetKerberosOptions); + if (soap_out_PointerTo_sai__SetKerberosOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetKerberosOptions(struct soap *soap, const char *tag, int id, _sai__SetKerberosOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetKerberosOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetKerberosOptions ** SOAP_FMAC4 soap_get_PointerTo_sai__SetKerberosOptions(struct soap *soap, _sai__SetKerberosOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetKerberosOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetKerberosOptions ** SOAP_FMAC4 soap_in_PointerTo_sai__SetKerberosOptions(struct soap *soap, const char *tag, _sai__SetKerberosOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetKerberosOptions **)soap_malloc(soap, sizeof(_sai__SetKerberosOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetKerberosOptions *)soap_instantiate__sai__SetKerberosOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetKerberosOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetKerberosOptions, sizeof(_sai__SetKerberosOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetDigestRealmResponse(struct soap *soap, _sai__GetDigestRealmResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetDigestRealmResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetDigestRealmResponse(struct soap *soap, _sai__GetDigestRealmResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetDigestRealmResponse); + if (soap_out_PointerTo_sai__GetDigestRealmResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetDigestRealmResponse(struct soap *soap, const char *tag, int id, _sai__GetDigestRealmResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetDigestRealmResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetDigestRealmResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetDigestRealmResponse(struct soap *soap, _sai__GetDigestRealmResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetDigestRealmResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetDigestRealmResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetDigestRealmResponse(struct soap *soap, const char *tag, _sai__GetDigestRealmResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetDigestRealmResponse **)soap_malloc(soap, sizeof(_sai__GetDigestRealmResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetDigestRealmResponse *)soap_instantiate__sai__GetDigestRealmResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetDigestRealmResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetDigestRealmResponse, sizeof(_sai__GetDigestRealmResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetDigestRealm(struct soap *soap, _sai__GetDigestRealm *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetDigestRealm)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetDigestRealm(struct soap *soap, _sai__GetDigestRealm *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetDigestRealm); + if (soap_out_PointerTo_sai__GetDigestRealm(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetDigestRealm(struct soap *soap, const char *tag, int id, _sai__GetDigestRealm *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetDigestRealm); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetDigestRealm ** SOAP_FMAC4 soap_get_PointerTo_sai__GetDigestRealm(struct soap *soap, _sai__GetDigestRealm **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetDigestRealm(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetDigestRealm ** SOAP_FMAC4 soap_in_PointerTo_sai__GetDigestRealm(struct soap *soap, const char *tag, _sai__GetDigestRealm **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetDigestRealm **)soap_malloc(soap, sizeof(_sai__GetDigestRealm *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetDigestRealm *)soap_instantiate__sai__GetDigestRealm(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetDigestRealm **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetDigestRealm, sizeof(_sai__GetDigestRealm), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAdminAclEntryExResponse(struct soap *soap, _sai__SetAdminAclEntryExResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetAdminAclEntryExResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAdminAclEntryExResponse(struct soap *soap, _sai__SetAdminAclEntryExResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetAdminAclEntryExResponse); + if (soap_out_PointerTo_sai__SetAdminAclEntryExResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAdminAclEntryExResponse(struct soap *soap, const char *tag, int id, _sai__SetAdminAclEntryExResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetAdminAclEntryExResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAdminAclEntryExResponse(struct soap *soap, _sai__SetAdminAclEntryExResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetAdminAclEntryExResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetAdminAclEntryExResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAdminAclEntryExResponse(struct soap *soap, const char *tag, _sai__SetAdminAclEntryExResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetAdminAclEntryExResponse **)soap_malloc(soap, sizeof(_sai__SetAdminAclEntryExResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetAdminAclEntryExResponse *)soap_instantiate__sai__SetAdminAclEntryExResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetAdminAclEntryExResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetAdminAclEntryExResponse, sizeof(_sai__SetAdminAclEntryExResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAdminAclEntryEx(struct soap *soap, _sai__SetAdminAclEntryEx *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetAdminAclEntryEx)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAdminAclEntryEx(struct soap *soap, _sai__SetAdminAclEntryEx *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetAdminAclEntryEx); + if (soap_out_PointerTo_sai__SetAdminAclEntryEx(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAdminAclEntryEx(struct soap *soap, const char *tag, int id, _sai__SetAdminAclEntryEx *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetAdminAclEntryEx); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryEx ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAdminAclEntryEx(struct soap *soap, _sai__SetAdminAclEntryEx **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetAdminAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetAdminAclEntryEx ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAdminAclEntryEx(struct soap *soap, const char *tag, _sai__SetAdminAclEntryEx **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetAdminAclEntryEx **)soap_malloc(soap, sizeof(_sai__SetAdminAclEntryEx *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetAdminAclEntryEx *)soap_instantiate__sai__SetAdminAclEntryEx(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetAdminAclEntryEx **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetAdminAclEntryEx, sizeof(_sai__SetAdminAclEntryEx), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap *soap, _sai__UpdateUserAclEntryExResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__UpdateUserAclEntryExResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap *soap, _sai__UpdateUserAclEntryExResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryExResponse); + if (soap_out_PointerTo_sai__UpdateUserAclEntryExResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap *soap, const char *tag, int id, _sai__UpdateUserAclEntryExResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__UpdateUserAclEntryExResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap *soap, _sai__UpdateUserAclEntryExResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__UpdateUserAclEntryExResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryExResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateUserAclEntryExResponse(struct soap *soap, const char *tag, _sai__UpdateUserAclEntryExResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__UpdateUserAclEntryExResponse **)soap_malloc(soap, sizeof(_sai__UpdateUserAclEntryExResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__UpdateUserAclEntryExResponse *)soap_instantiate__sai__UpdateUserAclEntryExResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__UpdateUserAclEntryExResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__UpdateUserAclEntryExResponse, sizeof(_sai__UpdateUserAclEntryExResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateUserAclEntryEx(struct soap *soap, _sai__UpdateUserAclEntryEx *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__UpdateUserAclEntryEx)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateUserAclEntryEx(struct soap *soap, _sai__UpdateUserAclEntryEx *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryEx); + if (soap_out_PointerTo_sai__UpdateUserAclEntryEx(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateUserAclEntryEx(struct soap *soap, const char *tag, int id, _sai__UpdateUserAclEntryEx *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__UpdateUserAclEntryEx); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryEx ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateUserAclEntryEx(struct soap *soap, _sai__UpdateUserAclEntryEx **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__UpdateUserAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryEx ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateUserAclEntryEx(struct soap *soap, const char *tag, _sai__UpdateUserAclEntryEx **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__UpdateUserAclEntryEx **)soap_malloc(soap, sizeof(_sai__UpdateUserAclEntryEx *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__UpdateUserAclEntryEx *)soap_instantiate__sai__UpdateUserAclEntryEx(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__UpdateUserAclEntryEx **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__UpdateUserAclEntryEx, sizeof(_sai__UpdateUserAclEntryEx), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetUserAclEntryExResponse(struct soap *soap, _sai__GetUserAclEntryExResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetUserAclEntryExResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetUserAclEntryExResponse(struct soap *soap, _sai__GetUserAclEntryExResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetUserAclEntryExResponse); + if (soap_out_PointerTo_sai__GetUserAclEntryExResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetUserAclEntryExResponse(struct soap *soap, const char *tag, int id, _sai__GetUserAclEntryExResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetUserAclEntryExResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntryExResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetUserAclEntryExResponse(struct soap *soap, _sai__GetUserAclEntryExResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetUserAclEntryExResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetUserAclEntryExResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetUserAclEntryExResponse(struct soap *soap, const char *tag, _sai__GetUserAclEntryExResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetUserAclEntryExResponse **)soap_malloc(soap, sizeof(_sai__GetUserAclEntryExResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetUserAclEntryExResponse *)soap_instantiate__sai__GetUserAclEntryExResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetUserAclEntryExResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetUserAclEntryExResponse, sizeof(_sai__GetUserAclEntryExResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetUserAclEntryEx(struct soap *soap, _sai__GetUserAclEntryEx *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetUserAclEntryEx)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetUserAclEntryEx(struct soap *soap, _sai__GetUserAclEntryEx *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetUserAclEntryEx); + if (soap_out_PointerTo_sai__GetUserAclEntryEx(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetUserAclEntryEx(struct soap *soap, const char *tag, int id, _sai__GetUserAclEntryEx *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetUserAclEntryEx); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntryEx ** SOAP_FMAC4 soap_get_PointerTo_sai__GetUserAclEntryEx(struct soap *soap, _sai__GetUserAclEntryEx **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetUserAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetUserAclEntryEx ** SOAP_FMAC4 soap_in_PointerTo_sai__GetUserAclEntryEx(struct soap *soap, const char *tag, _sai__GetUserAclEntryEx **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetUserAclEntryEx **)soap_malloc(soap, sizeof(_sai__GetUserAclEntryEx *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetUserAclEntryEx *)soap_instantiate__sai__GetUserAclEntryEx(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetUserAclEntryEx **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetUserAclEntryEx, sizeof(_sai__GetUserAclEntryEx), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddUserAclEntryExResponse(struct soap *soap, _sai__AddUserAclEntryExResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__AddUserAclEntryExResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddUserAclEntryExResponse(struct soap *soap, _sai__AddUserAclEntryExResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__AddUserAclEntryExResponse); + if (soap_out_PointerTo_sai__AddUserAclEntryExResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddUserAclEntryExResponse(struct soap *soap, const char *tag, int id, _sai__AddUserAclEntryExResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__AddUserAclEntryExResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntryExResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__AddUserAclEntryExResponse(struct soap *soap, _sai__AddUserAclEntryExResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__AddUserAclEntryExResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__AddUserAclEntryExResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__AddUserAclEntryExResponse(struct soap *soap, const char *tag, _sai__AddUserAclEntryExResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__AddUserAclEntryExResponse **)soap_malloc(soap, sizeof(_sai__AddUserAclEntryExResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__AddUserAclEntryExResponse *)soap_instantiate__sai__AddUserAclEntryExResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__AddUserAclEntryExResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__AddUserAclEntryExResponse, sizeof(_sai__AddUserAclEntryExResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddUserAclEntryEx(struct soap *soap, _sai__AddUserAclEntryEx *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__AddUserAclEntryEx)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddUserAclEntryEx(struct soap *soap, _sai__AddUserAclEntryEx *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__AddUserAclEntryEx); + if (soap_out_PointerTo_sai__AddUserAclEntryEx(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddUserAclEntryEx(struct soap *soap, const char *tag, int id, _sai__AddUserAclEntryEx *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__AddUserAclEntryEx); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntryEx ** SOAP_FMAC4 soap_get_PointerTo_sai__AddUserAclEntryEx(struct soap *soap, _sai__AddUserAclEntryEx **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__AddUserAclEntryEx(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__AddUserAclEntryEx ** SOAP_FMAC4 soap_in_PointerTo_sai__AddUserAclEntryEx(struct soap *soap, const char *tag, _sai__AddUserAclEntryEx **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__AddUserAclEntryEx **)soap_malloc(soap, sizeof(_sai__AddUserAclEntryEx *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__AddUserAclEntryEx *)soap_instantiate__sai__AddUserAclEntryEx(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__AddUserAclEntryEx **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__AddUserAclEntryEx, sizeof(_sai__AddUserAclEntryEx), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCoreVersionResponse(struct soap *soap, _sai__GetCoreVersionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetCoreVersionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCoreVersionResponse(struct soap *soap, _sai__GetCoreVersionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetCoreVersionResponse); + if (soap_out_PointerTo_sai__GetCoreVersionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCoreVersionResponse(struct soap *soap, const char *tag, int id, _sai__GetCoreVersionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetCoreVersionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetCoreVersionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCoreVersionResponse(struct soap *soap, _sai__GetCoreVersionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetCoreVersionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetCoreVersionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCoreVersionResponse(struct soap *soap, const char *tag, _sai__GetCoreVersionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetCoreVersionResponse **)soap_malloc(soap, sizeof(_sai__GetCoreVersionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetCoreVersionResponse *)soap_instantiate__sai__GetCoreVersionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetCoreVersionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetCoreVersionResponse, sizeof(_sai__GetCoreVersionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetCoreVersion(struct soap *soap, _sai__GetCoreVersion *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetCoreVersion)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetCoreVersion(struct soap *soap, _sai__GetCoreVersion *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetCoreVersion); + if (soap_out_PointerTo_sai__GetCoreVersion(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetCoreVersion(struct soap *soap, const char *tag, int id, _sai__GetCoreVersion *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetCoreVersion); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetCoreVersion ** SOAP_FMAC4 soap_get_PointerTo_sai__GetCoreVersion(struct soap *soap, _sai__GetCoreVersion **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetCoreVersion(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetCoreVersion ** SOAP_FMAC4 soap_in_PointerTo_sai__GetCoreVersion(struct soap *soap, const char *tag, _sai__GetCoreVersion **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetCoreVersion **)soap_malloc(soap, sizeof(_sai__GetCoreVersion *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetCoreVersion *)soap_instantiate__sai__GetCoreVersion(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetCoreVersion **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetCoreVersion, sizeof(_sai__GetCoreVersion), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CommitChangesResponse(struct soap *soap, _sai__CommitChangesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CommitChangesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CommitChangesResponse(struct soap *soap, _sai__CommitChangesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CommitChangesResponse); + if (soap_out_PointerTo_sai__CommitChangesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CommitChangesResponse(struct soap *soap, const char *tag, int id, _sai__CommitChangesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CommitChangesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CommitChangesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__CommitChangesResponse(struct soap *soap, _sai__CommitChangesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CommitChangesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CommitChangesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__CommitChangesResponse(struct soap *soap, const char *tag, _sai__CommitChangesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CommitChangesResponse **)soap_malloc(soap, sizeof(_sai__CommitChangesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CommitChangesResponse *)soap_instantiate__sai__CommitChangesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CommitChangesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CommitChangesResponse, sizeof(_sai__CommitChangesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__CommitChanges(struct soap *soap, _sai__CommitChanges *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__CommitChanges)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__CommitChanges(struct soap *soap, _sai__CommitChanges *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__CommitChanges); + if (soap_out_PointerTo_sai__CommitChanges(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__CommitChanges(struct soap *soap, const char *tag, int id, _sai__CommitChanges *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__CommitChanges); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__CommitChanges ** SOAP_FMAC4 soap_get_PointerTo_sai__CommitChanges(struct soap *soap, _sai__CommitChanges **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__CommitChanges(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__CommitChanges ** SOAP_FMAC4 soap_in_PointerTo_sai__CommitChanges(struct soap *soap, const char *tag, _sai__CommitChanges **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__CommitChanges **)soap_malloc(soap, sizeof(_sai__CommitChanges *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__CommitChanges *)soap_instantiate__sai__CommitChanges(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__CommitChanges **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__CommitChanges, sizeof(_sai__CommitChanges), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UnprovisionResponse(struct soap *soap, _sai__UnprovisionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__UnprovisionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UnprovisionResponse(struct soap *soap, _sai__UnprovisionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__UnprovisionResponse); + if (soap_out_PointerTo_sai__UnprovisionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UnprovisionResponse(struct soap *soap, const char *tag, int id, _sai__UnprovisionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__UnprovisionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__UnprovisionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__UnprovisionResponse(struct soap *soap, _sai__UnprovisionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__UnprovisionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__UnprovisionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__UnprovisionResponse(struct soap *soap, const char *tag, _sai__UnprovisionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__UnprovisionResponse **)soap_malloc(soap, sizeof(_sai__UnprovisionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__UnprovisionResponse *)soap_instantiate__sai__UnprovisionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__UnprovisionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__UnprovisionResponse, sizeof(_sai__UnprovisionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__Unprovision(struct soap *soap, _sai__Unprovision *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__Unprovision)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__Unprovision(struct soap *soap, _sai__Unprovision *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__Unprovision); + if (soap_out_PointerTo_sai__Unprovision(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__Unprovision(struct soap *soap, const char *tag, int id, _sai__Unprovision *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__Unprovision); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__Unprovision ** SOAP_FMAC4 soap_get_PointerTo_sai__Unprovision(struct soap *soap, _sai__Unprovision **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__Unprovision(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__Unprovision ** SOAP_FMAC4 soap_in_PointerTo_sai__Unprovision(struct soap *soap, const char *tag, _sai__Unprovision **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__Unprovision **)soap_malloc(soap, sizeof(_sai__Unprovision *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__Unprovision *)soap_instantiate__sai__Unprovision(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__Unprovision **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__Unprovision, sizeof(_sai__Unprovision), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetProvisioningModeResponse(struct soap *soap, _sai__SetProvisioningModeResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetProvisioningModeResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetProvisioningModeResponse(struct soap *soap, _sai__SetProvisioningModeResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetProvisioningModeResponse); + if (soap_out_PointerTo_sai__SetProvisioningModeResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetProvisioningModeResponse(struct soap *soap, const char *tag, int id, _sai__SetProvisioningModeResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetProvisioningModeResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetProvisioningModeResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetProvisioningModeResponse(struct soap *soap, _sai__SetProvisioningModeResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetProvisioningModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetProvisioningModeResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetProvisioningModeResponse(struct soap *soap, const char *tag, _sai__SetProvisioningModeResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetProvisioningModeResponse **)soap_malloc(soap, sizeof(_sai__SetProvisioningModeResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetProvisioningModeResponse *)soap_instantiate__sai__SetProvisioningModeResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetProvisioningModeResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetProvisioningModeResponse, sizeof(_sai__SetProvisioningModeResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetProvisioningMode(struct soap *soap, _sai__SetProvisioningMode *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetProvisioningMode)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetProvisioningMode(struct soap *soap, _sai__SetProvisioningMode *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetProvisioningMode); + if (soap_out_PointerTo_sai__SetProvisioningMode(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetProvisioningMode(struct soap *soap, const char *tag, int id, _sai__SetProvisioningMode *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetProvisioningMode); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetProvisioningMode ** SOAP_FMAC4 soap_get_PointerTo_sai__SetProvisioningMode(struct soap *soap, _sai__SetProvisioningMode **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetProvisioningMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetProvisioningMode ** SOAP_FMAC4 soap_in_PointerTo_sai__SetProvisioningMode(struct soap *soap, const char *tag, _sai__SetProvisioningMode **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetProvisioningMode **)soap_malloc(soap, sizeof(_sai__SetProvisioningMode *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetProvisioningMode *)soap_instantiate__sai__SetProvisioningMode(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetProvisioningMode **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetProvisioningMode, sizeof(_sai__SetProvisioningMode), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningModeResponse(struct soap *soap, _sai__GetProvisioningModeResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetProvisioningModeResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningModeResponse(struct soap *soap, _sai__GetProvisioningModeResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetProvisioningModeResponse); + if (soap_out_PointerTo_sai__GetProvisioningModeResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningModeResponse(struct soap *soap, const char *tag, int id, _sai__GetProvisioningModeResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetProvisioningModeResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetProvisioningModeResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningModeResponse(struct soap *soap, _sai__GetProvisioningModeResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetProvisioningModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetProvisioningModeResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningModeResponse(struct soap *soap, const char *tag, _sai__GetProvisioningModeResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetProvisioningModeResponse **)soap_malloc(soap, sizeof(_sai__GetProvisioningModeResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetProvisioningModeResponse *)soap_instantiate__sai__GetProvisioningModeResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetProvisioningModeResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetProvisioningModeResponse, sizeof(_sai__GetProvisioningModeResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetProvisioningMode(struct soap *soap, _sai__GetProvisioningMode *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetProvisioningMode)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetProvisioningMode(struct soap *soap, _sai__GetProvisioningMode *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetProvisioningMode); + if (soap_out_PointerTo_sai__GetProvisioningMode(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetProvisioningMode(struct soap *soap, const char *tag, int id, _sai__GetProvisioningMode *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetProvisioningMode); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetProvisioningMode ** SOAP_FMAC4 soap_get_PointerTo_sai__GetProvisioningMode(struct soap *soap, _sai__GetProvisioningMode **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetProvisioningMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetProvisioningMode ** SOAP_FMAC4 soap_in_PointerTo_sai__GetProvisioningMode(struct soap *soap, const char *tag, _sai__GetProvisioningMode **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetProvisioningMode **)soap_malloc(soap, sizeof(_sai__GetProvisioningMode *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetProvisioningMode *)soap_instantiate__sai__GetProvisioningMode(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetProvisioningMode **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetProvisioningMode, sizeof(_sai__GetProvisioningMode), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap *soap, _sai__UpdateCoreFromUrlResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__UpdateCoreFromUrlResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap *soap, _sai__UpdateCoreFromUrlResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrlResponse); + if (soap_out_PointerTo_sai__UpdateCoreFromUrlResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap *soap, const char *tag, int id, _sai__UpdateCoreFromUrlResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__UpdateCoreFromUrlResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap *soap, _sai__UpdateCoreFromUrlResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__UpdateCoreFromUrlResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrlResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateCoreFromUrlResponse(struct soap *soap, const char *tag, _sai__UpdateCoreFromUrlResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__UpdateCoreFromUrlResponse **)soap_malloc(soap, sizeof(_sai__UpdateCoreFromUrlResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__UpdateCoreFromUrlResponse *)soap_instantiate__sai__UpdateCoreFromUrlResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__UpdateCoreFromUrlResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__UpdateCoreFromUrlResponse, sizeof(_sai__UpdateCoreFromUrlResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateCoreFromUrl(struct soap *soap, _sai__UpdateCoreFromUrl *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__UpdateCoreFromUrl)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateCoreFromUrl(struct soap *soap, _sai__UpdateCoreFromUrl *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__UpdateCoreFromUrl); + if (soap_out_PointerTo_sai__UpdateCoreFromUrl(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateCoreFromUrl(struct soap *soap, const char *tag, int id, _sai__UpdateCoreFromUrl *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__UpdateCoreFromUrl); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrl ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateCoreFromUrl(struct soap *soap, _sai__UpdateCoreFromUrl **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__UpdateCoreFromUrl(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__UpdateCoreFromUrl ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateCoreFromUrl(struct soap *soap, const char *tag, _sai__UpdateCoreFromUrl **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__UpdateCoreFromUrl **)soap_malloc(soap, sizeof(_sai__UpdateCoreFromUrl *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__UpdateCoreFromUrl *)soap_instantiate__sai__UpdateCoreFromUrl(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__UpdateCoreFromUrl **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__UpdateCoreFromUrl, sizeof(_sai__UpdateCoreFromUrl), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTLSCertificateResponse(struct soap *soap, _sai__GetTLSCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTLSCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTLSCertificateResponse(struct soap *soap, _sai__GetTLSCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTLSCertificateResponse); + if (soap_out_PointerTo_sai__GetTLSCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTLSCertificateResponse(struct soap *soap, const char *tag, int id, _sai__GetTLSCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTLSCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTLSCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTLSCertificateResponse(struct soap *soap, _sai__GetTLSCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTLSCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTLSCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTLSCertificateResponse(struct soap *soap, const char *tag, _sai__GetTLSCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTLSCertificateResponse **)soap_malloc(soap, sizeof(_sai__GetTLSCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTLSCertificateResponse *)soap_instantiate__sai__GetTLSCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTLSCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTLSCertificateResponse, sizeof(_sai__GetTLSCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetTLSCertificate(struct soap *soap, _sai__GetTLSCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetTLSCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetTLSCertificate(struct soap *soap, _sai__GetTLSCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetTLSCertificate); + if (soap_out_PointerTo_sai__GetTLSCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetTLSCertificate(struct soap *soap, const char *tag, int id, _sai__GetTLSCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetTLSCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetTLSCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__GetTLSCertificate(struct soap *soap, _sai__GetTLSCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetTLSCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetTLSCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__GetTLSCertificate(struct soap *soap, const char *tag, _sai__GetTLSCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetTLSCertificate **)soap_malloc(soap, sizeof(_sai__GetTLSCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetTLSCertificate *)soap_instantiate__sai__GetTLSCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetTLSCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetTLSCertificate, sizeof(_sai__GetTLSCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSCertificateResponse(struct soap *soap, _sai__SetTLSCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTLSCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSCertificateResponse(struct soap *soap, _sai__SetTLSCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTLSCertificateResponse); + if (soap_out_PointerTo_sai__SetTLSCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSCertificateResponse(struct soap *soap, const char *tag, int id, _sai__SetTLSCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTLSCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTLSCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSCertificateResponse(struct soap *soap, _sai__SetTLSCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTLSCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTLSCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSCertificateResponse(struct soap *soap, const char *tag, _sai__SetTLSCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTLSCertificateResponse **)soap_malloc(soap, sizeof(_sai__SetTLSCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTLSCertificateResponse *)soap_instantiate__sai__SetTLSCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTLSCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTLSCertificateResponse, sizeof(_sai__SetTLSCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSCertificate(struct soap *soap, _sai__SetTLSCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTLSCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSCertificate(struct soap *soap, _sai__SetTLSCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTLSCertificate); + if (soap_out_PointerTo_sai__SetTLSCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSCertificate(struct soap *soap, const char *tag, int id, _sai__SetTLSCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTLSCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTLSCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSCertificate(struct soap *soap, _sai__SetTLSCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTLSCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTLSCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSCertificate(struct soap *soap, const char *tag, _sai__SetTLSCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTLSCertificate **)soap_malloc(soap, sizeof(_sai__SetTLSCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTLSCertificate *)soap_instantiate__sai__SetTLSCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTLSCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTLSCertificate, sizeof(_sai__SetTLSCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap *soap, _sai__SetTLSKeyAndCertificateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap *soap, _sai__SetTLSKeyAndCertificateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificateResponse); + if (soap_out_PointerTo_sai__SetTLSKeyAndCertificateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap *soap, const char *tag, int id, _sai__SetTLSKeyAndCertificateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap *soap, _sai__SetTLSKeyAndCertificateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTLSKeyAndCertificateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificateResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSKeyAndCertificateResponse(struct soap *soap, const char *tag, _sai__SetTLSKeyAndCertificateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTLSKeyAndCertificateResponse **)soap_malloc(soap, sizeof(_sai__SetTLSKeyAndCertificateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTLSKeyAndCertificateResponse *)soap_instantiate__sai__SetTLSKeyAndCertificateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTLSKeyAndCertificateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTLSKeyAndCertificateResponse, sizeof(_sai__SetTLSKeyAndCertificateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTLSKeyAndCertificate(struct soap *soap, _sai__SetTLSKeyAndCertificate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTLSKeyAndCertificate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTLSKeyAndCertificate(struct soap *soap, _sai__SetTLSKeyAndCertificate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTLSKeyAndCertificate); + if (soap_out_PointerTo_sai__SetTLSKeyAndCertificate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTLSKeyAndCertificate(struct soap *soap, const char *tag, int id, _sai__SetTLSKeyAndCertificate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTLSKeyAndCertificate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTLSKeyAndCertificate(struct soap *soap, _sai__SetTLSKeyAndCertificate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTLSKeyAndCertificate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTLSKeyAndCertificate ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTLSKeyAndCertificate(struct soap *soap, const char *tag, _sai__SetTLSKeyAndCertificate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTLSKeyAndCertificate **)soap_malloc(soap, sizeof(_sai__SetTLSKeyAndCertificate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTLSKeyAndCertificate *)soap_instantiate__sai__SetTLSKeyAndCertificate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTLSKeyAndCertificate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTLSKeyAndCertificate, sizeof(_sai__SetTLSKeyAndCertificate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetRngKeyResponse(struct soap *soap, _sai__SetRngKeyResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetRngKeyResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetRngKeyResponse(struct soap *soap, _sai__SetRngKeyResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetRngKeyResponse); + if (soap_out_PointerTo_sai__SetRngKeyResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetRngKeyResponse(struct soap *soap, const char *tag, int id, _sai__SetRngKeyResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetRngKeyResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetRngKeyResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetRngKeyResponse(struct soap *soap, _sai__SetRngKeyResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetRngKeyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetRngKeyResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetRngKeyResponse(struct soap *soap, const char *tag, _sai__SetRngKeyResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetRngKeyResponse **)soap_malloc(soap, sizeof(_sai__SetRngKeyResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetRngKeyResponse *)soap_instantiate__sai__SetRngKeyResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetRngKeyResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetRngKeyResponse, sizeof(_sai__SetRngKeyResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetRngKey(struct soap *soap, _sai__SetRngKey *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetRngKey)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetRngKey(struct soap *soap, _sai__SetRngKey *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetRngKey); + if (soap_out_PointerTo_sai__SetRngKey(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetRngKey(struct soap *soap, const char *tag, int id, _sai__SetRngKey *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetRngKey); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetRngKey ** SOAP_FMAC4 soap_get_PointerTo_sai__SetRngKey(struct soap *soap, _sai__SetRngKey **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetRngKey(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetRngKey ** SOAP_FMAC4 soap_in_PointerTo_sai__SetRngKey(struct soap *soap, const char *tag, _sai__SetRngKey **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetRngKey **)soap_malloc(soap, sizeof(_sai__SetRngKey *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetRngKey *)soap_instantiate__sai__SetRngKey(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetRngKey **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetRngKey, sizeof(_sai__SetRngKey), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTlsEnabledResponse(struct soap *soap, _sai__SetTlsEnabledResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTlsEnabledResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTlsEnabledResponse(struct soap *soap, _sai__SetTlsEnabledResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTlsEnabledResponse); + if (soap_out_PointerTo_sai__SetTlsEnabledResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTlsEnabledResponse(struct soap *soap, const char *tag, int id, _sai__SetTlsEnabledResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTlsEnabledResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTlsEnabledResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTlsEnabledResponse(struct soap *soap, _sai__SetTlsEnabledResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTlsEnabledResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTlsEnabledResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTlsEnabledResponse(struct soap *soap, const char *tag, _sai__SetTlsEnabledResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTlsEnabledResponse **)soap_malloc(soap, sizeof(_sai__SetTlsEnabledResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTlsEnabledResponse *)soap_instantiate__sai__SetTlsEnabledResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTlsEnabledResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTlsEnabledResponse, sizeof(_sai__SetTlsEnabledResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetTlsEnabled(struct soap *soap, _sai__SetTlsEnabled *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetTlsEnabled)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetTlsEnabled(struct soap *soap, _sai__SetTlsEnabled *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetTlsEnabled); + if (soap_out_PointerTo_sai__SetTlsEnabled(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetTlsEnabled(struct soap *soap, const char *tag, int id, _sai__SetTlsEnabled *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetTlsEnabled); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetTlsEnabled ** SOAP_FMAC4 soap_get_PointerTo_sai__SetTlsEnabled(struct soap *soap, _sai__SetTlsEnabled **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetTlsEnabled(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetTlsEnabled ** SOAP_FMAC4 soap_in_PointerTo_sai__SetTlsEnabled(struct soap *soap, const char *tag, _sai__SetTlsEnabled **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetTlsEnabled **)soap_malloc(soap, sizeof(_sai__SetTlsEnabled *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetTlsEnabled *)soap_instantiate__sai__SetTlsEnabled(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetTlsEnabled **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetTlsEnabled, sizeof(_sai__SetTlsEnabled), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__RemoveUserAclEntryResponse(struct soap *soap, _sai__RemoveUserAclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__RemoveUserAclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__RemoveUserAclEntryResponse(struct soap *soap, _sai__RemoveUserAclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__RemoveUserAclEntryResponse); + if (soap_out_PointerTo_sai__RemoveUserAclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__RemoveUserAclEntryResponse(struct soap *soap, const char *tag, int id, _sai__RemoveUserAclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__RemoveUserAclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__RemoveUserAclEntryResponse(struct soap *soap, _sai__RemoveUserAclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__RemoveUserAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__RemoveUserAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__RemoveUserAclEntryResponse(struct soap *soap, const char *tag, _sai__RemoveUserAclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__RemoveUserAclEntryResponse **)soap_malloc(soap, sizeof(_sai__RemoveUserAclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__RemoveUserAclEntryResponse *)soap_instantiate__sai__RemoveUserAclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__RemoveUserAclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__RemoveUserAclEntryResponse, sizeof(_sai__RemoveUserAclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__RemoveUserAclEntry(struct soap *soap, _sai__RemoveUserAclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__RemoveUserAclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__RemoveUserAclEntry(struct soap *soap, _sai__RemoveUserAclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__RemoveUserAclEntry); + if (soap_out_PointerTo_sai__RemoveUserAclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__RemoveUserAclEntry(struct soap *soap, const char *tag, int id, _sai__RemoveUserAclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__RemoveUserAclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__RemoveUserAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__RemoveUserAclEntry(struct soap *soap, _sai__RemoveUserAclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__RemoveUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__RemoveUserAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__RemoveUserAclEntry(struct soap *soap, const char *tag, _sai__RemoveUserAclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__RemoveUserAclEntry **)soap_malloc(soap, sizeof(_sai__RemoveUserAclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__RemoveUserAclEntry *)soap_instantiate__sai__RemoveUserAclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__RemoveUserAclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__RemoveUserAclEntry, sizeof(_sai__RemoveUserAclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateUserAclEntryResponse(struct soap *soap, _sai__UpdateUserAclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__UpdateUserAclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateUserAclEntryResponse(struct soap *soap, _sai__UpdateUserAclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__UpdateUserAclEntryResponse); + if (soap_out_PointerTo_sai__UpdateUserAclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateUserAclEntryResponse(struct soap *soap, const char *tag, int id, _sai__UpdateUserAclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__UpdateUserAclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateUserAclEntryResponse(struct soap *soap, _sai__UpdateUserAclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__UpdateUserAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__UpdateUserAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateUserAclEntryResponse(struct soap *soap, const char *tag, _sai__UpdateUserAclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__UpdateUserAclEntryResponse **)soap_malloc(soap, sizeof(_sai__UpdateUserAclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__UpdateUserAclEntryResponse *)soap_instantiate__sai__UpdateUserAclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__UpdateUserAclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__UpdateUserAclEntryResponse, sizeof(_sai__UpdateUserAclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__UpdateUserAclEntry(struct soap *soap, _sai__UpdateUserAclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__UpdateUserAclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__UpdateUserAclEntry(struct soap *soap, _sai__UpdateUserAclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__UpdateUserAclEntry); + if (soap_out_PointerTo_sai__UpdateUserAclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__UpdateUserAclEntry(struct soap *soap, const char *tag, int id, _sai__UpdateUserAclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__UpdateUserAclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__UpdateUserAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__UpdateUserAclEntry(struct soap *soap, _sai__UpdateUserAclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__UpdateUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__UpdateUserAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__UpdateUserAclEntry(struct soap *soap, const char *tag, _sai__UpdateUserAclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__UpdateUserAclEntry **)soap_malloc(soap, sizeof(_sai__UpdateUserAclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__UpdateUserAclEntry *)soap_instantiate__sai__UpdateUserAclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__UpdateUserAclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__UpdateUserAclEntry, sizeof(_sai__UpdateUserAclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetUserAclEntryResponse(struct soap *soap, _sai__GetUserAclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetUserAclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetUserAclEntryResponse(struct soap *soap, _sai__GetUserAclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetUserAclEntryResponse); + if (soap_out_PointerTo_sai__GetUserAclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetUserAclEntryResponse(struct soap *soap, const char *tag, int id, _sai__GetUserAclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetUserAclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetUserAclEntryResponse(struct soap *soap, _sai__GetUserAclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetUserAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetUserAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetUserAclEntryResponse(struct soap *soap, const char *tag, _sai__GetUserAclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetUserAclEntryResponse **)soap_malloc(soap, sizeof(_sai__GetUserAclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetUserAclEntryResponse *)soap_instantiate__sai__GetUserAclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetUserAclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetUserAclEntryResponse, sizeof(_sai__GetUserAclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetUserAclEntry(struct soap *soap, _sai__GetUserAclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetUserAclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetUserAclEntry(struct soap *soap, _sai__GetUserAclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetUserAclEntry); + if (soap_out_PointerTo_sai__GetUserAclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetUserAclEntry(struct soap *soap, const char *tag, int id, _sai__GetUserAclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetUserAclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetUserAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__GetUserAclEntry(struct soap *soap, _sai__GetUserAclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetUserAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__GetUserAclEntry(struct soap *soap, const char *tag, _sai__GetUserAclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetUserAclEntry **)soap_malloc(soap, sizeof(_sai__GetUserAclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetUserAclEntry *)soap_instantiate__sai__GetUserAclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetUserAclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetUserAclEntry, sizeof(_sai__GetUserAclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap *soap, _sai__EnumerateUserAclEntriesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnumerateUserAclEntriesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap *soap, _sai__EnumerateUserAclEntriesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntriesResponse); + if (soap_out_PointerTo_sai__EnumerateUserAclEntriesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap *soap, const char *tag, int id, _sai__EnumerateUserAclEntriesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnumerateUserAclEntriesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap *soap, _sai__EnumerateUserAclEntriesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnumerateUserAclEntriesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntriesResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateUserAclEntriesResponse(struct soap *soap, const char *tag, _sai__EnumerateUserAclEntriesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnumerateUserAclEntriesResponse **)soap_malloc(soap, sizeof(_sai__EnumerateUserAclEntriesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnumerateUserAclEntriesResponse *)soap_instantiate__sai__EnumerateUserAclEntriesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnumerateUserAclEntriesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnumerateUserAclEntriesResponse, sizeof(_sai__EnumerateUserAclEntriesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__EnumerateUserAclEntries(struct soap *soap, _sai__EnumerateUserAclEntries *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__EnumerateUserAclEntries)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__EnumerateUserAclEntries(struct soap *soap, _sai__EnumerateUserAclEntries *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__EnumerateUserAclEntries); + if (soap_out_PointerTo_sai__EnumerateUserAclEntries(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__EnumerateUserAclEntries(struct soap *soap, const char *tag, int id, _sai__EnumerateUserAclEntries *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__EnumerateUserAclEntries); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntries ** SOAP_FMAC4 soap_get_PointerTo_sai__EnumerateUserAclEntries(struct soap *soap, _sai__EnumerateUserAclEntries **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__EnumerateUserAclEntries(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__EnumerateUserAclEntries ** SOAP_FMAC4 soap_in_PointerTo_sai__EnumerateUserAclEntries(struct soap *soap, const char *tag, _sai__EnumerateUserAclEntries **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__EnumerateUserAclEntries **)soap_malloc(soap, sizeof(_sai__EnumerateUserAclEntries *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__EnumerateUserAclEntries *)soap_instantiate__sai__EnumerateUserAclEntries(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__EnumerateUserAclEntries **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__EnumerateUserAclEntries, sizeof(_sai__EnumerateUserAclEntries), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddUserAclEntryResponse(struct soap *soap, _sai__AddUserAclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__AddUserAclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddUserAclEntryResponse(struct soap *soap, _sai__AddUserAclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__AddUserAclEntryResponse); + if (soap_out_PointerTo_sai__AddUserAclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddUserAclEntryResponse(struct soap *soap, const char *tag, int id, _sai__AddUserAclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__AddUserAclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__AddUserAclEntryResponse(struct soap *soap, _sai__AddUserAclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__AddUserAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__AddUserAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__AddUserAclEntryResponse(struct soap *soap, const char *tag, _sai__AddUserAclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__AddUserAclEntryResponse **)soap_malloc(soap, sizeof(_sai__AddUserAclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__AddUserAclEntryResponse *)soap_instantiate__sai__AddUserAclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__AddUserAclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__AddUserAclEntryResponse, sizeof(_sai__AddUserAclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__AddUserAclEntry(struct soap *soap, _sai__AddUserAclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__AddUserAclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__AddUserAclEntry(struct soap *soap, _sai__AddUserAclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__AddUserAclEntry); + if (soap_out_PointerTo_sai__AddUserAclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__AddUserAclEntry(struct soap *soap, const char *tag, int id, _sai__AddUserAclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__AddUserAclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__AddUserAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__AddUserAclEntry(struct soap *soap, _sai__AddUserAclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__AddUserAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__AddUserAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__AddUserAclEntry(struct soap *soap, const char *tag, _sai__AddUserAclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__AddUserAclEntry **)soap_malloc(soap, sizeof(_sai__AddUserAclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__AddUserAclEntry *)soap_instantiate__sai__AddUserAclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__AddUserAclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__AddUserAclEntry, sizeof(_sai__AddUserAclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAdminAclEntryResponse(struct soap *soap, _sai__SetAdminAclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetAdminAclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAdminAclEntryResponse(struct soap *soap, _sai__SetAdminAclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetAdminAclEntryResponse); + if (soap_out_PointerTo_sai__SetAdminAclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAdminAclEntryResponse(struct soap *soap, const char *tag, int id, _sai__SetAdminAclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetAdminAclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAdminAclEntryResponse(struct soap *soap, _sai__SetAdminAclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetAdminAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetAdminAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAdminAclEntryResponse(struct soap *soap, const char *tag, _sai__SetAdminAclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetAdminAclEntryResponse **)soap_malloc(soap, sizeof(_sai__SetAdminAclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetAdminAclEntryResponse *)soap_instantiate__sai__SetAdminAclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetAdminAclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetAdminAclEntryResponse, sizeof(_sai__SetAdminAclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__SetAdminAclEntry(struct soap *soap, _sai__SetAdminAclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__SetAdminAclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__SetAdminAclEntry(struct soap *soap, _sai__SetAdminAclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__SetAdminAclEntry); + if (soap_out_PointerTo_sai__SetAdminAclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__SetAdminAclEntry(struct soap *soap, const char *tag, int id, _sai__SetAdminAclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__SetAdminAclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__SetAdminAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__SetAdminAclEntry(struct soap *soap, _sai__SetAdminAclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__SetAdminAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__SetAdminAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__SetAdminAclEntry(struct soap *soap, const char *tag, _sai__SetAdminAclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__SetAdminAclEntry **)soap_malloc(soap, sizeof(_sai__SetAdminAclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__SetAdminAclEntry *)soap_instantiate__sai__SetAdminAclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__SetAdminAclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__SetAdminAclEntry, sizeof(_sai__SetAdminAclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetAdminAclEntryResponse(struct soap *soap, _sai__GetAdminAclEntryResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetAdminAclEntryResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetAdminAclEntryResponse(struct soap *soap, _sai__GetAdminAclEntryResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetAdminAclEntryResponse); + if (soap_out_PointerTo_sai__GetAdminAclEntryResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetAdminAclEntryResponse(struct soap *soap, const char *tag, int id, _sai__GetAdminAclEntryResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetAdminAclEntryResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetAdminAclEntryResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__GetAdminAclEntryResponse(struct soap *soap, _sai__GetAdminAclEntryResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetAdminAclEntryResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetAdminAclEntryResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__GetAdminAclEntryResponse(struct soap *soap, const char *tag, _sai__GetAdminAclEntryResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetAdminAclEntryResponse **)soap_malloc(soap, sizeof(_sai__GetAdminAclEntryResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetAdminAclEntryResponse *)soap_instantiate__sai__GetAdminAclEntryResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetAdminAclEntryResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetAdminAclEntryResponse, sizeof(_sai__GetAdminAclEntryResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__GetAdminAclEntry(struct soap *soap, _sai__GetAdminAclEntry *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__GetAdminAclEntry)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__GetAdminAclEntry(struct soap *soap, _sai__GetAdminAclEntry *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__GetAdminAclEntry); + if (soap_out_PointerTo_sai__GetAdminAclEntry(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__GetAdminAclEntry(struct soap *soap, const char *tag, int id, _sai__GetAdminAclEntry *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__GetAdminAclEntry); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__GetAdminAclEntry ** SOAP_FMAC4 soap_get_PointerTo_sai__GetAdminAclEntry(struct soap *soap, _sai__GetAdminAclEntry **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__GetAdminAclEntry(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__GetAdminAclEntry ** SOAP_FMAC4 soap_in_PointerTo_sai__GetAdminAclEntry(struct soap *soap, const char *tag, _sai__GetAdminAclEntry **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__GetAdminAclEntry **)soap_malloc(soap, sizeof(_sai__GetAdminAclEntry *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__GetAdminAclEntry *)soap_instantiate__sai__GetAdminAclEntry(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__GetAdminAclEntry **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__GetAdminAclEntry, sizeof(_sai__GetAdminAclEntry), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap *soap, _sai__ResetFlashWearOutProtectionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap *soap, _sai__ResetFlashWearOutProtectionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtectionResponse); + if (soap_out_PointerTo_sai__ResetFlashWearOutProtectionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap *soap, const char *tag, int id, _sai__ResetFlashWearOutProtectionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse ** SOAP_FMAC4 soap_get_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap *soap, _sai__ResetFlashWearOutProtectionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__ResetFlashWearOutProtectionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtectionResponse ** SOAP_FMAC4 soap_in_PointerTo_sai__ResetFlashWearOutProtectionResponse(struct soap *soap, const char *tag, _sai__ResetFlashWearOutProtectionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__ResetFlashWearOutProtectionResponse **)soap_malloc(soap, sizeof(_sai__ResetFlashWearOutProtectionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__ResetFlashWearOutProtectionResponse *)soap_instantiate__sai__ResetFlashWearOutProtectionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__ResetFlashWearOutProtectionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__ResetFlashWearOutProtectionResponse, sizeof(_sai__ResetFlashWearOutProtectionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_sai__ResetFlashWearOutProtection(struct soap *soap, _sai__ResetFlashWearOutProtection *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__sai__ResetFlashWearOutProtection)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_sai__ResetFlashWearOutProtection(struct soap *soap, _sai__ResetFlashWearOutProtection *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_sai__ResetFlashWearOutProtection); + if (soap_out_PointerTo_sai__ResetFlashWearOutProtection(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_sai__ResetFlashWearOutProtection(struct soap *soap, const char *tag, int id, _sai__ResetFlashWearOutProtection *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__sai__ResetFlashWearOutProtection); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtection ** SOAP_FMAC4 soap_get_PointerTo_sai__ResetFlashWearOutProtection(struct soap *soap, _sai__ResetFlashWearOutProtection **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_sai__ResetFlashWearOutProtection(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _sai__ResetFlashWearOutProtection ** SOAP_FMAC4 soap_in_PointerTo_sai__ResetFlashWearOutProtection(struct soap *soap, const char *tag, _sai__ResetFlashWearOutProtection **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_sai__ResetFlashWearOutProtection **)soap_malloc(soap, sizeof(_sai__ResetFlashWearOutProtection *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_sai__ResetFlashWearOutProtection *)soap_instantiate__sai__ResetFlashWearOutProtection(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_sai__ResetFlashWearOutProtection **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__sai__ResetFlashWearOutProtection, sizeof(_sai__ResetFlashWearOutProtection), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__GetSystemPowerStateResponse(struct soap *soap, _rci__GetSystemPowerStateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__rci__GetSystemPowerStateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__GetSystemPowerStateResponse(struct soap *soap, _rci__GetSystemPowerStateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_rci__GetSystemPowerStateResponse); + if (soap_out_PointerTo_rci__GetSystemPowerStateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__GetSystemPowerStateResponse(struct soap *soap, const char *tag, int id, _rci__GetSystemPowerStateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__rci__GetSystemPowerStateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _rci__GetSystemPowerStateResponse ** SOAP_FMAC4 soap_get_PointerTo_rci__GetSystemPowerStateResponse(struct soap *soap, _rci__GetSystemPowerStateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_rci__GetSystemPowerStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _rci__GetSystemPowerStateResponse ** SOAP_FMAC4 soap_in_PointerTo_rci__GetSystemPowerStateResponse(struct soap *soap, const char *tag, _rci__GetSystemPowerStateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_rci__GetSystemPowerStateResponse **)soap_malloc(soap, sizeof(_rci__GetSystemPowerStateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_rci__GetSystemPowerStateResponse *)soap_instantiate__rci__GetSystemPowerStateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_rci__GetSystemPowerStateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__rci__GetSystemPowerStateResponse, sizeof(_rci__GetSystemPowerStateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__GetSystemPowerState(struct soap *soap, _rci__GetSystemPowerState *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__rci__GetSystemPowerState)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__GetSystemPowerState(struct soap *soap, _rci__GetSystemPowerState *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_rci__GetSystemPowerState); + if (soap_out_PointerTo_rci__GetSystemPowerState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__GetSystemPowerState(struct soap *soap, const char *tag, int id, _rci__GetSystemPowerState *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__rci__GetSystemPowerState); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _rci__GetSystemPowerState ** SOAP_FMAC4 soap_get_PointerTo_rci__GetSystemPowerState(struct soap *soap, _rci__GetSystemPowerState **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_rci__GetSystemPowerState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _rci__GetSystemPowerState ** SOAP_FMAC4 soap_in_PointerTo_rci__GetSystemPowerState(struct soap *soap, const char *tag, _rci__GetSystemPowerState **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_rci__GetSystemPowerState **)soap_malloc(soap, sizeof(_rci__GetSystemPowerState *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_rci__GetSystemPowerState *)soap_instantiate__rci__GetSystemPowerState(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_rci__GetSystemPowerState **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__rci__GetSystemPowerState, sizeof(_rci__GetSystemPowerState), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__RemoteControlResponse(struct soap *soap, _rci__RemoteControlResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__rci__RemoteControlResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__RemoteControlResponse(struct soap *soap, _rci__RemoteControlResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_rci__RemoteControlResponse); + if (soap_out_PointerTo_rci__RemoteControlResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__RemoteControlResponse(struct soap *soap, const char *tag, int id, _rci__RemoteControlResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__rci__RemoteControlResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _rci__RemoteControlResponse ** SOAP_FMAC4 soap_get_PointerTo_rci__RemoteControlResponse(struct soap *soap, _rci__RemoteControlResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_rci__RemoteControlResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _rci__RemoteControlResponse ** SOAP_FMAC4 soap_in_PointerTo_rci__RemoteControlResponse(struct soap *soap, const char *tag, _rci__RemoteControlResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_rci__RemoteControlResponse **)soap_malloc(soap, sizeof(_rci__RemoteControlResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_rci__RemoteControlResponse *)soap_instantiate__rci__RemoteControlResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_rci__RemoteControlResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__rci__RemoteControlResponse, sizeof(_rci__RemoteControlResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__RemoteControl(struct soap *soap, _rci__RemoteControl *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__rci__RemoteControl)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__RemoteControl(struct soap *soap, _rci__RemoteControl *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_rci__RemoteControl); + if (soap_out_PointerTo_rci__RemoteControl(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__RemoteControl(struct soap *soap, const char *tag, int id, _rci__RemoteControl *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__rci__RemoteControl); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _rci__RemoteControl ** SOAP_FMAC4 soap_get_PointerTo_rci__RemoteControl(struct soap *soap, _rci__RemoteControl **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_rci__RemoteControl(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _rci__RemoteControl ** SOAP_FMAC4 soap_in_PointerTo_rci__RemoteControl(struct soap *soap, const char *tag, _rci__RemoteControl **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_rci__RemoteControl **)soap_malloc(soap, sizeof(_rci__RemoteControl *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_rci__RemoteControl *)soap_instantiate__rci__RemoteControl(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_rci__RemoteControl **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__rci__RemoteControl, sizeof(_rci__RemoteControl), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, _rci__GetRemoteControlCapabilitiesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, _rci__GetRemoteControlCapabilitiesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilitiesResponse); + if (soap_out_PointerTo_rci__GetRemoteControlCapabilitiesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, const char *tag, int id, _rci__GetRemoteControlCapabilitiesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, _rci__GetRemoteControlCapabilitiesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_rci__GetRemoteControlCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_rci__GetRemoteControlCapabilitiesResponse(struct soap *soap, const char *tag, _rci__GetRemoteControlCapabilitiesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_rci__GetRemoteControlCapabilitiesResponse **)soap_malloc(soap, sizeof(_rci__GetRemoteControlCapabilitiesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_rci__GetRemoteControlCapabilitiesResponse *)soap_instantiate__rci__GetRemoteControlCapabilitiesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_rci__GetRemoteControlCapabilitiesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__rci__GetRemoteControlCapabilitiesResponse, sizeof(_rci__GetRemoteControlCapabilitiesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_rci__GetRemoteControlCapabilities(struct soap *soap, _rci__GetRemoteControlCapabilities *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__rci__GetRemoteControlCapabilities)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_rci__GetRemoteControlCapabilities(struct soap *soap, _rci__GetRemoteControlCapabilities *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_rci__GetRemoteControlCapabilities); + if (soap_out_PointerTo_rci__GetRemoteControlCapabilities(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_rci__GetRemoteControlCapabilities(struct soap *soap, const char *tag, int id, _rci__GetRemoteControlCapabilities *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__rci__GetRemoteControlCapabilities); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilities ** SOAP_FMAC4 soap_get_PointerTo_rci__GetRemoteControlCapabilities(struct soap *soap, _rci__GetRemoteControlCapabilities **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_rci__GetRemoteControlCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _rci__GetRemoteControlCapabilities ** SOAP_FMAC4 soap_in_PointerTo_rci__GetRemoteControlCapabilities(struct soap *soap, const char *tag, _rci__GetRemoteControlCapabilities **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_rci__GetRemoteControlCapabilities **)soap_malloc(soap, sizeof(_rci__GetRemoteControlCapabilities *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_rci__GetRemoteControlCapabilities *)soap_instantiate__rci__GetRemoteControlCapabilities(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_rci__GetRemoteControlCapabilities **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__rci__GetRemoteControlCapabilities, sizeof(_rci__GetRemoteControlCapabilities), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap *soap, _net__Get8021XPxeTimeoutResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Get8021XPxeTimeoutResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap *soap, _net__Get8021XPxeTimeoutResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Get8021XPxeTimeoutResponse); + if (soap_out_PointerTo_net__Get8021XPxeTimeoutResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap *soap, const char *tag, int id, _net__Get8021XPxeTimeoutResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Get8021XPxeTimeoutResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap *soap, _net__Get8021XPxeTimeoutResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Get8021XPxeTimeoutResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Get8021XPxeTimeoutResponse ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XPxeTimeoutResponse(struct soap *soap, const char *tag, _net__Get8021XPxeTimeoutResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Get8021XPxeTimeoutResponse **)soap_malloc(soap, sizeof(_net__Get8021XPxeTimeoutResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Get8021XPxeTimeoutResponse *)soap_instantiate__net__Get8021XPxeTimeoutResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Get8021XPxeTimeoutResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Get8021XPxeTimeoutResponse, sizeof(_net__Get8021XPxeTimeoutResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XPxeTimeout(struct soap *soap, _net__Get8021XPxeTimeout *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Get8021XPxeTimeout)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XPxeTimeout(struct soap *soap, _net__Get8021XPxeTimeout *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Get8021XPxeTimeout); + if (soap_out_PointerTo_net__Get8021XPxeTimeout(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XPxeTimeout(struct soap *soap, const char *tag, int id, _net__Get8021XPxeTimeout *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Get8021XPxeTimeout); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Get8021XPxeTimeout ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XPxeTimeout(struct soap *soap, _net__Get8021XPxeTimeout **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Get8021XPxeTimeout(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Get8021XPxeTimeout ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XPxeTimeout(struct soap *soap, const char *tag, _net__Get8021XPxeTimeout **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Get8021XPxeTimeout **)soap_malloc(soap, sizeof(_net__Get8021XPxeTimeout *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Get8021XPxeTimeout *)soap_instantiate__net__Get8021XPxeTimeout(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Get8021XPxeTimeout **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Get8021XPxeTimeout, sizeof(_net__Get8021XPxeTimeout), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap *soap, _net__Set8021XPxeTimeoutResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Set8021XPxeTimeoutResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap *soap, _net__Set8021XPxeTimeoutResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Set8021XPxeTimeoutResponse); + if (soap_out_PointerTo_net__Set8021XPxeTimeoutResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap *soap, const char *tag, int id, _net__Set8021XPxeTimeoutResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Set8021XPxeTimeoutResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap *soap, _net__Set8021XPxeTimeoutResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Set8021XPxeTimeoutResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Set8021XPxeTimeoutResponse ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XPxeTimeoutResponse(struct soap *soap, const char *tag, _net__Set8021XPxeTimeoutResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Set8021XPxeTimeoutResponse **)soap_malloc(soap, sizeof(_net__Set8021XPxeTimeoutResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Set8021XPxeTimeoutResponse *)soap_instantiate__net__Set8021XPxeTimeoutResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Set8021XPxeTimeoutResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Set8021XPxeTimeoutResponse, sizeof(_net__Set8021XPxeTimeoutResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XPxeTimeout(struct soap *soap, _net__Set8021XPxeTimeout *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Set8021XPxeTimeout)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XPxeTimeout(struct soap *soap, _net__Set8021XPxeTimeout *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Set8021XPxeTimeout); + if (soap_out_PointerTo_net__Set8021XPxeTimeout(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XPxeTimeout(struct soap *soap, const char *tag, int id, _net__Set8021XPxeTimeout *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Set8021XPxeTimeout); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Set8021XPxeTimeout ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XPxeTimeout(struct soap *soap, _net__Set8021XPxeTimeout **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Set8021XPxeTimeout(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Set8021XPxeTimeout ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XPxeTimeout(struct soap *soap, const char *tag, _net__Set8021XPxeTimeout **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Set8021XPxeTimeout **)soap_malloc(soap, sizeof(_net__Set8021XPxeTimeout *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Set8021XPxeTimeout *)soap_instantiate__net__Set8021XPxeTimeout(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Set8021XPxeTimeout **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Set8021XPxeTimeout, sizeof(_net__Set8021XPxeTimeout), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XActiveS0Response(struct soap *soap, _net__Get8021XActiveS0Response *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Get8021XActiveS0Response)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XActiveS0Response(struct soap *soap, _net__Get8021XActiveS0Response *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Get8021XActiveS0Response); + if (soap_out_PointerTo_net__Get8021XActiveS0Response(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XActiveS0Response(struct soap *soap, const char *tag, int id, _net__Get8021XActiveS0Response *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Get8021XActiveS0Response); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Get8021XActiveS0Response ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XActiveS0Response(struct soap *soap, _net__Get8021XActiveS0Response **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Get8021XActiveS0Response(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Get8021XActiveS0Response ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XActiveS0Response(struct soap *soap, const char *tag, _net__Get8021XActiveS0Response **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Get8021XActiveS0Response **)soap_malloc(soap, sizeof(_net__Get8021XActiveS0Response *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Get8021XActiveS0Response *)soap_instantiate__net__Get8021XActiveS0Response(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Get8021XActiveS0Response **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Get8021XActiveS0Response, sizeof(_net__Get8021XActiveS0Response), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XActiveS0(struct soap *soap, _net__Get8021XActiveS0 *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Get8021XActiveS0)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XActiveS0(struct soap *soap, _net__Get8021XActiveS0 *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Get8021XActiveS0); + if (soap_out_PointerTo_net__Get8021XActiveS0(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XActiveS0(struct soap *soap, const char *tag, int id, _net__Get8021XActiveS0 *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Get8021XActiveS0); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Get8021XActiveS0 ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XActiveS0(struct soap *soap, _net__Get8021XActiveS0 **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Get8021XActiveS0(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Get8021XActiveS0 ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XActiveS0(struct soap *soap, const char *tag, _net__Get8021XActiveS0 **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Get8021XActiveS0 **)soap_malloc(soap, sizeof(_net__Get8021XActiveS0 *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Get8021XActiveS0 *)soap_instantiate__net__Get8021XActiveS0(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Get8021XActiveS0 **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Get8021XActiveS0, sizeof(_net__Get8021XActiveS0), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XActiveS0Response(struct soap *soap, _net__Set8021XActiveS0Response *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Set8021XActiveS0Response)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XActiveS0Response(struct soap *soap, _net__Set8021XActiveS0Response *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Set8021XActiveS0Response); + if (soap_out_PointerTo_net__Set8021XActiveS0Response(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XActiveS0Response(struct soap *soap, const char *tag, int id, _net__Set8021XActiveS0Response *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Set8021XActiveS0Response); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Set8021XActiveS0Response ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XActiveS0Response(struct soap *soap, _net__Set8021XActiveS0Response **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Set8021XActiveS0Response(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Set8021XActiveS0Response ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XActiveS0Response(struct soap *soap, const char *tag, _net__Set8021XActiveS0Response **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Set8021XActiveS0Response **)soap_malloc(soap, sizeof(_net__Set8021XActiveS0Response *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Set8021XActiveS0Response *)soap_instantiate__net__Set8021XActiveS0Response(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Set8021XActiveS0Response **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Set8021XActiveS0Response, sizeof(_net__Set8021XActiveS0Response), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XActiveS0(struct soap *soap, _net__Set8021XActiveS0 *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Set8021XActiveS0)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XActiveS0(struct soap *soap, _net__Set8021XActiveS0 *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Set8021XActiveS0); + if (soap_out_PointerTo_net__Set8021XActiveS0(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XActiveS0(struct soap *soap, const char *tag, int id, _net__Set8021XActiveS0 *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Set8021XActiveS0); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Set8021XActiveS0 ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XActiveS0(struct soap *soap, _net__Set8021XActiveS0 **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Set8021XActiveS0(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Set8021XActiveS0 ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XActiveS0(struct soap *soap, const char *tag, _net__Set8021XActiveS0 **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Set8021XActiveS0 **)soap_malloc(soap, sizeof(_net__Set8021XActiveS0 *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Set8021XActiveS0 *)soap_instantiate__net__Set8021XActiveS0(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Set8021XActiveS0 **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Set8021XActiveS0, sizeof(_net__Set8021XActiveS0), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XWiredProfileResponse(struct soap *soap, _net__Get8021XWiredProfileResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Get8021XWiredProfileResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XWiredProfileResponse(struct soap *soap, _net__Get8021XWiredProfileResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Get8021XWiredProfileResponse); + if (soap_out_PointerTo_net__Get8021XWiredProfileResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XWiredProfileResponse(struct soap *soap, const char *tag, int id, _net__Get8021XWiredProfileResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Get8021XWiredProfileResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Get8021XWiredProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XWiredProfileResponse(struct soap *soap, _net__Get8021XWiredProfileResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Get8021XWiredProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Get8021XWiredProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XWiredProfileResponse(struct soap *soap, const char *tag, _net__Get8021XWiredProfileResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Get8021XWiredProfileResponse **)soap_malloc(soap, sizeof(_net__Get8021XWiredProfileResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Get8021XWiredProfileResponse *)soap_instantiate__net__Get8021XWiredProfileResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Get8021XWiredProfileResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Get8021XWiredProfileResponse, sizeof(_net__Get8021XWiredProfileResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Get8021XWiredProfile(struct soap *soap, _net__Get8021XWiredProfile *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Get8021XWiredProfile)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Get8021XWiredProfile(struct soap *soap, _net__Get8021XWiredProfile *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Get8021XWiredProfile); + if (soap_out_PointerTo_net__Get8021XWiredProfile(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Get8021XWiredProfile(struct soap *soap, const char *tag, int id, _net__Get8021XWiredProfile *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Get8021XWiredProfile); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Get8021XWiredProfile ** SOAP_FMAC4 soap_get_PointerTo_net__Get8021XWiredProfile(struct soap *soap, _net__Get8021XWiredProfile **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Get8021XWiredProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Get8021XWiredProfile ** SOAP_FMAC4 soap_in_PointerTo_net__Get8021XWiredProfile(struct soap *soap, const char *tag, _net__Get8021XWiredProfile **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Get8021XWiredProfile **)soap_malloc(soap, sizeof(_net__Get8021XWiredProfile *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Get8021XWiredProfile *)soap_instantiate__net__Get8021XWiredProfile(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Get8021XWiredProfile **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Get8021XWiredProfile, sizeof(_net__Get8021XWiredProfile), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XWiredProfileResponse(struct soap *soap, _net__Set8021XWiredProfileResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Set8021XWiredProfileResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XWiredProfileResponse(struct soap *soap, _net__Set8021XWiredProfileResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Set8021XWiredProfileResponse); + if (soap_out_PointerTo_net__Set8021XWiredProfileResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XWiredProfileResponse(struct soap *soap, const char *tag, int id, _net__Set8021XWiredProfileResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Set8021XWiredProfileResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Set8021XWiredProfileResponse ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XWiredProfileResponse(struct soap *soap, _net__Set8021XWiredProfileResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Set8021XWiredProfileResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Set8021XWiredProfileResponse ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XWiredProfileResponse(struct soap *soap, const char *tag, _net__Set8021XWiredProfileResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Set8021XWiredProfileResponse **)soap_malloc(soap, sizeof(_net__Set8021XWiredProfileResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Set8021XWiredProfileResponse *)soap_instantiate__net__Set8021XWiredProfileResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Set8021XWiredProfileResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Set8021XWiredProfileResponse, sizeof(_net__Set8021XWiredProfileResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__Set8021XWiredProfile(struct soap *soap, _net__Set8021XWiredProfile *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__Set8021XWiredProfile)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__Set8021XWiredProfile(struct soap *soap, _net__Set8021XWiredProfile *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__Set8021XWiredProfile); + if (soap_out_PointerTo_net__Set8021XWiredProfile(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__Set8021XWiredProfile(struct soap *soap, const char *tag, int id, _net__Set8021XWiredProfile *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__Set8021XWiredProfile); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__Set8021XWiredProfile ** SOAP_FMAC4 soap_get_PointerTo_net__Set8021XWiredProfile(struct soap *soap, _net__Set8021XWiredProfile **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__Set8021XWiredProfile(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__Set8021XWiredProfile ** SOAP_FMAC4 soap_in_PointerTo_net__Set8021XWiredProfile(struct soap *soap, const char *tag, _net__Set8021XWiredProfile **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__Set8021XWiredProfile **)soap_malloc(soap, sizeof(_net__Set8021XWiredProfile *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__Set8021XWiredProfile *)soap_instantiate__net__Set8021XWiredProfile(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__Set8021XWiredProfile **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__Set8021XWiredProfile, sizeof(_net__Set8021XWiredProfile), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetInterfaceSettingsResponse(struct soap *soap, _net__SetInterfaceSettingsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetInterfaceSettingsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetInterfaceSettingsResponse(struct soap *soap, _net__SetInterfaceSettingsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetInterfaceSettingsResponse); + if (soap_out_PointerTo_net__SetInterfaceSettingsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetInterfaceSettingsResponse(struct soap *soap, const char *tag, int id, _net__SetInterfaceSettingsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetInterfaceSettingsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetInterfaceSettingsResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetInterfaceSettingsResponse(struct soap *soap, _net__SetInterfaceSettingsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetInterfaceSettingsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetInterfaceSettingsResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetInterfaceSettingsResponse(struct soap *soap, const char *tag, _net__SetInterfaceSettingsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetInterfaceSettingsResponse **)soap_malloc(soap, sizeof(_net__SetInterfaceSettingsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetInterfaceSettingsResponse *)soap_instantiate__net__SetInterfaceSettingsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetInterfaceSettingsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetInterfaceSettingsResponse, sizeof(_net__SetInterfaceSettingsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetInterfaceSettings(struct soap *soap, _net__SetInterfaceSettings *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetInterfaceSettings)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetInterfaceSettings(struct soap *soap, _net__SetInterfaceSettings *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetInterfaceSettings); + if (soap_out_PointerTo_net__SetInterfaceSettings(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetInterfaceSettings(struct soap *soap, const char *tag, int id, _net__SetInterfaceSettings *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetInterfaceSettings); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetInterfaceSettings ** SOAP_FMAC4 soap_get_PointerTo_net__SetInterfaceSettings(struct soap *soap, _net__SetInterfaceSettings **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetInterfaceSettings(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetInterfaceSettings ** SOAP_FMAC4 soap_in_PointerTo_net__SetInterfaceSettings(struct soap *soap, const char *tag, _net__SetInterfaceSettings **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetInterfaceSettings **)soap_malloc(soap, sizeof(_net__SetInterfaceSettings *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetInterfaceSettings *)soap_instantiate__net__SetInterfaceSettings(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetInterfaceSettings **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetInterfaceSettings, sizeof(_net__SetInterfaceSettings), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetInterfaceSettingsResponse(struct soap *soap, _net__GetInterfaceSettingsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetInterfaceSettingsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetInterfaceSettingsResponse(struct soap *soap, _net__GetInterfaceSettingsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetInterfaceSettingsResponse); + if (soap_out_PointerTo_net__GetInterfaceSettingsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetInterfaceSettingsResponse(struct soap *soap, const char *tag, int id, _net__GetInterfaceSettingsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetInterfaceSettingsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetInterfaceSettingsResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetInterfaceSettingsResponse(struct soap *soap, _net__GetInterfaceSettingsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetInterfaceSettingsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetInterfaceSettingsResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetInterfaceSettingsResponse(struct soap *soap, const char *tag, _net__GetInterfaceSettingsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetInterfaceSettingsResponse **)soap_malloc(soap, sizeof(_net__GetInterfaceSettingsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetInterfaceSettingsResponse *)soap_instantiate__net__GetInterfaceSettingsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetInterfaceSettingsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetInterfaceSettingsResponse, sizeof(_net__GetInterfaceSettingsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetInterfaceSettings(struct soap *soap, _net__GetInterfaceSettings *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetInterfaceSettings)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetInterfaceSettings(struct soap *soap, _net__GetInterfaceSettings *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetInterfaceSettings); + if (soap_out_PointerTo_net__GetInterfaceSettings(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetInterfaceSettings(struct soap *soap, const char *tag, int id, _net__GetInterfaceSettings *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetInterfaceSettings); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetInterfaceSettings ** SOAP_FMAC4 soap_get_PointerTo_net__GetInterfaceSettings(struct soap *soap, _net__GetInterfaceSettings **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetInterfaceSettings(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetInterfaceSettings ** SOAP_FMAC4 soap_in_PointerTo_net__GetInterfaceSettings(struct soap *soap, const char *tag, _net__GetInterfaceSettings **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetInterfaceSettings **)soap_malloc(soap, sizeof(_net__GetInterfaceSettings *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetInterfaceSettings *)soap_instantiate__net__GetInterfaceSettings(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetInterfaceSettings **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetInterfaceSettings, sizeof(_net__GetInterfaceSettings), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__EnumerateInterfacesResponse(struct soap *soap, _net__EnumerateInterfacesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__EnumerateInterfacesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__EnumerateInterfacesResponse(struct soap *soap, _net__EnumerateInterfacesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__EnumerateInterfacesResponse); + if (soap_out_PointerTo_net__EnumerateInterfacesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__EnumerateInterfacesResponse(struct soap *soap, const char *tag, int id, _net__EnumerateInterfacesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__EnumerateInterfacesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__EnumerateInterfacesResponse ** SOAP_FMAC4 soap_get_PointerTo_net__EnumerateInterfacesResponse(struct soap *soap, _net__EnumerateInterfacesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__EnumerateInterfacesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__EnumerateInterfacesResponse ** SOAP_FMAC4 soap_in_PointerTo_net__EnumerateInterfacesResponse(struct soap *soap, const char *tag, _net__EnumerateInterfacesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__EnumerateInterfacesResponse **)soap_malloc(soap, sizeof(_net__EnumerateInterfacesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__EnumerateInterfacesResponse *)soap_instantiate__net__EnumerateInterfacesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__EnumerateInterfacesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__EnumerateInterfacesResponse, sizeof(_net__EnumerateInterfacesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__EnumerateInterfaces(struct soap *soap, _net__EnumerateInterfaces *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__EnumerateInterfaces)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__EnumerateInterfaces(struct soap *soap, _net__EnumerateInterfaces *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__EnumerateInterfaces); + if (soap_out_PointerTo_net__EnumerateInterfaces(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__EnumerateInterfaces(struct soap *soap, const char *tag, int id, _net__EnumerateInterfaces *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__EnumerateInterfaces); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__EnumerateInterfaces ** SOAP_FMAC4 soap_get_PointerTo_net__EnumerateInterfaces(struct soap *soap, _net__EnumerateInterfaces **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__EnumerateInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__EnumerateInterfaces ** SOAP_FMAC4 soap_in_PointerTo_net__EnumerateInterfaces(struct soap *soap, const char *tag, _net__EnumerateInterfaces **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__EnumerateInterfaces **)soap_malloc(soap, sizeof(_net__EnumerateInterfaces *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__EnumerateInterfaces *)soap_instantiate__net__EnumerateInterfaces(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__EnumerateInterfaces **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__EnumerateInterfaces, sizeof(_net__EnumerateInterfaces), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetPingResponseResponse(struct soap *soap, _net__GetPingResponseResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetPingResponseResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetPingResponseResponse(struct soap *soap, _net__GetPingResponseResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetPingResponseResponse); + if (soap_out_PointerTo_net__GetPingResponseResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetPingResponseResponse(struct soap *soap, const char *tag, int id, _net__GetPingResponseResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetPingResponseResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetPingResponseResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetPingResponseResponse(struct soap *soap, _net__GetPingResponseResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetPingResponseResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetPingResponseResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetPingResponseResponse(struct soap *soap, const char *tag, _net__GetPingResponseResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetPingResponseResponse **)soap_malloc(soap, sizeof(_net__GetPingResponseResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetPingResponseResponse *)soap_instantiate__net__GetPingResponseResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetPingResponseResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetPingResponseResponse, sizeof(_net__GetPingResponseResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetPingResponse(struct soap *soap, _net__GetPingResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetPingResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetPingResponse(struct soap *soap, _net__GetPingResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetPingResponse); + if (soap_out_PointerTo_net__GetPingResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetPingResponse(struct soap *soap, const char *tag, int id, _net__GetPingResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetPingResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetPingResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetPingResponse(struct soap *soap, _net__GetPingResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetPingResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetPingResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetPingResponse(struct soap *soap, const char *tag, _net__GetPingResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetPingResponse **)soap_malloc(soap, sizeof(_net__GetPingResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetPingResponse *)soap_instantiate__net__GetPingResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetPingResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetPingResponse, sizeof(_net__GetPingResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetPingResponseResponse(struct soap *soap, _net__SetPingResponseResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetPingResponseResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetPingResponseResponse(struct soap *soap, _net__SetPingResponseResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetPingResponseResponse); + if (soap_out_PointerTo_net__SetPingResponseResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetPingResponseResponse(struct soap *soap, const char *tag, int id, _net__SetPingResponseResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetPingResponseResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetPingResponseResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetPingResponseResponse(struct soap *soap, _net__SetPingResponseResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetPingResponseResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetPingResponseResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetPingResponseResponse(struct soap *soap, const char *tag, _net__SetPingResponseResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetPingResponseResponse **)soap_malloc(soap, sizeof(_net__SetPingResponseResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetPingResponseResponse *)soap_instantiate__net__SetPingResponseResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetPingResponseResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetPingResponseResponse, sizeof(_net__SetPingResponseResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetPingResponse(struct soap *soap, _net__SetPingResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetPingResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetPingResponse(struct soap *soap, _net__SetPingResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetPingResponse); + if (soap_out_PointerTo_net__SetPingResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetPingResponse(struct soap *soap, const char *tag, int id, _net__SetPingResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetPingResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetPingResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetPingResponse(struct soap *soap, _net__SetPingResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetPingResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetPingResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetPingResponse(struct soap *soap, const char *tag, _net__SetPingResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetPingResponse **)soap_malloc(soap, sizeof(_net__SetPingResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetPingResponse *)soap_instantiate__net__SetPingResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetPingResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetPingResponse, sizeof(_net__SetPingResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetVlanParametersResponse(struct soap *soap, _net__GetVlanParametersResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetVlanParametersResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetVlanParametersResponse(struct soap *soap, _net__GetVlanParametersResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetVlanParametersResponse); + if (soap_out_PointerTo_net__GetVlanParametersResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetVlanParametersResponse(struct soap *soap, const char *tag, int id, _net__GetVlanParametersResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetVlanParametersResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetVlanParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetVlanParametersResponse(struct soap *soap, _net__GetVlanParametersResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetVlanParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetVlanParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetVlanParametersResponse(struct soap *soap, const char *tag, _net__GetVlanParametersResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetVlanParametersResponse **)soap_malloc(soap, sizeof(_net__GetVlanParametersResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetVlanParametersResponse *)soap_instantiate__net__GetVlanParametersResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetVlanParametersResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetVlanParametersResponse, sizeof(_net__GetVlanParametersResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetVlanParameters(struct soap *soap, _net__GetVlanParameters *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetVlanParameters)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetVlanParameters(struct soap *soap, _net__GetVlanParameters *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetVlanParameters); + if (soap_out_PointerTo_net__GetVlanParameters(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetVlanParameters(struct soap *soap, const char *tag, int id, _net__GetVlanParameters *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetVlanParameters); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetVlanParameters ** SOAP_FMAC4 soap_get_PointerTo_net__GetVlanParameters(struct soap *soap, _net__GetVlanParameters **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetVlanParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetVlanParameters ** SOAP_FMAC4 soap_in_PointerTo_net__GetVlanParameters(struct soap *soap, const char *tag, _net__GetVlanParameters **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetVlanParameters **)soap_malloc(soap, sizeof(_net__GetVlanParameters *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetVlanParameters *)soap_instantiate__net__GetVlanParameters(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetVlanParameters **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetVlanParameters, sizeof(_net__GetVlanParameters), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetVlanParametersResponse(struct soap *soap, _net__SetVlanParametersResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetVlanParametersResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetVlanParametersResponse(struct soap *soap, _net__SetVlanParametersResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetVlanParametersResponse); + if (soap_out_PointerTo_net__SetVlanParametersResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetVlanParametersResponse(struct soap *soap, const char *tag, int id, _net__SetVlanParametersResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetVlanParametersResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetVlanParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetVlanParametersResponse(struct soap *soap, _net__SetVlanParametersResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetVlanParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetVlanParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetVlanParametersResponse(struct soap *soap, const char *tag, _net__SetVlanParametersResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetVlanParametersResponse **)soap_malloc(soap, sizeof(_net__SetVlanParametersResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetVlanParametersResponse *)soap_instantiate__net__SetVlanParametersResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetVlanParametersResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetVlanParametersResponse, sizeof(_net__SetVlanParametersResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetVlanParameters(struct soap *soap, _net__SetVlanParameters *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetVlanParameters)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetVlanParameters(struct soap *soap, _net__SetVlanParameters *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetVlanParameters); + if (soap_out_PointerTo_net__SetVlanParameters(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetVlanParameters(struct soap *soap, const char *tag, int id, _net__SetVlanParameters *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetVlanParameters); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetVlanParameters ** SOAP_FMAC4 soap_get_PointerTo_net__SetVlanParameters(struct soap *soap, _net__SetVlanParameters **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetVlanParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetVlanParameters ** SOAP_FMAC4 soap_in_PointerTo_net__SetVlanParameters(struct soap *soap, const char *tag, _net__SetVlanParameters **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetVlanParameters **)soap_malloc(soap, sizeof(_net__SetVlanParameters *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetVlanParameters *)soap_instantiate__net__SetVlanParameters(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetVlanParameters **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetVlanParameters, sizeof(_net__SetVlanParameters), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetTcpIpParametersResponse(struct soap *soap, _net__GetTcpIpParametersResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetTcpIpParametersResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetTcpIpParametersResponse(struct soap *soap, _net__GetTcpIpParametersResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetTcpIpParametersResponse); + if (soap_out_PointerTo_net__GetTcpIpParametersResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetTcpIpParametersResponse(struct soap *soap, const char *tag, int id, _net__GetTcpIpParametersResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetTcpIpParametersResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetTcpIpParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetTcpIpParametersResponse(struct soap *soap, _net__GetTcpIpParametersResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetTcpIpParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetTcpIpParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetTcpIpParametersResponse(struct soap *soap, const char *tag, _net__GetTcpIpParametersResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetTcpIpParametersResponse **)soap_malloc(soap, sizeof(_net__GetTcpIpParametersResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetTcpIpParametersResponse *)soap_instantiate__net__GetTcpIpParametersResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetTcpIpParametersResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetTcpIpParametersResponse, sizeof(_net__GetTcpIpParametersResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetTcpIpParameters(struct soap *soap, _net__GetTcpIpParameters *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetTcpIpParameters)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetTcpIpParameters(struct soap *soap, _net__GetTcpIpParameters *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetTcpIpParameters); + if (soap_out_PointerTo_net__GetTcpIpParameters(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetTcpIpParameters(struct soap *soap, const char *tag, int id, _net__GetTcpIpParameters *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetTcpIpParameters); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetTcpIpParameters ** SOAP_FMAC4 soap_get_PointerTo_net__GetTcpIpParameters(struct soap *soap, _net__GetTcpIpParameters **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetTcpIpParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetTcpIpParameters ** SOAP_FMAC4 soap_in_PointerTo_net__GetTcpIpParameters(struct soap *soap, const char *tag, _net__GetTcpIpParameters **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetTcpIpParameters **)soap_malloc(soap, sizeof(_net__GetTcpIpParameters *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetTcpIpParameters *)soap_instantiate__net__GetTcpIpParameters(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetTcpIpParameters **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetTcpIpParameters, sizeof(_net__GetTcpIpParameters), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetTcpIpParametersResponse(struct soap *soap, _net__SetTcpIpParametersResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetTcpIpParametersResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetTcpIpParametersResponse(struct soap *soap, _net__SetTcpIpParametersResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetTcpIpParametersResponse); + if (soap_out_PointerTo_net__SetTcpIpParametersResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetTcpIpParametersResponse(struct soap *soap, const char *tag, int id, _net__SetTcpIpParametersResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetTcpIpParametersResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetTcpIpParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetTcpIpParametersResponse(struct soap *soap, _net__SetTcpIpParametersResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetTcpIpParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetTcpIpParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetTcpIpParametersResponse(struct soap *soap, const char *tag, _net__SetTcpIpParametersResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetTcpIpParametersResponse **)soap_malloc(soap, sizeof(_net__SetTcpIpParametersResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetTcpIpParametersResponse *)soap_instantiate__net__SetTcpIpParametersResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetTcpIpParametersResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetTcpIpParametersResponse, sizeof(_net__SetTcpIpParametersResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetTcpIpParameters(struct soap *soap, _net__SetTcpIpParameters *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetTcpIpParameters)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetTcpIpParameters(struct soap *soap, _net__SetTcpIpParameters *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetTcpIpParameters); + if (soap_out_PointerTo_net__SetTcpIpParameters(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetTcpIpParameters(struct soap *soap, const char *tag, int id, _net__SetTcpIpParameters *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetTcpIpParameters); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetTcpIpParameters ** SOAP_FMAC4 soap_get_PointerTo_net__SetTcpIpParameters(struct soap *soap, _net__SetTcpIpParameters **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetTcpIpParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetTcpIpParameters ** SOAP_FMAC4 soap_in_PointerTo_net__SetTcpIpParameters(struct soap *soap, const char *tag, _net__SetTcpIpParameters **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetTcpIpParameters **)soap_malloc(soap, sizeof(_net__SetTcpIpParameters *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetTcpIpParameters *)soap_instantiate__net__SetTcpIpParameters(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetTcpIpParameters **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetTcpIpParameters, sizeof(_net__SetTcpIpParameters), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetDomainNameResponse(struct soap *soap, _net__GetDomainNameResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetDomainNameResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetDomainNameResponse(struct soap *soap, _net__GetDomainNameResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetDomainNameResponse); + if (soap_out_PointerTo_net__GetDomainNameResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetDomainNameResponse(struct soap *soap, const char *tag, int id, _net__GetDomainNameResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetDomainNameResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetDomainNameResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetDomainNameResponse(struct soap *soap, _net__GetDomainNameResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetDomainNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetDomainNameResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetDomainNameResponse(struct soap *soap, const char *tag, _net__GetDomainNameResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetDomainNameResponse **)soap_malloc(soap, sizeof(_net__GetDomainNameResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetDomainNameResponse *)soap_instantiate__net__GetDomainNameResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetDomainNameResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetDomainNameResponse, sizeof(_net__GetDomainNameResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetDomainName(struct soap *soap, _net__GetDomainName *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetDomainName)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetDomainName(struct soap *soap, _net__GetDomainName *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetDomainName); + if (soap_out_PointerTo_net__GetDomainName(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetDomainName(struct soap *soap, const char *tag, int id, _net__GetDomainName *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetDomainName); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetDomainName ** SOAP_FMAC4 soap_get_PointerTo_net__GetDomainName(struct soap *soap, _net__GetDomainName **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetDomainName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetDomainName ** SOAP_FMAC4 soap_in_PointerTo_net__GetDomainName(struct soap *soap, const char *tag, _net__GetDomainName **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetDomainName **)soap_malloc(soap, sizeof(_net__GetDomainName *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetDomainName *)soap_instantiate__net__GetDomainName(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetDomainName **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetDomainName, sizeof(_net__GetDomainName), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetDomainNameResponse(struct soap *soap, _net__SetDomainNameResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetDomainNameResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetDomainNameResponse(struct soap *soap, _net__SetDomainNameResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetDomainNameResponse); + if (soap_out_PointerTo_net__SetDomainNameResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetDomainNameResponse(struct soap *soap, const char *tag, int id, _net__SetDomainNameResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetDomainNameResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetDomainNameResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetDomainNameResponse(struct soap *soap, _net__SetDomainNameResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetDomainNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetDomainNameResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetDomainNameResponse(struct soap *soap, const char *tag, _net__SetDomainNameResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetDomainNameResponse **)soap_malloc(soap, sizeof(_net__SetDomainNameResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetDomainNameResponse *)soap_instantiate__net__SetDomainNameResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetDomainNameResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetDomainNameResponse, sizeof(_net__SetDomainNameResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetDomainName(struct soap *soap, _net__SetDomainName *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetDomainName)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetDomainName(struct soap *soap, _net__SetDomainName *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetDomainName); + if (soap_out_PointerTo_net__SetDomainName(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetDomainName(struct soap *soap, const char *tag, int id, _net__SetDomainName *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetDomainName); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetDomainName ** SOAP_FMAC4 soap_get_PointerTo_net__SetDomainName(struct soap *soap, _net__SetDomainName **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetDomainName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetDomainName ** SOAP_FMAC4 soap_in_PointerTo_net__SetDomainName(struct soap *soap, const char *tag, _net__SetDomainName **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetDomainName **)soap_malloc(soap, sizeof(_net__SetDomainName *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetDomainName *)soap_instantiate__net__SetDomainName(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetDomainName **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetDomainName, sizeof(_net__SetDomainName), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetHostNameResponse(struct soap *soap, _net__GetHostNameResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetHostNameResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetHostNameResponse(struct soap *soap, _net__GetHostNameResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetHostNameResponse); + if (soap_out_PointerTo_net__GetHostNameResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetHostNameResponse(struct soap *soap, const char *tag, int id, _net__GetHostNameResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetHostNameResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetHostNameResponse ** SOAP_FMAC4 soap_get_PointerTo_net__GetHostNameResponse(struct soap *soap, _net__GetHostNameResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetHostNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetHostNameResponse ** SOAP_FMAC4 soap_in_PointerTo_net__GetHostNameResponse(struct soap *soap, const char *tag, _net__GetHostNameResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetHostNameResponse **)soap_malloc(soap, sizeof(_net__GetHostNameResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetHostNameResponse *)soap_instantiate__net__GetHostNameResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetHostNameResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetHostNameResponse, sizeof(_net__GetHostNameResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__GetHostName(struct soap *soap, _net__GetHostName *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__GetHostName)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__GetHostName(struct soap *soap, _net__GetHostName *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__GetHostName); + if (soap_out_PointerTo_net__GetHostName(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__GetHostName(struct soap *soap, const char *tag, int id, _net__GetHostName *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__GetHostName); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__GetHostName ** SOAP_FMAC4 soap_get_PointerTo_net__GetHostName(struct soap *soap, _net__GetHostName **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__GetHostName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__GetHostName ** SOAP_FMAC4 soap_in_PointerTo_net__GetHostName(struct soap *soap, const char *tag, _net__GetHostName **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__GetHostName **)soap_malloc(soap, sizeof(_net__GetHostName *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__GetHostName *)soap_instantiate__net__GetHostName(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__GetHostName **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__GetHostName, sizeof(_net__GetHostName), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetHostNameResponse(struct soap *soap, _net__SetHostNameResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetHostNameResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetHostNameResponse(struct soap *soap, _net__SetHostNameResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetHostNameResponse); + if (soap_out_PointerTo_net__SetHostNameResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetHostNameResponse(struct soap *soap, const char *tag, int id, _net__SetHostNameResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetHostNameResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetHostNameResponse ** SOAP_FMAC4 soap_get_PointerTo_net__SetHostNameResponse(struct soap *soap, _net__SetHostNameResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetHostNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetHostNameResponse ** SOAP_FMAC4 soap_in_PointerTo_net__SetHostNameResponse(struct soap *soap, const char *tag, _net__SetHostNameResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetHostNameResponse **)soap_malloc(soap, sizeof(_net__SetHostNameResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetHostNameResponse *)soap_instantiate__net__SetHostNameResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetHostNameResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetHostNameResponse, sizeof(_net__SetHostNameResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_net__SetHostName(struct soap *soap, _net__SetHostName *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__net__SetHostName)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_net__SetHostName(struct soap *soap, _net__SetHostName *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_net__SetHostName); + if (soap_out_PointerTo_net__SetHostName(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_net__SetHostName(struct soap *soap, const char *tag, int id, _net__SetHostName *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__net__SetHostName); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _net__SetHostName ** SOAP_FMAC4 soap_get_PointerTo_net__SetHostName(struct soap *soap, _net__SetHostName **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_net__SetHostName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _net__SetHostName ** SOAP_FMAC4 soap_in_PointerTo_net__SetHostName(struct soap *soap, const char *tag, _net__SetHostName **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_net__SetHostName **)soap_malloc(soap, sizeof(_net__SetHostName *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_net__SetHostName *)soap_instantiate__net__SetHostName(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_net__SetHostName **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__net__SetHostName, sizeof(_net__SetHostName), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetIderSessionLogResponse(struct soap *soap, _inf__GetIderSessionLogResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetIderSessionLogResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetIderSessionLogResponse(struct soap *soap, _inf__GetIderSessionLogResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetIderSessionLogResponse); + if (soap_out_PointerTo_inf__GetIderSessionLogResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetIderSessionLogResponse(struct soap *soap, const char *tag, int id, _inf__GetIderSessionLogResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetIderSessionLogResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetIderSessionLogResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetIderSessionLogResponse(struct soap *soap, _inf__GetIderSessionLogResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetIderSessionLogResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetIderSessionLogResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetIderSessionLogResponse(struct soap *soap, const char *tag, _inf__GetIderSessionLogResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetIderSessionLogResponse **)soap_malloc(soap, sizeof(_inf__GetIderSessionLogResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetIderSessionLogResponse *)soap_instantiate__inf__GetIderSessionLogResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetIderSessionLogResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetIderSessionLogResponse, sizeof(_inf__GetIderSessionLogResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetIderSessionLog(struct soap *soap, _inf__GetIderSessionLog *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetIderSessionLog)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetIderSessionLog(struct soap *soap, _inf__GetIderSessionLog *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetIderSessionLog); + if (soap_out_PointerTo_inf__GetIderSessionLog(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetIderSessionLog(struct soap *soap, const char *tag, int id, _inf__GetIderSessionLog *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetIderSessionLog); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetIderSessionLog ** SOAP_FMAC4 soap_get_PointerTo_inf__GetIderSessionLog(struct soap *soap, _inf__GetIderSessionLog **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetIderSessionLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetIderSessionLog ** SOAP_FMAC4 soap_in_PointerTo_inf__GetIderSessionLog(struct soap *soap, const char *tag, _inf__GetIderSessionLog **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetIderSessionLog **)soap_malloc(soap, sizeof(_inf__GetIderSessionLog *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetIderSessionLog *)soap_instantiate__inf__GetIderSessionLog(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetIderSessionLog **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetIderSessionLog, sizeof(_inf__GetIderSessionLog), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetSecurityParametersResponse(struct soap *soap, _inf__GetSecurityParametersResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetSecurityParametersResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetSecurityParametersResponse(struct soap *soap, _inf__GetSecurityParametersResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetSecurityParametersResponse); + if (soap_out_PointerTo_inf__GetSecurityParametersResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetSecurityParametersResponse(struct soap *soap, const char *tag, int id, _inf__GetSecurityParametersResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetSecurityParametersResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetSecurityParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetSecurityParametersResponse(struct soap *soap, _inf__GetSecurityParametersResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetSecurityParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetSecurityParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetSecurityParametersResponse(struct soap *soap, const char *tag, _inf__GetSecurityParametersResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetSecurityParametersResponse **)soap_malloc(soap, sizeof(_inf__GetSecurityParametersResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetSecurityParametersResponse *)soap_instantiate__inf__GetSecurityParametersResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetSecurityParametersResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetSecurityParametersResponse, sizeof(_inf__GetSecurityParametersResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetSecurityParameters(struct soap *soap, _inf__GetSecurityParameters *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetSecurityParameters)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetSecurityParameters(struct soap *soap, _inf__GetSecurityParameters *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetSecurityParameters); + if (soap_out_PointerTo_inf__GetSecurityParameters(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetSecurityParameters(struct soap *soap, const char *tag, int id, _inf__GetSecurityParameters *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetSecurityParameters); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetSecurityParameters ** SOAP_FMAC4 soap_get_PointerTo_inf__GetSecurityParameters(struct soap *soap, _inf__GetSecurityParameters **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetSecurityParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetSecurityParameters ** SOAP_FMAC4 soap_in_PointerTo_inf__GetSecurityParameters(struct soap *soap, const char *tag, _inf__GetSecurityParameters **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetSecurityParameters **)soap_malloc(soap, sizeof(_inf__GetSecurityParameters *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetSecurityParameters *)soap_instantiate__inf__GetSecurityParameters(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetSecurityParameters **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetSecurityParameters, sizeof(_inf__GetSecurityParameters), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetNetworkStateResponse(struct soap *soap, _inf__GetNetworkStateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetNetworkStateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetNetworkStateResponse(struct soap *soap, _inf__GetNetworkStateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetNetworkStateResponse); + if (soap_out_PointerTo_inf__GetNetworkStateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetNetworkStateResponse(struct soap *soap, const char *tag, int id, _inf__GetNetworkStateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetNetworkStateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetNetworkStateResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetNetworkStateResponse(struct soap *soap, _inf__GetNetworkStateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetNetworkStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetNetworkStateResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetNetworkStateResponse(struct soap *soap, const char *tag, _inf__GetNetworkStateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetNetworkStateResponse **)soap_malloc(soap, sizeof(_inf__GetNetworkStateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetNetworkStateResponse *)soap_instantiate__inf__GetNetworkStateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetNetworkStateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetNetworkStateResponse, sizeof(_inf__GetNetworkStateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetNetworkState(struct soap *soap, _inf__GetNetworkState *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetNetworkState)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetNetworkState(struct soap *soap, _inf__GetNetworkState *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetNetworkState); + if (soap_out_PointerTo_inf__GetNetworkState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetNetworkState(struct soap *soap, const char *tag, int id, _inf__GetNetworkState *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetNetworkState); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetNetworkState ** SOAP_FMAC4 soap_get_PointerTo_inf__GetNetworkState(struct soap *soap, _inf__GetNetworkState **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetNetworkState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetNetworkState ** SOAP_FMAC4 soap_in_PointerTo_inf__GetNetworkState(struct soap *soap, const char *tag, _inf__GetNetworkState **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetNetworkState **)soap_malloc(soap, sizeof(_inf__GetNetworkState *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetNetworkState *)soap_instantiate__inf__GetNetworkState(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetNetworkState **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetNetworkState, sizeof(_inf__GetNetworkState), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetEnabledInterfacesResponse(struct soap *soap, _inf__GetEnabledInterfacesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetEnabledInterfacesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetEnabledInterfacesResponse(struct soap *soap, _inf__GetEnabledInterfacesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetEnabledInterfacesResponse); + if (soap_out_PointerTo_inf__GetEnabledInterfacesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetEnabledInterfacesResponse(struct soap *soap, const char *tag, int id, _inf__GetEnabledInterfacesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetEnabledInterfacesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetEnabledInterfacesResponse(struct soap *soap, _inf__GetEnabledInterfacesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetEnabledInterfacesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetEnabledInterfacesResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetEnabledInterfacesResponse(struct soap *soap, const char *tag, _inf__GetEnabledInterfacesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetEnabledInterfacesResponse **)soap_malloc(soap, sizeof(_inf__GetEnabledInterfacesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetEnabledInterfacesResponse *)soap_instantiate__inf__GetEnabledInterfacesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetEnabledInterfacesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetEnabledInterfacesResponse, sizeof(_inf__GetEnabledInterfacesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetEnabledInterfaces(struct soap *soap, _inf__GetEnabledInterfaces *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetEnabledInterfaces)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetEnabledInterfaces(struct soap *soap, _inf__GetEnabledInterfaces *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetEnabledInterfaces); + if (soap_out_PointerTo_inf__GetEnabledInterfaces(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetEnabledInterfaces(struct soap *soap, const char *tag, int id, _inf__GetEnabledInterfaces *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetEnabledInterfaces); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetEnabledInterfaces ** SOAP_FMAC4 soap_get_PointerTo_inf__GetEnabledInterfaces(struct soap *soap, _inf__GetEnabledInterfaces **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetEnabledInterfaces(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetEnabledInterfaces ** SOAP_FMAC4 soap_in_PointerTo_inf__GetEnabledInterfaces(struct soap *soap, const char *tag, _inf__GetEnabledInterfaces **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetEnabledInterfaces **)soap_malloc(soap, sizeof(_inf__GetEnabledInterfaces *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetEnabledInterfaces *)soap_instantiate__inf__GetEnabledInterfaces(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetEnabledInterfaces **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetEnabledInterfaces, sizeof(_inf__GetEnabledInterfaces), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetPasswordModelResponse(struct soap *soap, _inf__GetPasswordModelResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetPasswordModelResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetPasswordModelResponse(struct soap *soap, _inf__GetPasswordModelResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetPasswordModelResponse); + if (soap_out_PointerTo_inf__GetPasswordModelResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetPasswordModelResponse(struct soap *soap, const char *tag, int id, _inf__GetPasswordModelResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetPasswordModelResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetPasswordModelResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetPasswordModelResponse(struct soap *soap, _inf__GetPasswordModelResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetPasswordModelResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetPasswordModelResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetPasswordModelResponse(struct soap *soap, const char *tag, _inf__GetPasswordModelResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetPasswordModelResponse **)soap_malloc(soap, sizeof(_inf__GetPasswordModelResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetPasswordModelResponse *)soap_instantiate__inf__GetPasswordModelResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetPasswordModelResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetPasswordModelResponse, sizeof(_inf__GetPasswordModelResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetPasswordModel(struct soap *soap, _inf__GetPasswordModel *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetPasswordModel)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetPasswordModel(struct soap *soap, _inf__GetPasswordModel *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetPasswordModel); + if (soap_out_PointerTo_inf__GetPasswordModel(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetPasswordModel(struct soap *soap, const char *tag, int id, _inf__GetPasswordModel *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetPasswordModel); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetPasswordModel ** SOAP_FMAC4 soap_get_PointerTo_inf__GetPasswordModel(struct soap *soap, _inf__GetPasswordModel **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetPasswordModel(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetPasswordModel ** SOAP_FMAC4 soap_in_PointerTo_inf__GetPasswordModel(struct soap *soap, const char *tag, _inf__GetPasswordModel **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetPasswordModel **)soap_malloc(soap, sizeof(_inf__GetPasswordModel *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetPasswordModel *)soap_instantiate__inf__GetPasswordModel(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetPasswordModel **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetPasswordModel, sizeof(_inf__GetPasswordModel), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, _inf__GetAdminNetAclEntryStatusResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, _inf__GetAdminNetAclEntryStatusResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatusResponse); + if (soap_out_PointerTo_inf__GetAdminNetAclEntryStatusResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, const char *tag, int id, _inf__GetAdminNetAclEntryStatusResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, _inf__GetAdminNetAclEntryStatusResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetAdminNetAclEntryStatusResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatusResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetAdminNetAclEntryStatusResponse(struct soap *soap, const char *tag, _inf__GetAdminNetAclEntryStatusResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetAdminNetAclEntryStatusResponse **)soap_malloc(soap, sizeof(_inf__GetAdminNetAclEntryStatusResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetAdminNetAclEntryStatusResponse *)soap_instantiate__inf__GetAdminNetAclEntryStatusResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetAdminNetAclEntryStatusResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetAdminNetAclEntryStatusResponse, sizeof(_inf__GetAdminNetAclEntryStatusResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap *soap, _inf__GetAdminNetAclEntryStatus *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetAdminNetAclEntryStatus)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap *soap, _inf__GetAdminNetAclEntryStatus *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetAdminNetAclEntryStatus); + if (soap_out_PointerTo_inf__GetAdminNetAclEntryStatus(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap *soap, const char *tag, int id, _inf__GetAdminNetAclEntryStatus *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetAdminNetAclEntryStatus); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus ** SOAP_FMAC4 soap_get_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap *soap, _inf__GetAdminNetAclEntryStatus **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetAdminNetAclEntryStatus(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetAdminNetAclEntryStatus ** SOAP_FMAC4 soap_in_PointerTo_inf__GetAdminNetAclEntryStatus(struct soap *soap, const char *tag, _inf__GetAdminNetAclEntryStatus **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetAdminNetAclEntryStatus **)soap_malloc(soap, sizeof(_inf__GetAdminNetAclEntryStatus *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetAdminNetAclEntryStatus *)soap_instantiate__inf__GetAdminNetAclEntryStatus(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetAdminNetAclEntryStatus **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetAdminNetAclEntryStatus, sizeof(_inf__GetAdminNetAclEntryStatus), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap *soap, _inf__GetAdminAclEntryStatusResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetAdminAclEntryStatusResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap *soap, _inf__GetAdminAclEntryStatusResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatusResponse); + if (soap_out_PointerTo_inf__GetAdminAclEntryStatusResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap *soap, const char *tag, int id, _inf__GetAdminAclEntryStatusResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetAdminAclEntryStatusResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap *soap, _inf__GetAdminAclEntryStatusResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetAdminAclEntryStatusResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatusResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetAdminAclEntryStatusResponse(struct soap *soap, const char *tag, _inf__GetAdminAclEntryStatusResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetAdminAclEntryStatusResponse **)soap_malloc(soap, sizeof(_inf__GetAdminAclEntryStatusResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetAdminAclEntryStatusResponse *)soap_instantiate__inf__GetAdminAclEntryStatusResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetAdminAclEntryStatusResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetAdminAclEntryStatusResponse, sizeof(_inf__GetAdminAclEntryStatusResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetAdminAclEntryStatus(struct soap *soap, _inf__GetAdminAclEntryStatus *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetAdminAclEntryStatus)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetAdminAclEntryStatus(struct soap *soap, _inf__GetAdminAclEntryStatus *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetAdminAclEntryStatus); + if (soap_out_PointerTo_inf__GetAdminAclEntryStatus(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetAdminAclEntryStatus(struct soap *soap, const char *tag, int id, _inf__GetAdminAclEntryStatus *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetAdminAclEntryStatus); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatus ** SOAP_FMAC4 soap_get_PointerTo_inf__GetAdminAclEntryStatus(struct soap *soap, _inf__GetAdminAclEntryStatus **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetAdminAclEntryStatus(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetAdminAclEntryStatus ** SOAP_FMAC4 soap_in_PointerTo_inf__GetAdminAclEntryStatus(struct soap *soap, const char *tag, _inf__GetAdminAclEntryStatus **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetAdminAclEntryStatus **)soap_malloc(soap, sizeof(_inf__GetAdminAclEntryStatus *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetAdminAclEntryStatus *)soap_instantiate__inf__GetAdminAclEntryStatus(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetAdminAclEntryStatus **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetAdminAclEntryStatus, sizeof(_inf__GetAdminAclEntryStatus), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetConfigServerInfoResponse(struct soap *soap, _inf__GetConfigServerInfoResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetConfigServerInfoResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetConfigServerInfoResponse(struct soap *soap, _inf__GetConfigServerInfoResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetConfigServerInfoResponse); + if (soap_out_PointerTo_inf__GetConfigServerInfoResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetConfigServerInfoResponse(struct soap *soap, const char *tag, int id, _inf__GetConfigServerInfoResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetConfigServerInfoResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetConfigServerInfoResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetConfigServerInfoResponse(struct soap *soap, _inf__GetConfigServerInfoResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetConfigServerInfoResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetConfigServerInfoResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetConfigServerInfoResponse(struct soap *soap, const char *tag, _inf__GetConfigServerInfoResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetConfigServerInfoResponse **)soap_malloc(soap, sizeof(_inf__GetConfigServerInfoResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetConfigServerInfoResponse *)soap_instantiate__inf__GetConfigServerInfoResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetConfigServerInfoResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetConfigServerInfoResponse, sizeof(_inf__GetConfigServerInfoResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetConfigServerInfo(struct soap *soap, _inf__GetConfigServerInfo *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetConfigServerInfo)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetConfigServerInfo(struct soap *soap, _inf__GetConfigServerInfo *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetConfigServerInfo); + if (soap_out_PointerTo_inf__GetConfigServerInfo(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetConfigServerInfo(struct soap *soap, const char *tag, int id, _inf__GetConfigServerInfo *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetConfigServerInfo); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetConfigServerInfo ** SOAP_FMAC4 soap_get_PointerTo_inf__GetConfigServerInfo(struct soap *soap, _inf__GetConfigServerInfo **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetConfigServerInfo(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetConfigServerInfo ** SOAP_FMAC4 soap_in_PointerTo_inf__GetConfigServerInfo(struct soap *soap, const char *tag, _inf__GetConfigServerInfo **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetConfigServerInfo **)soap_malloc(soap, sizeof(_inf__GetConfigServerInfo *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetConfigServerInfo *)soap_instantiate__inf__GetConfigServerInfo(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetConfigServerInfo **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetConfigServerInfo, sizeof(_inf__GetConfigServerInfo), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetHostNameResponse(struct soap *soap, _inf__GetHostNameResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetHostNameResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetHostNameResponse(struct soap *soap, _inf__GetHostNameResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetHostNameResponse); + if (soap_out_PointerTo_inf__GetHostNameResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetHostNameResponse(struct soap *soap, const char *tag, int id, _inf__GetHostNameResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetHostNameResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetHostNameResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetHostNameResponse(struct soap *soap, _inf__GetHostNameResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetHostNameResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetHostNameResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetHostNameResponse(struct soap *soap, const char *tag, _inf__GetHostNameResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetHostNameResponse **)soap_malloc(soap, sizeof(_inf__GetHostNameResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetHostNameResponse *)soap_instantiate__inf__GetHostNameResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetHostNameResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetHostNameResponse, sizeof(_inf__GetHostNameResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetHostName(struct soap *soap, _inf__GetHostName *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetHostName)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetHostName(struct soap *soap, _inf__GetHostName *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetHostName); + if (soap_out_PointerTo_inf__GetHostName(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetHostName(struct soap *soap, const char *tag, int id, _inf__GetHostName *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetHostName); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetHostName ** SOAP_FMAC4 soap_get_PointerTo_inf__GetHostName(struct soap *soap, _inf__GetHostName **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetHostName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetHostName ** SOAP_FMAC4 soap_in_PointerTo_inf__GetHostName(struct soap *soap, const char *tag, _inf__GetHostName **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetHostName **)soap_malloc(soap, sizeof(_inf__GetHostName *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetHostName *)soap_instantiate__inf__GetHostName(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetHostName **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetHostName, sizeof(_inf__GetHostName), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetVlanParametersResponse(struct soap *soap, _inf__GetVlanParametersResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetVlanParametersResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetVlanParametersResponse(struct soap *soap, _inf__GetVlanParametersResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetVlanParametersResponse); + if (soap_out_PointerTo_inf__GetVlanParametersResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetVlanParametersResponse(struct soap *soap, const char *tag, int id, _inf__GetVlanParametersResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetVlanParametersResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetVlanParametersResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetVlanParametersResponse(struct soap *soap, _inf__GetVlanParametersResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetVlanParametersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetVlanParametersResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetVlanParametersResponse(struct soap *soap, const char *tag, _inf__GetVlanParametersResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetVlanParametersResponse **)soap_malloc(soap, sizeof(_inf__GetVlanParametersResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetVlanParametersResponse *)soap_instantiate__inf__GetVlanParametersResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetVlanParametersResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetVlanParametersResponse, sizeof(_inf__GetVlanParametersResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetVlanParameters(struct soap *soap, _inf__GetVlanParameters *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetVlanParameters)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetVlanParameters(struct soap *soap, _inf__GetVlanParameters *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetVlanParameters); + if (soap_out_PointerTo_inf__GetVlanParameters(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetVlanParameters(struct soap *soap, const char *tag, int id, _inf__GetVlanParameters *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetVlanParameters); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetVlanParameters ** SOAP_FMAC4 soap_get_PointerTo_inf__GetVlanParameters(struct soap *soap, _inf__GetVlanParameters **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetVlanParameters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetVlanParameters ** SOAP_FMAC4 soap_in_PointerTo_inf__GetVlanParameters(struct soap *soap, const char *tag, _inf__GetVlanParameters **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetVlanParameters **)soap_malloc(soap, sizeof(_inf__GetVlanParameters *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetVlanParameters *)soap_instantiate__inf__GetVlanParameters(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetVlanParameters **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetVlanParameters, sizeof(_inf__GetVlanParameters), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetProvisioningStateResponse(struct soap *soap, _inf__GetProvisioningStateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetProvisioningStateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetProvisioningStateResponse(struct soap *soap, _inf__GetProvisioningStateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetProvisioningStateResponse); + if (soap_out_PointerTo_inf__GetProvisioningStateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetProvisioningStateResponse(struct soap *soap, const char *tag, int id, _inf__GetProvisioningStateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetProvisioningStateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetProvisioningStateResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetProvisioningStateResponse(struct soap *soap, _inf__GetProvisioningStateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetProvisioningStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetProvisioningStateResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetProvisioningStateResponse(struct soap *soap, const char *tag, _inf__GetProvisioningStateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetProvisioningStateResponse **)soap_malloc(soap, sizeof(_inf__GetProvisioningStateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetProvisioningStateResponse *)soap_instantiate__inf__GetProvisioningStateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetProvisioningStateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetProvisioningStateResponse, sizeof(_inf__GetProvisioningStateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetProvisioningState(struct soap *soap, _inf__GetProvisioningState *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetProvisioningState)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetProvisioningState(struct soap *soap, _inf__GetProvisioningState *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetProvisioningState); + if (soap_out_PointerTo_inf__GetProvisioningState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetProvisioningState(struct soap *soap, const char *tag, int id, _inf__GetProvisioningState *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetProvisioningState); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetProvisioningState ** SOAP_FMAC4 soap_get_PointerTo_inf__GetProvisioningState(struct soap *soap, _inf__GetProvisioningState **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetProvisioningState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetProvisioningState ** SOAP_FMAC4 soap_in_PointerTo_inf__GetProvisioningState(struct soap *soap, const char *tag, _inf__GetProvisioningState **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetProvisioningState **)soap_malloc(soap, sizeof(_inf__GetProvisioningState *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetProvisioningState *)soap_instantiate__inf__GetProvisioningState(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetProvisioningState **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetProvisioningState, sizeof(_inf__GetProvisioningState), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetProvisioningModeResponse(struct soap *soap, _inf__GetProvisioningModeResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetProvisioningModeResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetProvisioningModeResponse(struct soap *soap, _inf__GetProvisioningModeResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetProvisioningModeResponse); + if (soap_out_PointerTo_inf__GetProvisioningModeResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetProvisioningModeResponse(struct soap *soap, const char *tag, int id, _inf__GetProvisioningModeResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetProvisioningModeResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetProvisioningModeResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetProvisioningModeResponse(struct soap *soap, _inf__GetProvisioningModeResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetProvisioningModeResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetProvisioningModeResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetProvisioningModeResponse(struct soap *soap, const char *tag, _inf__GetProvisioningModeResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetProvisioningModeResponse **)soap_malloc(soap, sizeof(_inf__GetProvisioningModeResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetProvisioningModeResponse *)soap_instantiate__inf__GetProvisioningModeResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetProvisioningModeResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetProvisioningModeResponse, sizeof(_inf__GetProvisioningModeResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetProvisioningMode(struct soap *soap, _inf__GetProvisioningMode *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetProvisioningMode)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetProvisioningMode(struct soap *soap, _inf__GetProvisioningMode *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetProvisioningMode); + if (soap_out_PointerTo_inf__GetProvisioningMode(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetProvisioningMode(struct soap *soap, const char *tag, int id, _inf__GetProvisioningMode *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetProvisioningMode); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetProvisioningMode ** SOAP_FMAC4 soap_get_PointerTo_inf__GetProvisioningMode(struct soap *soap, _inf__GetProvisioningMode **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetProvisioningMode(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetProvisioningMode ** SOAP_FMAC4 soap_in_PointerTo_inf__GetProvisioningMode(struct soap *soap, const char *tag, _inf__GetProvisioningMode **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetProvisioningMode **)soap_malloc(soap, sizeof(_inf__GetProvisioningMode *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetProvisioningMode *)soap_instantiate__inf__GetProvisioningMode(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetProvisioningMode **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetProvisioningMode, sizeof(_inf__GetProvisioningMode), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetCodeVersionsResponse(struct soap *soap, _inf__GetCodeVersionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetCodeVersionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetCodeVersionsResponse(struct soap *soap, _inf__GetCodeVersionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetCodeVersionsResponse); + if (soap_out_PointerTo_inf__GetCodeVersionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetCodeVersionsResponse(struct soap *soap, const char *tag, int id, _inf__GetCodeVersionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetCodeVersionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetCodeVersionsResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetCodeVersionsResponse(struct soap *soap, _inf__GetCodeVersionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetCodeVersionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetCodeVersionsResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetCodeVersionsResponse(struct soap *soap, const char *tag, _inf__GetCodeVersionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetCodeVersionsResponse **)soap_malloc(soap, sizeof(_inf__GetCodeVersionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetCodeVersionsResponse *)soap_instantiate__inf__GetCodeVersionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetCodeVersionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetCodeVersionsResponse, sizeof(_inf__GetCodeVersionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetCodeVersions(struct soap *soap, _inf__GetCodeVersions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetCodeVersions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetCodeVersions(struct soap *soap, _inf__GetCodeVersions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetCodeVersions); + if (soap_out_PointerTo_inf__GetCodeVersions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetCodeVersions(struct soap *soap, const char *tag, int id, _inf__GetCodeVersions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetCodeVersions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetCodeVersions ** SOAP_FMAC4 soap_get_PointerTo_inf__GetCodeVersions(struct soap *soap, _inf__GetCodeVersions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetCodeVersions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetCodeVersions ** SOAP_FMAC4 soap_in_PointerTo_inf__GetCodeVersions(struct soap *soap, const char *tag, _inf__GetCodeVersions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetCodeVersions **)soap_malloc(soap, sizeof(_inf__GetCodeVersions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetCodeVersions *)soap_instantiate__inf__GetCodeVersions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetCodeVersions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetCodeVersions, sizeof(_inf__GetCodeVersions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetCoreVersionResponse(struct soap *soap, _inf__GetCoreVersionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetCoreVersionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetCoreVersionResponse(struct soap *soap, _inf__GetCoreVersionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetCoreVersionResponse); + if (soap_out_PointerTo_inf__GetCoreVersionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetCoreVersionResponse(struct soap *soap, const char *tag, int id, _inf__GetCoreVersionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetCoreVersionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetCoreVersionResponse ** SOAP_FMAC4 soap_get_PointerTo_inf__GetCoreVersionResponse(struct soap *soap, _inf__GetCoreVersionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetCoreVersionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetCoreVersionResponse ** SOAP_FMAC4 soap_in_PointerTo_inf__GetCoreVersionResponse(struct soap *soap, const char *tag, _inf__GetCoreVersionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetCoreVersionResponse **)soap_malloc(soap, sizeof(_inf__GetCoreVersionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetCoreVersionResponse *)soap_instantiate__inf__GetCoreVersionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetCoreVersionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetCoreVersionResponse, sizeof(_inf__GetCoreVersionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_inf__GetCoreVersion(struct soap *soap, _inf__GetCoreVersion *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__inf__GetCoreVersion)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_inf__GetCoreVersion(struct soap *soap, _inf__GetCoreVersion *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_inf__GetCoreVersion); + if (soap_out_PointerTo_inf__GetCoreVersion(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_inf__GetCoreVersion(struct soap *soap, const char *tag, int id, _inf__GetCoreVersion *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__inf__GetCoreVersion); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _inf__GetCoreVersion ** SOAP_FMAC4 soap_get_PointerTo_inf__GetCoreVersion(struct soap *soap, _inf__GetCoreVersion **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_inf__GetCoreVersion(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _inf__GetCoreVersion ** SOAP_FMAC4 soap_in_PointerTo_inf__GetCoreVersion(struct soap *soap, const char *tag, _inf__GetCoreVersion **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_inf__GetCoreVersion **)soap_malloc(soap, sizeof(_inf__GetCoreVersion *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_inf__GetCoreVersion *)soap_instantiate__inf__GetCoreVersion(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_inf__GetCoreVersion **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__inf__GetCoreVersion, sizeof(_inf__GetCoreVersion), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__GetIderSessionLogResponse(struct soap *soap, _idr__GetIderSessionLogResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__idr__GetIderSessionLogResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__GetIderSessionLogResponse(struct soap *soap, _idr__GetIderSessionLogResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_idr__GetIderSessionLogResponse); + if (soap_out_PointerTo_idr__GetIderSessionLogResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__GetIderSessionLogResponse(struct soap *soap, const char *tag, int id, _idr__GetIderSessionLogResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__idr__GetIderSessionLogResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _idr__GetIderSessionLogResponse ** SOAP_FMAC4 soap_get_PointerTo_idr__GetIderSessionLogResponse(struct soap *soap, _idr__GetIderSessionLogResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_idr__GetIderSessionLogResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _idr__GetIderSessionLogResponse ** SOAP_FMAC4 soap_in_PointerTo_idr__GetIderSessionLogResponse(struct soap *soap, const char *tag, _idr__GetIderSessionLogResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_idr__GetIderSessionLogResponse **)soap_malloc(soap, sizeof(_idr__GetIderSessionLogResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_idr__GetIderSessionLogResponse *)soap_instantiate__idr__GetIderSessionLogResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_idr__GetIderSessionLogResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__idr__GetIderSessionLogResponse, sizeof(_idr__GetIderSessionLogResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__GetIderSessionLog(struct soap *soap, _idr__GetIderSessionLog *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__idr__GetIderSessionLog)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__GetIderSessionLog(struct soap *soap, _idr__GetIderSessionLog *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_idr__GetIderSessionLog); + if (soap_out_PointerTo_idr__GetIderSessionLog(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__GetIderSessionLog(struct soap *soap, const char *tag, int id, _idr__GetIderSessionLog *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__idr__GetIderSessionLog); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _idr__GetIderSessionLog ** SOAP_FMAC4 soap_get_PointerTo_idr__GetIderSessionLog(struct soap *soap, _idr__GetIderSessionLog **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_idr__GetIderSessionLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _idr__GetIderSessionLog ** SOAP_FMAC4 soap_in_PointerTo_idr__GetIderSessionLog(struct soap *soap, const char *tag, _idr__GetIderSessionLog **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_idr__GetIderSessionLog **)soap_malloc(soap, sizeof(_idr__GetIderSessionLog *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_idr__GetIderSessionLog *)soap_instantiate__idr__GetIderSessionLog(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_idr__GetIderSessionLog **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__idr__GetIderSessionLog, sizeof(_idr__GetIderSessionLog), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap *soap, _idr__GetRedirectionListenerStateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__idr__GetRedirectionListenerStateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap *soap, _idr__GetRedirectionListenerStateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_idr__GetRedirectionListenerStateResponse); + if (soap_out_PointerTo_idr__GetRedirectionListenerStateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap *soap, const char *tag, int id, _idr__GetRedirectionListenerStateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__idr__GetRedirectionListenerStateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse ** SOAP_FMAC4 soap_get_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap *soap, _idr__GetRedirectionListenerStateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_idr__GetRedirectionListenerStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _idr__GetRedirectionListenerStateResponse ** SOAP_FMAC4 soap_in_PointerTo_idr__GetRedirectionListenerStateResponse(struct soap *soap, const char *tag, _idr__GetRedirectionListenerStateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_idr__GetRedirectionListenerStateResponse **)soap_malloc(soap, sizeof(_idr__GetRedirectionListenerStateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_idr__GetRedirectionListenerStateResponse *)soap_instantiate__idr__GetRedirectionListenerStateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_idr__GetRedirectionListenerStateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__idr__GetRedirectionListenerStateResponse, sizeof(_idr__GetRedirectionListenerStateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__GetRedirectionListenerState(struct soap *soap, _idr__GetRedirectionListenerState *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__idr__GetRedirectionListenerState)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__GetRedirectionListenerState(struct soap *soap, _idr__GetRedirectionListenerState *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_idr__GetRedirectionListenerState); + if (soap_out_PointerTo_idr__GetRedirectionListenerState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__GetRedirectionListenerState(struct soap *soap, const char *tag, int id, _idr__GetRedirectionListenerState *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__idr__GetRedirectionListenerState); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _idr__GetRedirectionListenerState ** SOAP_FMAC4 soap_get_PointerTo_idr__GetRedirectionListenerState(struct soap *soap, _idr__GetRedirectionListenerState **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_idr__GetRedirectionListenerState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _idr__GetRedirectionListenerState ** SOAP_FMAC4 soap_in_PointerTo_idr__GetRedirectionListenerState(struct soap *soap, const char *tag, _idr__GetRedirectionListenerState **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_idr__GetRedirectionListenerState **)soap_malloc(soap, sizeof(_idr__GetRedirectionListenerState *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_idr__GetRedirectionListenerState *)soap_instantiate__idr__GetRedirectionListenerState(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_idr__GetRedirectionListenerState **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__idr__GetRedirectionListenerState, sizeof(_idr__GetRedirectionListenerState), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap *soap, _idr__SetRedirectionListenerStateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__idr__SetRedirectionListenerStateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap *soap, _idr__SetRedirectionListenerStateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_idr__SetRedirectionListenerStateResponse); + if (soap_out_PointerTo_idr__SetRedirectionListenerStateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap *soap, const char *tag, int id, _idr__SetRedirectionListenerStateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__idr__SetRedirectionListenerStateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse ** SOAP_FMAC4 soap_get_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap *soap, _idr__SetRedirectionListenerStateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_idr__SetRedirectionListenerStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _idr__SetRedirectionListenerStateResponse ** SOAP_FMAC4 soap_in_PointerTo_idr__SetRedirectionListenerStateResponse(struct soap *soap, const char *tag, _idr__SetRedirectionListenerStateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_idr__SetRedirectionListenerStateResponse **)soap_malloc(soap, sizeof(_idr__SetRedirectionListenerStateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_idr__SetRedirectionListenerStateResponse *)soap_instantiate__idr__SetRedirectionListenerStateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_idr__SetRedirectionListenerStateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__idr__SetRedirectionListenerStateResponse, sizeof(_idr__SetRedirectionListenerStateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_idr__SetRedirectionListenerState(struct soap *soap, _idr__SetRedirectionListenerState *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__idr__SetRedirectionListenerState)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_idr__SetRedirectionListenerState(struct soap *soap, _idr__SetRedirectionListenerState *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_idr__SetRedirectionListenerState); + if (soap_out_PointerTo_idr__SetRedirectionListenerState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_idr__SetRedirectionListenerState(struct soap *soap, const char *tag, int id, _idr__SetRedirectionListenerState *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__idr__SetRedirectionListenerState); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _idr__SetRedirectionListenerState ** SOAP_FMAC4 soap_get_PointerTo_idr__SetRedirectionListenerState(struct soap *soap, _idr__SetRedirectionListenerState **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_idr__SetRedirectionListenerState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _idr__SetRedirectionListenerState ** SOAP_FMAC4 soap_in_PointerTo_idr__SetRedirectionListenerState(struct soap *soap, const char *tag, _idr__SetRedirectionListenerState **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_idr__SetRedirectionListenerState **)soap_malloc(soap, sizeof(_idr__SetRedirectionListenerState *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_idr__SetRedirectionListenerState *)soap_instantiate__idr__SetRedirectionListenerState(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_idr__SetRedirectionListenerState **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__idr__SetRedirectionListenerState, sizeof(_idr__SetRedirectionListenerState), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_hwa__GetAssetDataResponse(struct soap *soap, _hwa__GetAssetDataResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__hwa__GetAssetDataResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_hwa__GetAssetDataResponse(struct soap *soap, _hwa__GetAssetDataResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_hwa__GetAssetDataResponse); + if (soap_out_PointerTo_hwa__GetAssetDataResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_hwa__GetAssetDataResponse(struct soap *soap, const char *tag, int id, _hwa__GetAssetDataResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__hwa__GetAssetDataResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _hwa__GetAssetDataResponse ** SOAP_FMAC4 soap_get_PointerTo_hwa__GetAssetDataResponse(struct soap *soap, _hwa__GetAssetDataResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_hwa__GetAssetDataResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _hwa__GetAssetDataResponse ** SOAP_FMAC4 soap_in_PointerTo_hwa__GetAssetDataResponse(struct soap *soap, const char *tag, _hwa__GetAssetDataResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_hwa__GetAssetDataResponse **)soap_malloc(soap, sizeof(_hwa__GetAssetDataResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_hwa__GetAssetDataResponse *)soap_instantiate__hwa__GetAssetDataResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_hwa__GetAssetDataResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__hwa__GetAssetDataResponse, sizeof(_hwa__GetAssetDataResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_hwa__GetAssetData(struct soap *soap, _hwa__GetAssetData *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__hwa__GetAssetData)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_hwa__GetAssetData(struct soap *soap, _hwa__GetAssetData *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_hwa__GetAssetData); + if (soap_out_PointerTo_hwa__GetAssetData(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_hwa__GetAssetData(struct soap *soap, const char *tag, int id, _hwa__GetAssetData *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__hwa__GetAssetData); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _hwa__GetAssetData ** SOAP_FMAC4 soap_get_PointerTo_hwa__GetAssetData(struct soap *soap, _hwa__GetAssetData **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_hwa__GetAssetData(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _hwa__GetAssetData ** SOAP_FMAC4 soap_in_PointerTo_hwa__GetAssetData(struct soap *soap, const char *tag, _hwa__GetAssetData **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_hwa__GetAssetData **)soap_malloc(soap, sizeof(_hwa__GetAssetData *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_hwa__GetAssetData *)soap_instantiate__hwa__GetAssetData(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_hwa__GetAssetData **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__hwa__GetAssetData, sizeof(_hwa__GetAssetData), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap *soap, _hwa__EnumerateAssetTypesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__hwa__EnumerateAssetTypesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap *soap, _hwa__EnumerateAssetTypesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypesResponse); + if (soap_out_PointerTo_hwa__EnumerateAssetTypesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap *soap, const char *tag, int id, _hwa__EnumerateAssetTypesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__hwa__EnumerateAssetTypesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse ** SOAP_FMAC4 soap_get_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap *soap, _hwa__EnumerateAssetTypesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_hwa__EnumerateAssetTypesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypesResponse ** SOAP_FMAC4 soap_in_PointerTo_hwa__EnumerateAssetTypesResponse(struct soap *soap, const char *tag, _hwa__EnumerateAssetTypesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_hwa__EnumerateAssetTypesResponse **)soap_malloc(soap, sizeof(_hwa__EnumerateAssetTypesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_hwa__EnumerateAssetTypesResponse *)soap_instantiate__hwa__EnumerateAssetTypesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_hwa__EnumerateAssetTypesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__hwa__EnumerateAssetTypesResponse, sizeof(_hwa__EnumerateAssetTypesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_hwa__EnumerateAssetTypes(struct soap *soap, _hwa__EnumerateAssetTypes *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__hwa__EnumerateAssetTypes)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_hwa__EnumerateAssetTypes(struct soap *soap, _hwa__EnumerateAssetTypes *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_hwa__EnumerateAssetTypes); + if (soap_out_PointerTo_hwa__EnumerateAssetTypes(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_hwa__EnumerateAssetTypes(struct soap *soap, const char *tag, int id, _hwa__EnumerateAssetTypes *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__hwa__EnumerateAssetTypes); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypes ** SOAP_FMAC4 soap_get_PointerTo_hwa__EnumerateAssetTypes(struct soap *soap, _hwa__EnumerateAssetTypes **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_hwa__EnumerateAssetTypes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _hwa__EnumerateAssetTypes ** SOAP_FMAC4 soap_in_PointerTo_hwa__EnumerateAssetTypes(struct soap *soap, const char *tag, _hwa__EnumerateAssetTypes **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_hwa__EnumerateAssetTypes **)soap_malloc(soap, sizeof(_hwa__EnumerateAssetTypes *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_hwa__EnumerateAssetTypes *)soap_instantiate__hwa__EnumerateAssetTypes(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_hwa__EnumerateAssetTypes **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__hwa__EnumerateAssetTypes, sizeof(_hwa__EnumerateAssetTypes), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, _emi__GetGeneralAlertSubscriptionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, _emi__GetGeneralAlertSubscriptionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscriptionResponse); + if (soap_out_PointerTo_emi__GetGeneralAlertSubscriptionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, const char *tag, int id, _emi__GetGeneralAlertSubscriptionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, _emi__GetGeneralAlertSubscriptionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetGeneralAlertSubscriptionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscriptionResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetGeneralAlertSubscriptionResponse(struct soap *soap, const char *tag, _emi__GetGeneralAlertSubscriptionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetGeneralAlertSubscriptionResponse **)soap_malloc(soap, sizeof(_emi__GetGeneralAlertSubscriptionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetGeneralAlertSubscriptionResponse *)soap_instantiate__emi__GetGeneralAlertSubscriptionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetGeneralAlertSubscriptionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetGeneralAlertSubscriptionResponse, sizeof(_emi__GetGeneralAlertSubscriptionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetGeneralAlertSubscription(struct soap *soap, _emi__GetGeneralAlertSubscription *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetGeneralAlertSubscription)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetGeneralAlertSubscription(struct soap *soap, _emi__GetGeneralAlertSubscription *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetGeneralAlertSubscription); + if (soap_out_PointerTo_emi__GetGeneralAlertSubscription(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetGeneralAlertSubscription(struct soap *soap, const char *tag, int id, _emi__GetGeneralAlertSubscription *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetGeneralAlertSubscription); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscription ** SOAP_FMAC4 soap_get_PointerTo_emi__GetGeneralAlertSubscription(struct soap *soap, _emi__GetGeneralAlertSubscription **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetGeneralAlertSubscription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetGeneralAlertSubscription ** SOAP_FMAC4 soap_in_PointerTo_emi__GetGeneralAlertSubscription(struct soap *soap, const char *tag, _emi__GetGeneralAlertSubscription **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetGeneralAlertSubscription **)soap_malloc(soap, sizeof(_emi__GetGeneralAlertSubscription *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetGeneralAlertSubscription *)soap_instantiate__emi__GetGeneralAlertSubscription(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetGeneralAlertSubscription **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetGeneralAlertSubscription, sizeof(_emi__GetGeneralAlertSubscription), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse); + if (soap_out_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, const char *tag, int id, _emi__EnumerateGeneralAlertSubscriptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateGeneralAlertSubscriptionsResponse(struct soap *soap, const char *tag, _emi__EnumerateGeneralAlertSubscriptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateGeneralAlertSubscriptionsResponse **)soap_malloc(soap, sizeof(_emi__EnumerateGeneralAlertSubscriptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateGeneralAlertSubscriptionsResponse *)soap_instantiate__emi__EnumerateGeneralAlertSubscriptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateGeneralAlertSubscriptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptionsResponse, sizeof(_emi__EnumerateGeneralAlertSubscriptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateGeneralAlertSubscriptions); + if (soap_out_PointerTo_emi__EnumerateGeneralAlertSubscriptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const char *tag, int id, _emi__EnumerateGeneralAlertSubscriptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, _emi__EnumerateGeneralAlertSubscriptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateGeneralAlertSubscriptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateGeneralAlertSubscriptions ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const char *tag, _emi__EnumerateGeneralAlertSubscriptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateGeneralAlertSubscriptions **)soap_malloc(soap, sizeof(_emi__EnumerateGeneralAlertSubscriptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateGeneralAlertSubscriptions *)soap_instantiate__emi__EnumerateGeneralAlertSubscriptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateGeneralAlertSubscriptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateGeneralAlertSubscriptions, sizeof(_emi__EnumerateGeneralAlertSubscriptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap *soap, _emi__SubscribeForGeneralAlertResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__SubscribeForGeneralAlertResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap *soap, _emi__SubscribeForGeneralAlertResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlertResponse); + if (soap_out_PointerTo_emi__SubscribeForGeneralAlertResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap *soap, const char *tag, int id, _emi__SubscribeForGeneralAlertResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__SubscribeForGeneralAlertResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap *soap, _emi__SubscribeForGeneralAlertResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__SubscribeForGeneralAlertResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlertResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__SubscribeForGeneralAlertResponse(struct soap *soap, const char *tag, _emi__SubscribeForGeneralAlertResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__SubscribeForGeneralAlertResponse **)soap_malloc(soap, sizeof(_emi__SubscribeForGeneralAlertResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__SubscribeForGeneralAlertResponse *)soap_instantiate__emi__SubscribeForGeneralAlertResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__SubscribeForGeneralAlertResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__SubscribeForGeneralAlertResponse, sizeof(_emi__SubscribeForGeneralAlertResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SubscribeForGeneralAlert(struct soap *soap, _emi__SubscribeForGeneralAlert *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__SubscribeForGeneralAlert)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SubscribeForGeneralAlert(struct soap *soap, _emi__SubscribeForGeneralAlert *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__SubscribeForGeneralAlert); + if (soap_out_PointerTo_emi__SubscribeForGeneralAlert(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SubscribeForGeneralAlert(struct soap *soap, const char *tag, int id, _emi__SubscribeForGeneralAlert *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__SubscribeForGeneralAlert); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlert ** SOAP_FMAC4 soap_get_PointerTo_emi__SubscribeForGeneralAlert(struct soap *soap, _emi__SubscribeForGeneralAlert **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__SubscribeForGeneralAlert(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__SubscribeForGeneralAlert ** SOAP_FMAC4 soap_in_PointerTo_emi__SubscribeForGeneralAlert(struct soap *soap, const char *tag, _emi__SubscribeForGeneralAlert **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__SubscribeForGeneralAlert **)soap_malloc(soap, sizeof(_emi__SubscribeForGeneralAlert *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__SubscribeForGeneralAlert *)soap_instantiate__emi__SubscribeForGeneralAlert(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__SubscribeForGeneralAlert **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__SubscribeForGeneralAlert, sizeof(_emi__SubscribeForGeneralAlert), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetSensorAttributesResponse(struct soap *soap, _emi__GetSensorAttributesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetSensorAttributesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetSensorAttributesResponse(struct soap *soap, _emi__GetSensorAttributesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetSensorAttributesResponse); + if (soap_out_PointerTo_emi__GetSensorAttributesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetSensorAttributesResponse(struct soap *soap, const char *tag, int id, _emi__GetSensorAttributesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetSensorAttributesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetSensorAttributesResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetSensorAttributesResponse(struct soap *soap, _emi__GetSensorAttributesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetSensorAttributesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetSensorAttributesResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetSensorAttributesResponse(struct soap *soap, const char *tag, _emi__GetSensorAttributesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetSensorAttributesResponse **)soap_malloc(soap, sizeof(_emi__GetSensorAttributesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetSensorAttributesResponse *)soap_instantiate__emi__GetSensorAttributesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetSensorAttributesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetSensorAttributesResponse, sizeof(_emi__GetSensorAttributesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetSensorAttributes(struct soap *soap, _emi__GetSensorAttributes *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetSensorAttributes)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetSensorAttributes(struct soap *soap, _emi__GetSensorAttributes *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetSensorAttributes); + if (soap_out_PointerTo_emi__GetSensorAttributes(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetSensorAttributes(struct soap *soap, const char *tag, int id, _emi__GetSensorAttributes *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetSensorAttributes); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetSensorAttributes ** SOAP_FMAC4 soap_get_PointerTo_emi__GetSensorAttributes(struct soap *soap, _emi__GetSensorAttributes **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetSensorAttributes(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetSensorAttributes ** SOAP_FMAC4 soap_in_PointerTo_emi__GetSensorAttributes(struct soap *soap, const char *tag, _emi__GetSensorAttributes **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetSensorAttributes **)soap_malloc(soap, sizeof(_emi__GetSensorAttributes *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetSensorAttributes *)soap_instantiate__emi__GetSensorAttributes(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetSensorAttributes **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetSensorAttributes, sizeof(_emi__GetSensorAttributes), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateSensorsResponse(struct soap *soap, _emi__EnumerateSensorsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateSensorsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateSensorsResponse(struct soap *soap, _emi__EnumerateSensorsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateSensorsResponse); + if (soap_out_PointerTo_emi__EnumerateSensorsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateSensorsResponse(struct soap *soap, const char *tag, int id, _emi__EnumerateSensorsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateSensorsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateSensorsResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateSensorsResponse(struct soap *soap, _emi__EnumerateSensorsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateSensorsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateSensorsResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateSensorsResponse(struct soap *soap, const char *tag, _emi__EnumerateSensorsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateSensorsResponse **)soap_malloc(soap, sizeof(_emi__EnumerateSensorsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateSensorsResponse *)soap_instantiate__emi__EnumerateSensorsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateSensorsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateSensorsResponse, sizeof(_emi__EnumerateSensorsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateSensors(struct soap *soap, _emi__EnumerateSensors *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateSensors)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateSensors(struct soap *soap, _emi__EnumerateSensors *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateSensors); + if (soap_out_PointerTo_emi__EnumerateSensors(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateSensors(struct soap *soap, const char *tag, int id, _emi__EnumerateSensors *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateSensors); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateSensors ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateSensors(struct soap *soap, _emi__EnumerateSensors **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateSensors(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateSensors ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateSensors(struct soap *soap, const char *tag, _emi__EnumerateSensors **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateSensors **)soap_malloc(soap, sizeof(_emi__EnumerateSensors *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateSensors *)soap_instantiate__emi__EnumerateSensors(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateSensors **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateSensors, sizeof(_emi__EnumerateSensors), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap *soap, _emi__GetEventLogTimestampClockResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetEventLogTimestampClockResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap *soap, _emi__GetEventLogTimestampClockResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClockResponse); + if (soap_out_PointerTo_emi__GetEventLogTimestampClockResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap *soap, const char *tag, int id, _emi__GetEventLogTimestampClockResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetEventLogTimestampClockResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap *soap, _emi__GetEventLogTimestampClockResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetEventLogTimestampClockResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClockResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventLogTimestampClockResponse(struct soap *soap, const char *tag, _emi__GetEventLogTimestampClockResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetEventLogTimestampClockResponse **)soap_malloc(soap, sizeof(_emi__GetEventLogTimestampClockResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetEventLogTimestampClockResponse *)soap_instantiate__emi__GetEventLogTimestampClockResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetEventLogTimestampClockResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetEventLogTimestampClockResponse, sizeof(_emi__GetEventLogTimestampClockResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventLogTimestampClock(struct soap *soap, _emi__GetEventLogTimestampClock *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetEventLogTimestampClock)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventLogTimestampClock(struct soap *soap, _emi__GetEventLogTimestampClock *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetEventLogTimestampClock); + if (soap_out_PointerTo_emi__GetEventLogTimestampClock(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventLogTimestampClock(struct soap *soap, const char *tag, int id, _emi__GetEventLogTimestampClock *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetEventLogTimestampClock); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClock ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventLogTimestampClock(struct soap *soap, _emi__GetEventLogTimestampClock **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetEventLogTimestampClock(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetEventLogTimestampClock ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventLogTimestampClock(struct soap *soap, const char *tag, _emi__GetEventLogTimestampClock **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetEventLogTimestampClock **)soap_malloc(soap, sizeof(_emi__GetEventLogTimestampClock *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetEventLogTimestampClock *)soap_instantiate__emi__GetEventLogTimestampClock(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetEventLogTimestampClock **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetEventLogTimestampClock, sizeof(_emi__GetEventLogTimestampClock), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap *soap, _emi__SetEventLogTimestampClockResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__SetEventLogTimestampClockResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap *soap, _emi__SetEventLogTimestampClockResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClockResponse); + if (soap_out_PointerTo_emi__SetEventLogTimestampClockResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap *soap, const char *tag, int id, _emi__SetEventLogTimestampClockResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__SetEventLogTimestampClockResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap *soap, _emi__SetEventLogTimestampClockResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__SetEventLogTimestampClockResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClockResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__SetEventLogTimestampClockResponse(struct soap *soap, const char *tag, _emi__SetEventLogTimestampClockResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__SetEventLogTimestampClockResponse **)soap_malloc(soap, sizeof(_emi__SetEventLogTimestampClockResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__SetEventLogTimestampClockResponse *)soap_instantiate__emi__SetEventLogTimestampClockResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__SetEventLogTimestampClockResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__SetEventLogTimestampClockResponse, sizeof(_emi__SetEventLogTimestampClockResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SetEventLogTimestampClock(struct soap *soap, _emi__SetEventLogTimestampClock *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__SetEventLogTimestampClock)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SetEventLogTimestampClock(struct soap *soap, _emi__SetEventLogTimestampClock *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__SetEventLogTimestampClock); + if (soap_out_PointerTo_emi__SetEventLogTimestampClock(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SetEventLogTimestampClock(struct soap *soap, const char *tag, int id, _emi__SetEventLogTimestampClock *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__SetEventLogTimestampClock); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClock ** SOAP_FMAC4 soap_get_PointerTo_emi__SetEventLogTimestampClock(struct soap *soap, _emi__SetEventLogTimestampClock **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__SetEventLogTimestampClock(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__SetEventLogTimestampClock ** SOAP_FMAC4 soap_in_PointerTo_emi__SetEventLogTimestampClock(struct soap *soap, const char *tag, _emi__SetEventLogTimestampClock **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__SetEventLogTimestampClock **)soap_malloc(soap, sizeof(_emi__SetEventLogTimestampClock *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__SetEventLogTimestampClock *)soap_instantiate__emi__SetEventLogTimestampClock(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__SetEventLogTimestampClock **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__SetEventLogTimestampClock, sizeof(_emi__SetEventLogTimestampClock), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__FreezeEventLogResponse(struct soap *soap, _emi__FreezeEventLogResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__FreezeEventLogResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__FreezeEventLogResponse(struct soap *soap, _emi__FreezeEventLogResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__FreezeEventLogResponse); + if (soap_out_PointerTo_emi__FreezeEventLogResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__FreezeEventLogResponse(struct soap *soap, const char *tag, int id, _emi__FreezeEventLogResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__FreezeEventLogResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__FreezeEventLogResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__FreezeEventLogResponse(struct soap *soap, _emi__FreezeEventLogResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__FreezeEventLogResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__FreezeEventLogResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__FreezeEventLogResponse(struct soap *soap, const char *tag, _emi__FreezeEventLogResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__FreezeEventLogResponse **)soap_malloc(soap, sizeof(_emi__FreezeEventLogResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__FreezeEventLogResponse *)soap_instantiate__emi__FreezeEventLogResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__FreezeEventLogResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__FreezeEventLogResponse, sizeof(_emi__FreezeEventLogResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__FreezeEventLog(struct soap *soap, _emi__FreezeEventLog *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__FreezeEventLog)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__FreezeEventLog(struct soap *soap, _emi__FreezeEventLog *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__FreezeEventLog); + if (soap_out_PointerTo_emi__FreezeEventLog(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__FreezeEventLog(struct soap *soap, const char *tag, int id, _emi__FreezeEventLog *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__FreezeEventLog); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__FreezeEventLog ** SOAP_FMAC4 soap_get_PointerTo_emi__FreezeEventLog(struct soap *soap, _emi__FreezeEventLog **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__FreezeEventLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__FreezeEventLog ** SOAP_FMAC4 soap_in_PointerTo_emi__FreezeEventLog(struct soap *soap, const char *tag, _emi__FreezeEventLog **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__FreezeEventLog **)soap_malloc(soap, sizeof(_emi__FreezeEventLog *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__FreezeEventLog *)soap_instantiate__emi__FreezeEventLog(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__FreezeEventLog **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__FreezeEventLog, sizeof(_emi__FreezeEventLog), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__ClearEventLogResponse(struct soap *soap, _emi__ClearEventLogResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__ClearEventLogResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__ClearEventLogResponse(struct soap *soap, _emi__ClearEventLogResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__ClearEventLogResponse); + if (soap_out_PointerTo_emi__ClearEventLogResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__ClearEventLogResponse(struct soap *soap, const char *tag, int id, _emi__ClearEventLogResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__ClearEventLogResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__ClearEventLogResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__ClearEventLogResponse(struct soap *soap, _emi__ClearEventLogResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__ClearEventLogResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__ClearEventLogResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__ClearEventLogResponse(struct soap *soap, const char *tag, _emi__ClearEventLogResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__ClearEventLogResponse **)soap_malloc(soap, sizeof(_emi__ClearEventLogResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__ClearEventLogResponse *)soap_instantiate__emi__ClearEventLogResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__ClearEventLogResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__ClearEventLogResponse, sizeof(_emi__ClearEventLogResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__ClearEventLog(struct soap *soap, _emi__ClearEventLog *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__ClearEventLog)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__ClearEventLog(struct soap *soap, _emi__ClearEventLog *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__ClearEventLog); + if (soap_out_PointerTo_emi__ClearEventLog(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__ClearEventLog(struct soap *soap, const char *tag, int id, _emi__ClearEventLog *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__ClearEventLog); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__ClearEventLog ** SOAP_FMAC4 soap_get_PointerTo_emi__ClearEventLog(struct soap *soap, _emi__ClearEventLog **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__ClearEventLog(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__ClearEventLog ** SOAP_FMAC4 soap_in_PointerTo_emi__ClearEventLog(struct soap *soap, const char *tag, _emi__ClearEventLog **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__ClearEventLog **)soap_malloc(soap, sizeof(_emi__ClearEventLog *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__ClearEventLog *)soap_instantiate__emi__ClearEventLog(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__ClearEventLog **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__ClearEventLog, sizeof(_emi__ClearEventLog), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__ReadEventLogRecordsResponse(struct soap *soap, _emi__ReadEventLogRecordsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__ReadEventLogRecordsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__ReadEventLogRecordsResponse(struct soap *soap, _emi__ReadEventLogRecordsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__ReadEventLogRecordsResponse); + if (soap_out_PointerTo_emi__ReadEventLogRecordsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__ReadEventLogRecordsResponse(struct soap *soap, const char *tag, int id, _emi__ReadEventLogRecordsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__ReadEventLogRecordsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__ReadEventLogRecordsResponse(struct soap *soap, _emi__ReadEventLogRecordsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__ReadEventLogRecordsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__ReadEventLogRecordsResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__ReadEventLogRecordsResponse(struct soap *soap, const char *tag, _emi__ReadEventLogRecordsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__ReadEventLogRecordsResponse **)soap_malloc(soap, sizeof(_emi__ReadEventLogRecordsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__ReadEventLogRecordsResponse *)soap_instantiate__emi__ReadEventLogRecordsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__ReadEventLogRecordsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__ReadEventLogRecordsResponse, sizeof(_emi__ReadEventLogRecordsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__ReadEventLogRecords(struct soap *soap, _emi__ReadEventLogRecords *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__ReadEventLogRecords)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__ReadEventLogRecords(struct soap *soap, _emi__ReadEventLogRecords *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__ReadEventLogRecords); + if (soap_out_PointerTo_emi__ReadEventLogRecords(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__ReadEventLogRecords(struct soap *soap, const char *tag, int id, _emi__ReadEventLogRecords *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__ReadEventLogRecords); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__ReadEventLogRecords ** SOAP_FMAC4 soap_get_PointerTo_emi__ReadEventLogRecords(struct soap *soap, _emi__ReadEventLogRecords **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__ReadEventLogRecords(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__ReadEventLogRecords ** SOAP_FMAC4 soap_in_PointerTo_emi__ReadEventLogRecords(struct soap *soap, const char *tag, _emi__ReadEventLogRecords **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__ReadEventLogRecords **)soap_malloc(soap, sizeof(_emi__ReadEventLogRecords *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__ReadEventLogRecords *)soap_instantiate__emi__ReadEventLogRecords(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__ReadEventLogRecords **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__ReadEventLogRecords, sizeof(_emi__ReadEventLogRecords), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventLogStatusResponse(struct soap *soap, _emi__GetEventLogStatusResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetEventLogStatusResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventLogStatusResponse(struct soap *soap, _emi__GetEventLogStatusResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetEventLogStatusResponse); + if (soap_out_PointerTo_emi__GetEventLogStatusResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventLogStatusResponse(struct soap *soap, const char *tag, int id, _emi__GetEventLogStatusResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetEventLogStatusResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetEventLogStatusResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventLogStatusResponse(struct soap *soap, _emi__GetEventLogStatusResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetEventLogStatusResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetEventLogStatusResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventLogStatusResponse(struct soap *soap, const char *tag, _emi__GetEventLogStatusResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetEventLogStatusResponse **)soap_malloc(soap, sizeof(_emi__GetEventLogStatusResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetEventLogStatusResponse *)soap_instantiate__emi__GetEventLogStatusResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetEventLogStatusResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetEventLogStatusResponse, sizeof(_emi__GetEventLogStatusResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventLogStatus(struct soap *soap, _emi__GetEventLogStatus *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetEventLogStatus)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventLogStatus(struct soap *soap, _emi__GetEventLogStatus *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetEventLogStatus); + if (soap_out_PointerTo_emi__GetEventLogStatus(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventLogStatus(struct soap *soap, const char *tag, int id, _emi__GetEventLogStatus *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetEventLogStatus); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetEventLogStatus ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventLogStatus(struct soap *soap, _emi__GetEventLogStatus **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetEventLogStatus(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetEventLogStatus ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventLogStatus(struct soap *soap, const char *tag, _emi__GetEventLogStatus **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetEventLogStatus **)soap_malloc(soap, sizeof(_emi__GetEventLogStatus *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetEventLogStatus *)soap_instantiate__emi__GetEventLogStatus(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetEventLogStatus **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetEventLogStatus, sizeof(_emi__GetEventLogStatus), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__RemoveEventFilterResponse(struct soap *soap, _emi__RemoveEventFilterResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__RemoveEventFilterResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__RemoveEventFilterResponse(struct soap *soap, _emi__RemoveEventFilterResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__RemoveEventFilterResponse); + if (soap_out_PointerTo_emi__RemoveEventFilterResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__RemoveEventFilterResponse(struct soap *soap, const char *tag, int id, _emi__RemoveEventFilterResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__RemoveEventFilterResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__RemoveEventFilterResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__RemoveEventFilterResponse(struct soap *soap, _emi__RemoveEventFilterResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__RemoveEventFilterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__RemoveEventFilterResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__RemoveEventFilterResponse(struct soap *soap, const char *tag, _emi__RemoveEventFilterResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__RemoveEventFilterResponse **)soap_malloc(soap, sizeof(_emi__RemoveEventFilterResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__RemoveEventFilterResponse *)soap_instantiate__emi__RemoveEventFilterResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__RemoveEventFilterResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__RemoveEventFilterResponse, sizeof(_emi__RemoveEventFilterResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__RemoveEventFilter(struct soap *soap, _emi__RemoveEventFilter *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__RemoveEventFilter)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__RemoveEventFilter(struct soap *soap, _emi__RemoveEventFilter *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__RemoveEventFilter); + if (soap_out_PointerTo_emi__RemoveEventFilter(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__RemoveEventFilter(struct soap *soap, const char *tag, int id, _emi__RemoveEventFilter *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__RemoveEventFilter); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__RemoveEventFilter ** SOAP_FMAC4 soap_get_PointerTo_emi__RemoveEventFilter(struct soap *soap, _emi__RemoveEventFilter **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__RemoveEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__RemoveEventFilter ** SOAP_FMAC4 soap_in_PointerTo_emi__RemoveEventFilter(struct soap *soap, const char *tag, _emi__RemoveEventFilter **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__RemoveEventFilter **)soap_malloc(soap, sizeof(_emi__RemoveEventFilter *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__RemoveEventFilter *)soap_instantiate__emi__RemoveEventFilter(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__RemoveEventFilter **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__RemoveEventFilter, sizeof(_emi__RemoveEventFilter), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__UpdateEventFilterResponse(struct soap *soap, _emi__UpdateEventFilterResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__UpdateEventFilterResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__UpdateEventFilterResponse(struct soap *soap, _emi__UpdateEventFilterResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__UpdateEventFilterResponse); + if (soap_out_PointerTo_emi__UpdateEventFilterResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__UpdateEventFilterResponse(struct soap *soap, const char *tag, int id, _emi__UpdateEventFilterResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__UpdateEventFilterResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__UpdateEventFilterResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__UpdateEventFilterResponse(struct soap *soap, _emi__UpdateEventFilterResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__UpdateEventFilterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__UpdateEventFilterResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__UpdateEventFilterResponse(struct soap *soap, const char *tag, _emi__UpdateEventFilterResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__UpdateEventFilterResponse **)soap_malloc(soap, sizeof(_emi__UpdateEventFilterResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__UpdateEventFilterResponse *)soap_instantiate__emi__UpdateEventFilterResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__UpdateEventFilterResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__UpdateEventFilterResponse, sizeof(_emi__UpdateEventFilterResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__UpdateEventFilter(struct soap *soap, _emi__UpdateEventFilter *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__UpdateEventFilter)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__UpdateEventFilter(struct soap *soap, _emi__UpdateEventFilter *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__UpdateEventFilter); + if (soap_out_PointerTo_emi__UpdateEventFilter(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__UpdateEventFilter(struct soap *soap, const char *tag, int id, _emi__UpdateEventFilter *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__UpdateEventFilter); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__UpdateEventFilter ** SOAP_FMAC4 soap_get_PointerTo_emi__UpdateEventFilter(struct soap *soap, _emi__UpdateEventFilter **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__UpdateEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__UpdateEventFilter ** SOAP_FMAC4 soap_in_PointerTo_emi__UpdateEventFilter(struct soap *soap, const char *tag, _emi__UpdateEventFilter **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__UpdateEventFilter **)soap_malloc(soap, sizeof(_emi__UpdateEventFilter *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__UpdateEventFilter *)soap_instantiate__emi__UpdateEventFilter(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__UpdateEventFilter **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__UpdateEventFilter, sizeof(_emi__UpdateEventFilter), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventFilterResponse(struct soap *soap, _emi__GetEventFilterResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetEventFilterResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventFilterResponse(struct soap *soap, _emi__GetEventFilterResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetEventFilterResponse); + if (soap_out_PointerTo_emi__GetEventFilterResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventFilterResponse(struct soap *soap, const char *tag, int id, _emi__GetEventFilterResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetEventFilterResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetEventFilterResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventFilterResponse(struct soap *soap, _emi__GetEventFilterResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetEventFilterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetEventFilterResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventFilterResponse(struct soap *soap, const char *tag, _emi__GetEventFilterResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetEventFilterResponse **)soap_malloc(soap, sizeof(_emi__GetEventFilterResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetEventFilterResponse *)soap_instantiate__emi__GetEventFilterResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetEventFilterResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetEventFilterResponse, sizeof(_emi__GetEventFilterResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetEventFilter(struct soap *soap, _emi__GetEventFilter *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetEventFilter)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetEventFilter(struct soap *soap, _emi__GetEventFilter *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetEventFilter); + if (soap_out_PointerTo_emi__GetEventFilter(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetEventFilter(struct soap *soap, const char *tag, int id, _emi__GetEventFilter *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetEventFilter); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetEventFilter ** SOAP_FMAC4 soap_get_PointerTo_emi__GetEventFilter(struct soap *soap, _emi__GetEventFilter **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetEventFilter ** SOAP_FMAC4 soap_in_PointerTo_emi__GetEventFilter(struct soap *soap, const char *tag, _emi__GetEventFilter **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetEventFilter **)soap_malloc(soap, sizeof(_emi__GetEventFilter *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetEventFilter *)soap_instantiate__emi__GetEventFilter(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetEventFilter **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetEventFilter, sizeof(_emi__GetEventFilter), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap *soap, _emi__CancelAlertSubscriptionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__CancelAlertSubscriptionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap *soap, _emi__CancelAlertSubscriptionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__CancelAlertSubscriptionResponse); + if (soap_out_PointerTo_emi__CancelAlertSubscriptionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap *soap, const char *tag, int id, _emi__CancelAlertSubscriptionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__CancelAlertSubscriptionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap *soap, _emi__CancelAlertSubscriptionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__CancelAlertSubscriptionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__CancelAlertSubscriptionResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__CancelAlertSubscriptionResponse(struct soap *soap, const char *tag, _emi__CancelAlertSubscriptionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__CancelAlertSubscriptionResponse **)soap_malloc(soap, sizeof(_emi__CancelAlertSubscriptionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__CancelAlertSubscriptionResponse *)soap_instantiate__emi__CancelAlertSubscriptionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__CancelAlertSubscriptionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__CancelAlertSubscriptionResponse, sizeof(_emi__CancelAlertSubscriptionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__CancelAlertSubscription(struct soap *soap, _emi__CancelAlertSubscription *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__CancelAlertSubscription)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__CancelAlertSubscription(struct soap *soap, _emi__CancelAlertSubscription *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__CancelAlertSubscription); + if (soap_out_PointerTo_emi__CancelAlertSubscription(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__CancelAlertSubscription(struct soap *soap, const char *tag, int id, _emi__CancelAlertSubscription *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__CancelAlertSubscription); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__CancelAlertSubscription ** SOAP_FMAC4 soap_get_PointerTo_emi__CancelAlertSubscription(struct soap *soap, _emi__CancelAlertSubscription **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__CancelAlertSubscription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__CancelAlertSubscription ** SOAP_FMAC4 soap_in_PointerTo_emi__CancelAlertSubscription(struct soap *soap, const char *tag, _emi__CancelAlertSubscription **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__CancelAlertSubscription **)soap_malloc(soap, sizeof(_emi__CancelAlertSubscription *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__CancelAlertSubscription *)soap_instantiate__emi__CancelAlertSubscription(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__CancelAlertSubscription **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__CancelAlertSubscription, sizeof(_emi__CancelAlertSubscription), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap *soap, _emi__EnumerateAlertPoliciesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateAlertPoliciesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap *soap, _emi__EnumerateAlertPoliciesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateAlertPoliciesResponse); + if (soap_out_PointerTo_emi__EnumerateAlertPoliciesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap *soap, const char *tag, int id, _emi__EnumerateAlertPoliciesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateAlertPoliciesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap *soap, _emi__EnumerateAlertPoliciesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateAlertPoliciesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateAlertPoliciesResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateAlertPoliciesResponse(struct soap *soap, const char *tag, _emi__EnumerateAlertPoliciesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateAlertPoliciesResponse **)soap_malloc(soap, sizeof(_emi__EnumerateAlertPoliciesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateAlertPoliciesResponse *)soap_instantiate__emi__EnumerateAlertPoliciesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateAlertPoliciesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateAlertPoliciesResponse, sizeof(_emi__EnumerateAlertPoliciesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateAlertPolicies(struct soap *soap, _emi__EnumerateAlertPolicies *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateAlertPolicies)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateAlertPolicies(struct soap *soap, _emi__EnumerateAlertPolicies *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateAlertPolicies); + if (soap_out_PointerTo_emi__EnumerateAlertPolicies(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateAlertPolicies(struct soap *soap, const char *tag, int id, _emi__EnumerateAlertPolicies *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateAlertPolicies); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertPolicies ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateAlertPolicies(struct soap *soap, _emi__EnumerateAlertPolicies **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateAlertPolicies(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateAlertPolicies ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateAlertPolicies(struct soap *soap, const char *tag, _emi__EnumerateAlertPolicies **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateAlertPolicies **)soap_malloc(soap, sizeof(_emi__EnumerateAlertPolicies *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateAlertPolicies *)soap_instantiate__emi__EnumerateAlertPolicies(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateAlertPolicies **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateAlertPolicies, sizeof(_emi__EnumerateAlertPolicies), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateAlertSubscriptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateAlertSubscriptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptionsResponse); + if (soap_out_PointerTo_emi__EnumerateAlertSubscriptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, const char *tag, int id, _emi__EnumerateAlertSubscriptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, _emi__EnumerateAlertSubscriptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateAlertSubscriptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateAlertSubscriptionsResponse(struct soap *soap, const char *tag, _emi__EnumerateAlertSubscriptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateAlertSubscriptionsResponse **)soap_malloc(soap, sizeof(_emi__EnumerateAlertSubscriptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateAlertSubscriptionsResponse *)soap_instantiate__emi__EnumerateAlertSubscriptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateAlertSubscriptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateAlertSubscriptionsResponse, sizeof(_emi__EnumerateAlertSubscriptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateAlertSubscriptions(struct soap *soap, _emi__EnumerateAlertSubscriptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateAlertSubscriptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateAlertSubscriptions(struct soap *soap, _emi__EnumerateAlertSubscriptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateAlertSubscriptions); + if (soap_out_PointerTo_emi__EnumerateAlertSubscriptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateAlertSubscriptions(struct soap *soap, const char *tag, int id, _emi__EnumerateAlertSubscriptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateAlertSubscriptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateAlertSubscriptions(struct soap *soap, _emi__EnumerateAlertSubscriptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateAlertSubscriptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateAlertSubscriptions ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateAlertSubscriptions(struct soap *soap, const char *tag, _emi__EnumerateAlertSubscriptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateAlertSubscriptions **)soap_malloc(soap, sizeof(_emi__EnumerateAlertSubscriptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateAlertSubscriptions *)soap_instantiate__emi__EnumerateAlertSubscriptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateAlertSubscriptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateAlertSubscriptions, sizeof(_emi__EnumerateAlertSubscriptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SubscribeForAlertResponse(struct soap *soap, _emi__SubscribeForAlertResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__SubscribeForAlertResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SubscribeForAlertResponse(struct soap *soap, _emi__SubscribeForAlertResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__SubscribeForAlertResponse); + if (soap_out_PointerTo_emi__SubscribeForAlertResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SubscribeForAlertResponse(struct soap *soap, const char *tag, int id, _emi__SubscribeForAlertResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__SubscribeForAlertResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__SubscribeForAlertResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__SubscribeForAlertResponse(struct soap *soap, _emi__SubscribeForAlertResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__SubscribeForAlertResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__SubscribeForAlertResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__SubscribeForAlertResponse(struct soap *soap, const char *tag, _emi__SubscribeForAlertResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__SubscribeForAlertResponse **)soap_malloc(soap, sizeof(_emi__SubscribeForAlertResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__SubscribeForAlertResponse *)soap_instantiate__emi__SubscribeForAlertResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__SubscribeForAlertResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__SubscribeForAlertResponse, sizeof(_emi__SubscribeForAlertResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SubscribeForAlert(struct soap *soap, _emi__SubscribeForAlert *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__SubscribeForAlert)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SubscribeForAlert(struct soap *soap, _emi__SubscribeForAlert *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__SubscribeForAlert); + if (soap_out_PointerTo_emi__SubscribeForAlert(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SubscribeForAlert(struct soap *soap, const char *tag, int id, _emi__SubscribeForAlert *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__SubscribeForAlert); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__SubscribeForAlert ** SOAP_FMAC4 soap_get_PointerTo_emi__SubscribeForAlert(struct soap *soap, _emi__SubscribeForAlert **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__SubscribeForAlert(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__SubscribeForAlert ** SOAP_FMAC4 soap_in_PointerTo_emi__SubscribeForAlert(struct soap *soap, const char *tag, _emi__SubscribeForAlert **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__SubscribeForAlert **)soap_malloc(soap, sizeof(_emi__SubscribeForAlert *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__SubscribeForAlert *)soap_instantiate__emi__SubscribeForAlert(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__SubscribeForAlert **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__SubscribeForAlert, sizeof(_emi__SubscribeForAlert), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__AddEventFilterResponse(struct soap *soap, _emi__AddEventFilterResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__AddEventFilterResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__AddEventFilterResponse(struct soap *soap, _emi__AddEventFilterResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__AddEventFilterResponse); + if (soap_out_PointerTo_emi__AddEventFilterResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__AddEventFilterResponse(struct soap *soap, const char *tag, int id, _emi__AddEventFilterResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__AddEventFilterResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__AddEventFilterResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__AddEventFilterResponse(struct soap *soap, _emi__AddEventFilterResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__AddEventFilterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__AddEventFilterResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__AddEventFilterResponse(struct soap *soap, const char *tag, _emi__AddEventFilterResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__AddEventFilterResponse **)soap_malloc(soap, sizeof(_emi__AddEventFilterResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__AddEventFilterResponse *)soap_instantiate__emi__AddEventFilterResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__AddEventFilterResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__AddEventFilterResponse, sizeof(_emi__AddEventFilterResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__AddEventFilter(struct soap *soap, _emi__AddEventFilter *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__AddEventFilter)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__AddEventFilter(struct soap *soap, _emi__AddEventFilter *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__AddEventFilter); + if (soap_out_PointerTo_emi__AddEventFilter(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__AddEventFilter(struct soap *soap, const char *tag, int id, _emi__AddEventFilter *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__AddEventFilter); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__AddEventFilter ** SOAP_FMAC4 soap_get_PointerTo_emi__AddEventFilter(struct soap *soap, _emi__AddEventFilter **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__AddEventFilter(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__AddEventFilter ** SOAP_FMAC4 soap_in_PointerTo_emi__AddEventFilter(struct soap *soap, const char *tag, _emi__AddEventFilter **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__AddEventFilter **)soap_malloc(soap, sizeof(_emi__AddEventFilter *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__AddEventFilter *)soap_instantiate__emi__AddEventFilter(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__AddEventFilter **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__AddEventFilter, sizeof(_emi__AddEventFilter), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetAlertCommunityStringResponse(struct soap *soap, _emi__GetAlertCommunityStringResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetAlertCommunityStringResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetAlertCommunityStringResponse(struct soap *soap, _emi__GetAlertCommunityStringResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetAlertCommunityStringResponse); + if (soap_out_PointerTo_emi__GetAlertCommunityStringResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetAlertCommunityStringResponse(struct soap *soap, const char *tag, int id, _emi__GetAlertCommunityStringResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetAlertCommunityStringResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetAlertCommunityStringResponse(struct soap *soap, _emi__GetAlertCommunityStringResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetAlertCommunityStringResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetAlertCommunityStringResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetAlertCommunityStringResponse(struct soap *soap, const char *tag, _emi__GetAlertCommunityStringResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetAlertCommunityStringResponse **)soap_malloc(soap, sizeof(_emi__GetAlertCommunityStringResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetAlertCommunityStringResponse *)soap_instantiate__emi__GetAlertCommunityStringResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetAlertCommunityStringResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetAlertCommunityStringResponse, sizeof(_emi__GetAlertCommunityStringResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetAlertCommunityString(struct soap *soap, _emi__GetAlertCommunityString *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetAlertCommunityString)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetAlertCommunityString(struct soap *soap, _emi__GetAlertCommunityString *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetAlertCommunityString); + if (soap_out_PointerTo_emi__GetAlertCommunityString(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetAlertCommunityString(struct soap *soap, const char *tag, int id, _emi__GetAlertCommunityString *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetAlertCommunityString); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetAlertCommunityString ** SOAP_FMAC4 soap_get_PointerTo_emi__GetAlertCommunityString(struct soap *soap, _emi__GetAlertCommunityString **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetAlertCommunityString(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetAlertCommunityString ** SOAP_FMAC4 soap_in_PointerTo_emi__GetAlertCommunityString(struct soap *soap, const char *tag, _emi__GetAlertCommunityString **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetAlertCommunityString **)soap_malloc(soap, sizeof(_emi__GetAlertCommunityString *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetAlertCommunityString *)soap_instantiate__emi__GetAlertCommunityString(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetAlertCommunityString **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetAlertCommunityString, sizeof(_emi__GetAlertCommunityString), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SetAlertCommunityStringResponse(struct soap *soap, _emi__SetAlertCommunityStringResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__SetAlertCommunityStringResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SetAlertCommunityStringResponse(struct soap *soap, _emi__SetAlertCommunityStringResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__SetAlertCommunityStringResponse); + if (soap_out_PointerTo_emi__SetAlertCommunityStringResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SetAlertCommunityStringResponse(struct soap *soap, const char *tag, int id, _emi__SetAlertCommunityStringResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__SetAlertCommunityStringResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__SetAlertCommunityStringResponse(struct soap *soap, _emi__SetAlertCommunityStringResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__SetAlertCommunityStringResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__SetAlertCommunityStringResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__SetAlertCommunityStringResponse(struct soap *soap, const char *tag, _emi__SetAlertCommunityStringResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__SetAlertCommunityStringResponse **)soap_malloc(soap, sizeof(_emi__SetAlertCommunityStringResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__SetAlertCommunityStringResponse *)soap_instantiate__emi__SetAlertCommunityStringResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__SetAlertCommunityStringResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__SetAlertCommunityStringResponse, sizeof(_emi__SetAlertCommunityStringResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__SetAlertCommunityString(struct soap *soap, _emi__SetAlertCommunityString *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__SetAlertCommunityString)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__SetAlertCommunityString(struct soap *soap, _emi__SetAlertCommunityString *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__SetAlertCommunityString); + if (soap_out_PointerTo_emi__SetAlertCommunityString(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__SetAlertCommunityString(struct soap *soap, const char *tag, int id, _emi__SetAlertCommunityString *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__SetAlertCommunityString); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__SetAlertCommunityString ** SOAP_FMAC4 soap_get_PointerTo_emi__SetAlertCommunityString(struct soap *soap, _emi__SetAlertCommunityString **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__SetAlertCommunityString(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__SetAlertCommunityString ** SOAP_FMAC4 soap_in_PointerTo_emi__SetAlertCommunityString(struct soap *soap, const char *tag, _emi__SetAlertCommunityString **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__SetAlertCommunityString **)soap_malloc(soap, sizeof(_emi__SetAlertCommunityString *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__SetAlertCommunityString *)soap_instantiate__emi__SetAlertCommunityString(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__SetAlertCommunityString **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__SetAlertCommunityString, sizeof(_emi__SetAlertCommunityString), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetAlertSubscriptionResponse(struct soap *soap, _emi__GetAlertSubscriptionResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetAlertSubscriptionResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetAlertSubscriptionResponse(struct soap *soap, _emi__GetAlertSubscriptionResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetAlertSubscriptionResponse); + if (soap_out_PointerTo_emi__GetAlertSubscriptionResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetAlertSubscriptionResponse(struct soap *soap, const char *tag, int id, _emi__GetAlertSubscriptionResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetAlertSubscriptionResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__GetAlertSubscriptionResponse(struct soap *soap, _emi__GetAlertSubscriptionResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetAlertSubscriptionResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetAlertSubscriptionResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__GetAlertSubscriptionResponse(struct soap *soap, const char *tag, _emi__GetAlertSubscriptionResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetAlertSubscriptionResponse **)soap_malloc(soap, sizeof(_emi__GetAlertSubscriptionResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetAlertSubscriptionResponse *)soap_instantiate__emi__GetAlertSubscriptionResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetAlertSubscriptionResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetAlertSubscriptionResponse, sizeof(_emi__GetAlertSubscriptionResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__GetAlertSubscription(struct soap *soap, _emi__GetAlertSubscription *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__GetAlertSubscription)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__GetAlertSubscription(struct soap *soap, _emi__GetAlertSubscription *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__GetAlertSubscription); + if (soap_out_PointerTo_emi__GetAlertSubscription(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__GetAlertSubscription(struct soap *soap, const char *tag, int id, _emi__GetAlertSubscription *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__GetAlertSubscription); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__GetAlertSubscription ** SOAP_FMAC4 soap_get_PointerTo_emi__GetAlertSubscription(struct soap *soap, _emi__GetAlertSubscription **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__GetAlertSubscription(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__GetAlertSubscription ** SOAP_FMAC4 soap_in_PointerTo_emi__GetAlertSubscription(struct soap *soap, const char *tag, _emi__GetAlertSubscription **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__GetAlertSubscription **)soap_malloc(soap, sizeof(_emi__GetAlertSubscription *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__GetAlertSubscription *)soap_instantiate__emi__GetAlertSubscription(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__GetAlertSubscription **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__GetAlertSubscription, sizeof(_emi__GetAlertSubscription), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateEventFiltersResponse(struct soap *soap, _emi__EnumerateEventFiltersResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateEventFiltersResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateEventFiltersResponse(struct soap *soap, _emi__EnumerateEventFiltersResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateEventFiltersResponse); + if (soap_out_PointerTo_emi__EnumerateEventFiltersResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateEventFiltersResponse(struct soap *soap, const char *tag, int id, _emi__EnumerateEventFiltersResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateEventFiltersResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateEventFiltersResponse(struct soap *soap, _emi__EnumerateEventFiltersResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateEventFiltersResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateEventFiltersResponse ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateEventFiltersResponse(struct soap *soap, const char *tag, _emi__EnumerateEventFiltersResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateEventFiltersResponse **)soap_malloc(soap, sizeof(_emi__EnumerateEventFiltersResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateEventFiltersResponse *)soap_instantiate__emi__EnumerateEventFiltersResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateEventFiltersResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateEventFiltersResponse, sizeof(_emi__EnumerateEventFiltersResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_emi__EnumerateEventFilters(struct soap *soap, _emi__EnumerateEventFilters *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__emi__EnumerateEventFilters)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_emi__EnumerateEventFilters(struct soap *soap, _emi__EnumerateEventFilters *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_emi__EnumerateEventFilters); + if (soap_out_PointerTo_emi__EnumerateEventFilters(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_emi__EnumerateEventFilters(struct soap *soap, const char *tag, int id, _emi__EnumerateEventFilters *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__emi__EnumerateEventFilters); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _emi__EnumerateEventFilters ** SOAP_FMAC4 soap_get_PointerTo_emi__EnumerateEventFilters(struct soap *soap, _emi__EnumerateEventFilters **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_emi__EnumerateEventFilters(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _emi__EnumerateEventFilters ** SOAP_FMAC4 soap_in_PointerTo_emi__EnumerateEventFilters(struct soap *soap, const char *tag, _emi__EnumerateEventFilters **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_emi__EnumerateEventFilters **)soap_malloc(soap, sizeof(_emi__EnumerateEventFilters *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_emi__EnumerateEventFilters *)soap_instantiate__emi__EnumerateEventFilters(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_emi__EnumerateEventFilters **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__emi__EnumerateEventFilters, sizeof(_emi__EnumerateEventFilters), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__GetHcbStateResponse(struct soap *soap, _cb__GetHcbStateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__GetHcbStateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__GetHcbStateResponse(struct soap *soap, _cb__GetHcbStateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__GetHcbStateResponse); + if (soap_out_PointerTo_cb__GetHcbStateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__GetHcbStateResponse(struct soap *soap, const char *tag, int id, _cb__GetHcbStateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__GetHcbStateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__GetHcbStateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__GetHcbStateResponse(struct soap *soap, _cb__GetHcbStateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__GetHcbStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__GetHcbStateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__GetHcbStateResponse(struct soap *soap, const char *tag, _cb__GetHcbStateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__GetHcbStateResponse **)soap_malloc(soap, sizeof(_cb__GetHcbStateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__GetHcbStateResponse *)soap_instantiate__cb__GetHcbStateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__GetHcbStateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__GetHcbStateResponse, sizeof(_cb__GetHcbStateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__GetHcbState(struct soap *soap, _cb__GetHcbState *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__GetHcbState)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__GetHcbState(struct soap *soap, _cb__GetHcbState *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__GetHcbState); + if (soap_out_PointerTo_cb__GetHcbState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__GetHcbState(struct soap *soap, const char *tag, int id, _cb__GetHcbState *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__GetHcbState); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__GetHcbState ** SOAP_FMAC4 soap_get_PointerTo_cb__GetHcbState(struct soap *soap, _cb__GetHcbState **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__GetHcbState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__GetHcbState ** SOAP_FMAC4 soap_in_PointerTo_cb__GetHcbState(struct soap *soap, const char *tag, _cb__GetHcbState **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__GetHcbState **)soap_malloc(soap, sizeof(_cb__GetHcbState *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__GetHcbState *)soap_instantiate__cb__GetHcbState(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__GetHcbState **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__GetHcbState, sizeof(_cb__GetHcbState), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__ClearHcbStateResponse(struct soap *soap, _cb__ClearHcbStateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__ClearHcbStateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__ClearHcbStateResponse(struct soap *soap, _cb__ClearHcbStateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__ClearHcbStateResponse); + if (soap_out_PointerTo_cb__ClearHcbStateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__ClearHcbStateResponse(struct soap *soap, const char *tag, int id, _cb__ClearHcbStateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__ClearHcbStateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__ClearHcbStateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__ClearHcbStateResponse(struct soap *soap, _cb__ClearHcbStateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__ClearHcbStateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__ClearHcbStateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__ClearHcbStateResponse(struct soap *soap, const char *tag, _cb__ClearHcbStateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__ClearHcbStateResponse **)soap_malloc(soap, sizeof(_cb__ClearHcbStateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__ClearHcbStateResponse *)soap_instantiate__cb__ClearHcbStateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__ClearHcbStateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__ClearHcbStateResponse, sizeof(_cb__ClearHcbStateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__ClearHcbState(struct soap *soap, _cb__ClearHcbState *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__ClearHcbState)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__ClearHcbState(struct soap *soap, _cb__ClearHcbState *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__ClearHcbState); + if (soap_out_PointerTo_cb__ClearHcbState(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__ClearHcbState(struct soap *soap, const char *tag, int id, _cb__ClearHcbState *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__ClearHcbState); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__ClearHcbState ** SOAP_FMAC4 soap_get_PointerTo_cb__ClearHcbState(struct soap *soap, _cb__ClearHcbState **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__ClearHcbState(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__ClearHcbState ** SOAP_FMAC4 soap_in_PointerTo_cb__ClearHcbState(struct soap *soap, const char *tag, _cb__ClearHcbState **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__ClearHcbState **)soap_malloc(soap, sizeof(_cb__ClearHcbState *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__ClearHcbState *)soap_instantiate__cb__ClearHcbState(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__ClearHcbState **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__ClearHcbState, sizeof(_cb__ClearHcbState), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__GetHcbOptionsResponse(struct soap *soap, _cb__GetHcbOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__GetHcbOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__GetHcbOptionsResponse(struct soap *soap, _cb__GetHcbOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__GetHcbOptionsResponse); + if (soap_out_PointerTo_cb__GetHcbOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__GetHcbOptionsResponse(struct soap *soap, const char *tag, int id, _cb__GetHcbOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__GetHcbOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__GetHcbOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__GetHcbOptionsResponse(struct soap *soap, _cb__GetHcbOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__GetHcbOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__GetHcbOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__GetHcbOptionsResponse(struct soap *soap, const char *tag, _cb__GetHcbOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__GetHcbOptionsResponse **)soap_malloc(soap, sizeof(_cb__GetHcbOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__GetHcbOptionsResponse *)soap_instantiate__cb__GetHcbOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__GetHcbOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__GetHcbOptionsResponse, sizeof(_cb__GetHcbOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__GetHcbOptions(struct soap *soap, _cb__GetHcbOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__GetHcbOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__GetHcbOptions(struct soap *soap, _cb__GetHcbOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__GetHcbOptions); + if (soap_out_PointerTo_cb__GetHcbOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__GetHcbOptions(struct soap *soap, const char *tag, int id, _cb__GetHcbOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__GetHcbOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__GetHcbOptions ** SOAP_FMAC4 soap_get_PointerTo_cb__GetHcbOptions(struct soap *soap, _cb__GetHcbOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__GetHcbOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__GetHcbOptions ** SOAP_FMAC4 soap_in_PointerTo_cb__GetHcbOptions(struct soap *soap, const char *tag, _cb__GetHcbOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__GetHcbOptions **)soap_malloc(soap, sizeof(_cb__GetHcbOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__GetHcbOptions *)soap_instantiate__cb__GetHcbOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__GetHcbOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__GetHcbOptions, sizeof(_cb__GetHcbOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__SetHcbOptionsResponse(struct soap *soap, _cb__SetHcbOptionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__SetHcbOptionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__SetHcbOptionsResponse(struct soap *soap, _cb__SetHcbOptionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__SetHcbOptionsResponse); + if (soap_out_PointerTo_cb__SetHcbOptionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__SetHcbOptionsResponse(struct soap *soap, const char *tag, int id, _cb__SetHcbOptionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__SetHcbOptionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__SetHcbOptionsResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__SetHcbOptionsResponse(struct soap *soap, _cb__SetHcbOptionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__SetHcbOptionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__SetHcbOptionsResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__SetHcbOptionsResponse(struct soap *soap, const char *tag, _cb__SetHcbOptionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__SetHcbOptionsResponse **)soap_malloc(soap, sizeof(_cb__SetHcbOptionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__SetHcbOptionsResponse *)soap_instantiate__cb__SetHcbOptionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__SetHcbOptionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__SetHcbOptionsResponse, sizeof(_cb__SetHcbOptionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__SetHcbOptions(struct soap *soap, _cb__SetHcbOptions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__SetHcbOptions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__SetHcbOptions(struct soap *soap, _cb__SetHcbOptions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__SetHcbOptions); + if (soap_out_PointerTo_cb__SetHcbOptions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__SetHcbOptions(struct soap *soap, const char *tag, int id, _cb__SetHcbOptions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__SetHcbOptions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__SetHcbOptions ** SOAP_FMAC4 soap_get_PointerTo_cb__SetHcbOptions(struct soap *soap, _cb__SetHcbOptions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__SetHcbOptions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__SetHcbOptions ** SOAP_FMAC4 soap_in_PointerTo_cb__SetHcbOptions(struct soap *soap, const char *tag, _cb__SetHcbOptions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__SetHcbOptions **)soap_malloc(soap, sizeof(_cb__SetHcbOptions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__SetHcbOptions *)soap_instantiate__cb__SetHcbOptions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__SetHcbOptions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__SetHcbOptions, sizeof(_cb__SetHcbOptions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap *soap, _cb__CbQueryCapabilitiesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbQueryCapabilitiesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap *soap, _cb__CbQueryCapabilitiesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbQueryCapabilitiesResponse); + if (soap_out_PointerTo_cb__CbQueryCapabilitiesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap *soap, const char *tag, int id, _cb__CbQueryCapabilitiesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbQueryCapabilitiesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap *soap, _cb__CbQueryCapabilitiesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbQueryCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbQueryCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbQueryCapabilitiesResponse(struct soap *soap, const char *tag, _cb__CbQueryCapabilitiesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbQueryCapabilitiesResponse **)soap_malloc(soap, sizeof(_cb__CbQueryCapabilitiesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbQueryCapabilitiesResponse *)soap_instantiate__cb__CbQueryCapabilitiesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbQueryCapabilitiesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbQueryCapabilitiesResponse, sizeof(_cb__CbQueryCapabilitiesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbQueryCapabilities(struct soap *soap, _cb__CbQueryCapabilities *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbQueryCapabilities)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbQueryCapabilities(struct soap *soap, _cb__CbQueryCapabilities *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbQueryCapabilities); + if (soap_out_PointerTo_cb__CbQueryCapabilities(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbQueryCapabilities(struct soap *soap, const char *tag, int id, _cb__CbQueryCapabilities *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbQueryCapabilities); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbQueryCapabilities ** SOAP_FMAC4 soap_get_PointerTo_cb__CbQueryCapabilities(struct soap *soap, _cb__CbQueryCapabilities **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbQueryCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbQueryCapabilities ** SOAP_FMAC4 soap_in_PointerTo_cb__CbQueryCapabilities(struct soap *soap, const char *tag, _cb__CbQueryCapabilities **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbQueryCapabilities **)soap_malloc(soap, sizeof(_cb__CbQueryCapabilities *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbQueryCapabilities *)soap_instantiate__cb__CbQueryCapabilities(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbQueryCapabilities **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbQueryCapabilities, sizeof(_cb__CbQueryCapabilities), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterEnumerateResponse(struct soap *soap, _cb__CbFilterEnumerateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbFilterEnumerateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterEnumerateResponse(struct soap *soap, _cb__CbFilterEnumerateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbFilterEnumerateResponse); + if (soap_out_PointerTo_cb__CbFilterEnumerateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterEnumerateResponse(struct soap *soap, const char *tag, int id, _cb__CbFilterEnumerateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbFilterEnumerateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbFilterEnumerateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterEnumerateResponse(struct soap *soap, _cb__CbFilterEnumerateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbFilterEnumerateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbFilterEnumerateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterEnumerateResponse(struct soap *soap, const char *tag, _cb__CbFilterEnumerateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbFilterEnumerateResponse **)soap_malloc(soap, sizeof(_cb__CbFilterEnumerateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbFilterEnumerateResponse *)soap_instantiate__cb__CbFilterEnumerateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbFilterEnumerateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbFilterEnumerateResponse, sizeof(_cb__CbFilterEnumerateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterEnumerate(struct soap *soap, _cb__CbFilterEnumerate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbFilterEnumerate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterEnumerate(struct soap *soap, _cb__CbFilterEnumerate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbFilterEnumerate); + if (soap_out_PointerTo_cb__CbFilterEnumerate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterEnumerate(struct soap *soap, const char *tag, int id, _cb__CbFilterEnumerate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbFilterEnumerate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbFilterEnumerate ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterEnumerate(struct soap *soap, _cb__CbFilterEnumerate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbFilterEnumerate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbFilterEnumerate ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterEnumerate(struct soap *soap, const char *tag, _cb__CbFilterEnumerate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbFilterEnumerate **)soap_malloc(soap, sizeof(_cb__CbFilterEnumerate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbFilterEnumerate *)soap_instantiate__cb__CbFilterEnumerate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbFilterEnumerate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbFilterEnumerate, sizeof(_cb__CbFilterEnumerate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterDeleteResponse(struct soap *soap, _cb__CbFilterDeleteResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbFilterDeleteResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterDeleteResponse(struct soap *soap, _cb__CbFilterDeleteResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbFilterDeleteResponse); + if (soap_out_PointerTo_cb__CbFilterDeleteResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterDeleteResponse(struct soap *soap, const char *tag, int id, _cb__CbFilterDeleteResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbFilterDeleteResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbFilterDeleteResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterDeleteResponse(struct soap *soap, _cb__CbFilterDeleteResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbFilterDeleteResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbFilterDeleteResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterDeleteResponse(struct soap *soap, const char *tag, _cb__CbFilterDeleteResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbFilterDeleteResponse **)soap_malloc(soap, sizeof(_cb__CbFilterDeleteResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbFilterDeleteResponse *)soap_instantiate__cb__CbFilterDeleteResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbFilterDeleteResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbFilterDeleteResponse, sizeof(_cb__CbFilterDeleteResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterDelete(struct soap *soap, _cb__CbFilterDelete *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbFilterDelete)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterDelete(struct soap *soap, _cb__CbFilterDelete *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbFilterDelete); + if (soap_out_PointerTo_cb__CbFilterDelete(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterDelete(struct soap *soap, const char *tag, int id, _cb__CbFilterDelete *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbFilterDelete); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbFilterDelete ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterDelete(struct soap *soap, _cb__CbFilterDelete **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbFilterDelete(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbFilterDelete ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterDelete(struct soap *soap, const char *tag, _cb__CbFilterDelete **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbFilterDelete **)soap_malloc(soap, sizeof(_cb__CbFilterDelete *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbFilterDelete *)soap_instantiate__cb__CbFilterDelete(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbFilterDelete **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbFilterDelete, sizeof(_cb__CbFilterDelete), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterGetResponse(struct soap *soap, _cb__CbFilterGetResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbFilterGetResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterGetResponse(struct soap *soap, _cb__CbFilterGetResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbFilterGetResponse); + if (soap_out_PointerTo_cb__CbFilterGetResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterGetResponse(struct soap *soap, const char *tag, int id, _cb__CbFilterGetResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbFilterGetResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbFilterGetResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterGetResponse(struct soap *soap, _cb__CbFilterGetResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbFilterGetResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbFilterGetResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterGetResponse(struct soap *soap, const char *tag, _cb__CbFilterGetResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbFilterGetResponse **)soap_malloc(soap, sizeof(_cb__CbFilterGetResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbFilterGetResponse *)soap_instantiate__cb__CbFilterGetResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbFilterGetResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbFilterGetResponse, sizeof(_cb__CbFilterGetResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterGet(struct soap *soap, _cb__CbFilterGet *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbFilterGet)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterGet(struct soap *soap, _cb__CbFilterGet *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbFilterGet); + if (soap_out_PointerTo_cb__CbFilterGet(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterGet(struct soap *soap, const char *tag, int id, _cb__CbFilterGet *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbFilterGet); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbFilterGet ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterGet(struct soap *soap, _cb__CbFilterGet **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbFilterGet(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbFilterGet ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterGet(struct soap *soap, const char *tag, _cb__CbFilterGet **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbFilterGet **)soap_malloc(soap, sizeof(_cb__CbFilterGet *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbFilterGet *)soap_instantiate__cb__CbFilterGet(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbFilterGet **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbFilterGet, sizeof(_cb__CbFilterGet), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterCreateResponse(struct soap *soap, _cb__CbFilterCreateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbFilterCreateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterCreateResponse(struct soap *soap, _cb__CbFilterCreateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbFilterCreateResponse); + if (soap_out_PointerTo_cb__CbFilterCreateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterCreateResponse(struct soap *soap, const char *tag, int id, _cb__CbFilterCreateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbFilterCreateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbFilterCreateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterCreateResponse(struct soap *soap, _cb__CbFilterCreateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbFilterCreateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbFilterCreateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterCreateResponse(struct soap *soap, const char *tag, _cb__CbFilterCreateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbFilterCreateResponse **)soap_malloc(soap, sizeof(_cb__CbFilterCreateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbFilterCreateResponse *)soap_instantiate__cb__CbFilterCreateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbFilterCreateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbFilterCreateResponse, sizeof(_cb__CbFilterCreateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbFilterCreate(struct soap *soap, _cb__CbFilterCreate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbFilterCreate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbFilterCreate(struct soap *soap, _cb__CbFilterCreate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbFilterCreate); + if (soap_out_PointerTo_cb__CbFilterCreate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbFilterCreate(struct soap *soap, const char *tag, int id, _cb__CbFilterCreate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbFilterCreate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbFilterCreate ** SOAP_FMAC4 soap_get_PointerTo_cb__CbFilterCreate(struct soap *soap, _cb__CbFilterCreate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbFilterCreate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbFilterCreate ** SOAP_FMAC4 soap_in_PointerTo_cb__CbFilterCreate(struct soap *soap, const char *tag, _cb__CbFilterCreate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbFilterCreate **)soap_malloc(soap, sizeof(_cb__CbFilterCreate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbFilterCreate *)soap_instantiate__cb__CbFilterCreate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbFilterCreate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbFilterCreate, sizeof(_cb__CbFilterCreate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, _cb__CbPolicyGetActiveStatisticsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, _cb__CbPolicyGetActiveStatisticsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatisticsResponse); + if (soap_out_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, const char *tag, int id, _cb__CbPolicyGetActiveStatisticsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, _cb__CbPolicyGetActiveStatisticsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatisticsResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetActiveStatisticsResponse(struct soap *soap, const char *tag, _cb__CbPolicyGetActiveStatisticsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyGetActiveStatisticsResponse **)soap_malloc(soap, sizeof(_cb__CbPolicyGetActiveStatisticsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyGetActiveStatisticsResponse *)soap_instantiate__cb__CbPolicyGetActiveStatisticsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyGetActiveStatisticsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyGetActiveStatisticsResponse, sizeof(_cb__CbPolicyGetActiveStatisticsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap *soap, _cb__CbPolicyGetActiveStatistics *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyGetActiveStatistics)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap *soap, _cb__CbPolicyGetActiveStatistics *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyGetActiveStatistics); + if (soap_out_PointerTo_cb__CbPolicyGetActiveStatistics(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap *soap, const char *tag, int id, _cb__CbPolicyGetActiveStatistics *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyGetActiveStatistics); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap *soap, _cb__CbPolicyGetActiveStatistics **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyGetActiveStatistics(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyGetActiveStatistics ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetActiveStatistics(struct soap *soap, const char *tag, _cb__CbPolicyGetActiveStatistics **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyGetActiveStatistics **)soap_malloc(soap, sizeof(_cb__CbPolicyGetActiveStatistics *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyGetActiveStatistics *)soap_instantiate__cb__CbPolicyGetActiveStatistics(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyGetActiveStatistics **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyGetActiveStatistics, sizeof(_cb__CbPolicyGetActiveStatistics), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap *soap, _cb__CbPolicyGetEnabledResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyGetEnabledResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap *soap, _cb__CbPolicyGetEnabledResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabledResponse); + if (soap_out_PointerTo_cb__CbPolicyGetEnabledResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap *soap, const char *tag, int id, _cb__CbPolicyGetEnabledResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyGetEnabledResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap *soap, _cb__CbPolicyGetEnabledResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyGetEnabledResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabledResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetEnabledResponse(struct soap *soap, const char *tag, _cb__CbPolicyGetEnabledResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyGetEnabledResponse **)soap_malloc(soap, sizeof(_cb__CbPolicyGetEnabledResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyGetEnabledResponse *)soap_instantiate__cb__CbPolicyGetEnabledResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyGetEnabledResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyGetEnabledResponse, sizeof(_cb__CbPolicyGetEnabledResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetEnabled(struct soap *soap, _cb__CbPolicyGetEnabled *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyGetEnabled)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetEnabled(struct soap *soap, _cb__CbPolicyGetEnabled *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyGetEnabled); + if (soap_out_PointerTo_cb__CbPolicyGetEnabled(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetEnabled(struct soap *soap, const char *tag, int id, _cb__CbPolicyGetEnabled *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyGetEnabled); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabled ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetEnabled(struct soap *soap, _cb__CbPolicyGetEnabled **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyGetEnabled(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyGetEnabled ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetEnabled(struct soap *soap, const char *tag, _cb__CbPolicyGetEnabled **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyGetEnabled **)soap_malloc(soap, sizeof(_cb__CbPolicyGetEnabled *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyGetEnabled *)soap_instantiate__cb__CbPolicyGetEnabled(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyGetEnabled **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyGetEnabled, sizeof(_cb__CbPolicyGetEnabled), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyDisableResponse(struct soap *soap, _cb__CbPolicyDisableResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyDisableResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyDisableResponse(struct soap *soap, _cb__CbPolicyDisableResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyDisableResponse); + if (soap_out_PointerTo_cb__CbPolicyDisableResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyDisableResponse(struct soap *soap, const char *tag, int id, _cb__CbPolicyDisableResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyDisableResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyDisableResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyDisableResponse(struct soap *soap, _cb__CbPolicyDisableResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyDisableResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyDisableResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyDisableResponse(struct soap *soap, const char *tag, _cb__CbPolicyDisableResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyDisableResponse **)soap_malloc(soap, sizeof(_cb__CbPolicyDisableResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyDisableResponse *)soap_instantiate__cb__CbPolicyDisableResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyDisableResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyDisableResponse, sizeof(_cb__CbPolicyDisableResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyDisable(struct soap *soap, _cb__CbPolicyDisable *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyDisable)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyDisable(struct soap *soap, _cb__CbPolicyDisable *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyDisable); + if (soap_out_PointerTo_cb__CbPolicyDisable(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyDisable(struct soap *soap, const char *tag, int id, _cb__CbPolicyDisable *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyDisable); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyDisable ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyDisable(struct soap *soap, _cb__CbPolicyDisable **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyDisable(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyDisable ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyDisable(struct soap *soap, const char *tag, _cb__CbPolicyDisable **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyDisable **)soap_malloc(soap, sizeof(_cb__CbPolicyDisable *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyDisable *)soap_instantiate__cb__CbPolicyDisable(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyDisable **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyDisable, sizeof(_cb__CbPolicyDisable), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyEnableResponse(struct soap *soap, _cb__CbPolicyEnableResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyEnableResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyEnableResponse(struct soap *soap, _cb__CbPolicyEnableResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyEnableResponse); + if (soap_out_PointerTo_cb__CbPolicyEnableResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyEnableResponse(struct soap *soap, const char *tag, int id, _cb__CbPolicyEnableResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyEnableResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnableResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyEnableResponse(struct soap *soap, _cb__CbPolicyEnableResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyEnableResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyEnableResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyEnableResponse(struct soap *soap, const char *tag, _cb__CbPolicyEnableResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyEnableResponse **)soap_malloc(soap, sizeof(_cb__CbPolicyEnableResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyEnableResponse *)soap_instantiate__cb__CbPolicyEnableResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyEnableResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyEnableResponse, sizeof(_cb__CbPolicyEnableResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyEnable(struct soap *soap, _cb__CbPolicyEnable *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyEnable)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyEnable(struct soap *soap, _cb__CbPolicyEnable *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyEnable); + if (soap_out_PointerTo_cb__CbPolicyEnable(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyEnable(struct soap *soap, const char *tag, int id, _cb__CbPolicyEnable *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyEnable); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnable ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyEnable(struct soap *soap, _cb__CbPolicyEnable **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyEnable(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyEnable ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyEnable(struct soap *soap, const char *tag, _cb__CbPolicyEnable **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyEnable **)soap_malloc(soap, sizeof(_cb__CbPolicyEnable *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyEnable *)soap_instantiate__cb__CbPolicyEnable(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyEnable **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyEnable, sizeof(_cb__CbPolicyEnable), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyEnumerateResponse(struct soap *soap, _cb__CbPolicyEnumerateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyEnumerateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyEnumerateResponse(struct soap *soap, _cb__CbPolicyEnumerateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyEnumerateResponse); + if (soap_out_PointerTo_cb__CbPolicyEnumerateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyEnumerateResponse(struct soap *soap, const char *tag, int id, _cb__CbPolicyEnumerateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyEnumerateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyEnumerateResponse(struct soap *soap, _cb__CbPolicyEnumerateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyEnumerateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyEnumerateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyEnumerateResponse(struct soap *soap, const char *tag, _cb__CbPolicyEnumerateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyEnumerateResponse **)soap_malloc(soap, sizeof(_cb__CbPolicyEnumerateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyEnumerateResponse *)soap_instantiate__cb__CbPolicyEnumerateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyEnumerateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyEnumerateResponse, sizeof(_cb__CbPolicyEnumerateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyEnumerate(struct soap *soap, _cb__CbPolicyEnumerate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyEnumerate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyEnumerate(struct soap *soap, _cb__CbPolicyEnumerate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyEnumerate); + if (soap_out_PointerTo_cb__CbPolicyEnumerate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyEnumerate(struct soap *soap, const char *tag, int id, _cb__CbPolicyEnumerate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyEnumerate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyEnumerate ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyEnumerate(struct soap *soap, _cb__CbPolicyEnumerate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyEnumerate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyEnumerate ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyEnumerate(struct soap *soap, const char *tag, _cb__CbPolicyEnumerate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyEnumerate **)soap_malloc(soap, sizeof(_cb__CbPolicyEnumerate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyEnumerate *)soap_instantiate__cb__CbPolicyEnumerate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyEnumerate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyEnumerate, sizeof(_cb__CbPolicyEnumerate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyDeleteResponse(struct soap *soap, _cb__CbPolicyDeleteResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyDeleteResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyDeleteResponse(struct soap *soap, _cb__CbPolicyDeleteResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyDeleteResponse); + if (soap_out_PointerTo_cb__CbPolicyDeleteResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyDeleteResponse(struct soap *soap, const char *tag, int id, _cb__CbPolicyDeleteResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyDeleteResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyDeleteResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyDeleteResponse(struct soap *soap, _cb__CbPolicyDeleteResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyDeleteResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyDeleteResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyDeleteResponse(struct soap *soap, const char *tag, _cb__CbPolicyDeleteResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyDeleteResponse **)soap_malloc(soap, sizeof(_cb__CbPolicyDeleteResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyDeleteResponse *)soap_instantiate__cb__CbPolicyDeleteResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyDeleteResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyDeleteResponse, sizeof(_cb__CbPolicyDeleteResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyDelete(struct soap *soap, _cb__CbPolicyDelete *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyDelete)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyDelete(struct soap *soap, _cb__CbPolicyDelete *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyDelete); + if (soap_out_PointerTo_cb__CbPolicyDelete(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyDelete(struct soap *soap, const char *tag, int id, _cb__CbPolicyDelete *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyDelete); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyDelete ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyDelete(struct soap *soap, _cb__CbPolicyDelete **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyDelete(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyDelete ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyDelete(struct soap *soap, const char *tag, _cb__CbPolicyDelete **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyDelete **)soap_malloc(soap, sizeof(_cb__CbPolicyDelete *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyDelete *)soap_instantiate__cb__CbPolicyDelete(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyDelete **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyDelete, sizeof(_cb__CbPolicyDelete), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGetResponse(struct soap *soap, _cb__CbPolicyGetResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyGetResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGetResponse(struct soap *soap, _cb__CbPolicyGetResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyGetResponse); + if (soap_out_PointerTo_cb__CbPolicyGetResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGetResponse(struct soap *soap, const char *tag, int id, _cb__CbPolicyGetResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyGetResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyGetResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGetResponse(struct soap *soap, _cb__CbPolicyGetResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyGetResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyGetResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGetResponse(struct soap *soap, const char *tag, _cb__CbPolicyGetResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyGetResponse **)soap_malloc(soap, sizeof(_cb__CbPolicyGetResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyGetResponse *)soap_instantiate__cb__CbPolicyGetResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyGetResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyGetResponse, sizeof(_cb__CbPolicyGetResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyGet(struct soap *soap, _cb__CbPolicyGet *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyGet)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyGet(struct soap *soap, _cb__CbPolicyGet *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyGet); + if (soap_out_PointerTo_cb__CbPolicyGet(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyGet(struct soap *soap, const char *tag, int id, _cb__CbPolicyGet *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyGet); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyGet ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyGet(struct soap *soap, _cb__CbPolicyGet **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyGet(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyGet ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyGet(struct soap *soap, const char *tag, _cb__CbPolicyGet **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyGet **)soap_malloc(soap, sizeof(_cb__CbPolicyGet *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyGet *)soap_instantiate__cb__CbPolicyGet(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyGet **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyGet, sizeof(_cb__CbPolicyGet), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyCreateResponse(struct soap *soap, _cb__CbPolicyCreateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyCreateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyCreateResponse(struct soap *soap, _cb__CbPolicyCreateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyCreateResponse); + if (soap_out_PointerTo_cb__CbPolicyCreateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyCreateResponse(struct soap *soap, const char *tag, int id, _cb__CbPolicyCreateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyCreateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyCreateResponse ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyCreateResponse(struct soap *soap, _cb__CbPolicyCreateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyCreateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyCreateResponse ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyCreateResponse(struct soap *soap, const char *tag, _cb__CbPolicyCreateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyCreateResponse **)soap_malloc(soap, sizeof(_cb__CbPolicyCreateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyCreateResponse *)soap_instantiate__cb__CbPolicyCreateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyCreateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyCreateResponse, sizeof(_cb__CbPolicyCreateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_cb__CbPolicyCreate(struct soap *soap, _cb__CbPolicyCreate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__cb__CbPolicyCreate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_cb__CbPolicyCreate(struct soap *soap, _cb__CbPolicyCreate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_cb__CbPolicyCreate); + if (soap_out_PointerTo_cb__CbPolicyCreate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_cb__CbPolicyCreate(struct soap *soap, const char *tag, int id, _cb__CbPolicyCreate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__cb__CbPolicyCreate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _cb__CbPolicyCreate ** SOAP_FMAC4 soap_get_PointerTo_cb__CbPolicyCreate(struct soap *soap, _cb__CbPolicyCreate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_cb__CbPolicyCreate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _cb__CbPolicyCreate ** SOAP_FMAC4 soap_in_PointerTo_cb__CbPolicyCreate(struct soap *soap, const char *tag, _cb__CbPolicyCreate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_cb__CbPolicyCreate **)soap_malloc(soap, sizeof(_cb__CbPolicyCreate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_cb__CbPolicyCreate *)soap_instantiate__cb__CbPolicyCreate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_cb__CbPolicyCreate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__cb__CbPolicyCreate, sizeof(_cb__CbPolicyCreate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilitiesResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilitiesResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse); + if (soap_out_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogQueryCapabilitiesResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilitiesResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilitiesResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogQueryCapabilitiesResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogQueryCapabilitiesResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogQueryCapabilitiesResponse **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogQueryCapabilitiesResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogQueryCapabilitiesResponse *)soap_instantiate__apr__ConsoleWatchdogQueryCapabilitiesResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogQueryCapabilitiesResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilitiesResponse, sizeof(_apr__ConsoleWatchdogQueryCapabilitiesResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilities *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilities *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogQueryCapabilities); + if (soap_out_PointerTo_apr__ConsoleWatchdogQueryCapabilities(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogQueryCapabilities *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, _apr__ConsoleWatchdogQueryCapabilities **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogQueryCapabilities(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogQueryCapabilities ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const char *tag, _apr__ConsoleWatchdogQueryCapabilities **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogQueryCapabilities **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogQueryCapabilities *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogQueryCapabilities *)soap_instantiate__apr__ConsoleWatchdogQueryCapabilities(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogQueryCapabilities **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogQueryCapabilities, sizeof(_apr__ConsoleWatchdogQueryCapabilities), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicyResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicyResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse); + if (soap_out_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogGetCbPolicyResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicyResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicyResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogGetCbPolicyResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogGetCbPolicyResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogGetCbPolicyResponse **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogGetCbPolicyResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogGetCbPolicyResponse *)soap_instantiate__apr__ConsoleWatchdogGetCbPolicyResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogGetCbPolicyResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicyResponse, sizeof(_apr__ConsoleWatchdogGetCbPolicyResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicy *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicy *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetCbPolicy); + if (soap_out_PointerTo_apr__ConsoleWatchdogGetCbPolicy(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogGetCbPolicy *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogGetCbPolicy **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogGetCbPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetCbPolicy ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const char *tag, _apr__ConsoleWatchdogGetCbPolicy **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogGetCbPolicy **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogGetCbPolicy *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogGetCbPolicy *)soap_instantiate__apr__ConsoleWatchdogGetCbPolicy(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogGetCbPolicy **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogGetCbPolicy, sizeof(_apr__ConsoleWatchdogGetCbPolicy), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicyResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicyResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse); + if (soap_out_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogSetCbPolicyResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicyResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicyResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogSetCbPolicyResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogSetCbPolicyResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogSetCbPolicyResponse **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogSetCbPolicyResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogSetCbPolicyResponse *)soap_instantiate__apr__ConsoleWatchdogSetCbPolicyResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogSetCbPolicyResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicyResponse, sizeof(_apr__ConsoleWatchdogSetCbPolicyResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicy *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicy *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetCbPolicy); + if (soap_out_PointerTo_apr__ConsoleWatchdogSetCbPolicy(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogSetCbPolicy *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, _apr__ConsoleWatchdogSetCbPolicy **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogSetCbPolicy(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetCbPolicy ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const char *tag, _apr__ConsoleWatchdogSetCbPolicy **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogSetCbPolicy **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogSetCbPolicy *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogSetCbPolicy *)soap_instantiate__apr__ConsoleWatchdogSetCbPolicy(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogSetCbPolicy **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogSetCbPolicy, sizeof(_apr__ConsoleWatchdogSetCbPolicy), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogGetActionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogGetActionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActionsResponse); + if (soap_out_PointerTo_apr__ConsoleWatchdogGetActionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogGetActionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogGetActionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogGetActionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActionsResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogGetActionsResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogGetActionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogGetActionsResponse **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogGetActionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogGetActionsResponse *)soap_instantiate__apr__ConsoleWatchdogGetActionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogGetActionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogGetActionsResponse, sizeof(_apr__ConsoleWatchdogGetActionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogGetActions(struct soap *soap, _apr__ConsoleWatchdogGetActions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogGetActions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogGetActions(struct soap *soap, _apr__ConsoleWatchdogGetActions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogGetActions); + if (soap_out_PointerTo_apr__ConsoleWatchdogGetActions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogGetActions(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogGetActions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogGetActions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogGetActions(struct soap *soap, _apr__ConsoleWatchdogGetActions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogGetActions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogGetActions ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogGetActions(struct soap *soap, const char *tag, _apr__ConsoleWatchdogGetActions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogGetActions **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogGetActions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogGetActions *)soap_instantiate__apr__ConsoleWatchdogGetActions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogGetActions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogGetActions, sizeof(_apr__ConsoleWatchdogGetActions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogSetActionsResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogSetActionsResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActionsResponse); + if (soap_out_PointerTo_apr__ConsoleWatchdogSetActionsResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogSetActionsResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, _apr__ConsoleWatchdogSetActionsResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogSetActionsResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActionsResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogSetActionsResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogSetActionsResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogSetActionsResponse **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogSetActionsResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogSetActionsResponse *)soap_instantiate__apr__ConsoleWatchdogSetActionsResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogSetActionsResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogSetActionsResponse, sizeof(_apr__ConsoleWatchdogSetActionsResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogSetActions(struct soap *soap, _apr__ConsoleWatchdogSetActions *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogSetActions)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogSetActions(struct soap *soap, _apr__ConsoleWatchdogSetActions *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogSetActions); + if (soap_out_PointerTo_apr__ConsoleWatchdogSetActions(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogSetActions(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogSetActions *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogSetActions); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogSetActions(struct soap *soap, _apr__ConsoleWatchdogSetActions **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogSetActions(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogSetActions ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogSetActions(struct soap *soap, const char *tag, _apr__ConsoleWatchdogSetActions **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogSetActions **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogSetActions *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogSetActions *)soap_instantiate__apr__ConsoleWatchdogSetActions(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogSetActions **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogSetActions, sizeof(_apr__ConsoleWatchdogSetActions), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, _apr__ConsoleWatchdogEnumerateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, _apr__ConsoleWatchdogEnumerateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerateResponse); + if (soap_out_PointerTo_apr__ConsoleWatchdogEnumerateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogEnumerateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, _apr__ConsoleWatchdogEnumerateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogEnumerateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerateResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogEnumerateResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogEnumerateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogEnumerateResponse **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogEnumerateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogEnumerateResponse *)soap_instantiate__apr__ConsoleWatchdogEnumerateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogEnumerateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogEnumerateResponse, sizeof(_apr__ConsoleWatchdogEnumerateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap *soap, _apr__ConsoleWatchdogEnumerate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogEnumerate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap *soap, _apr__ConsoleWatchdogEnumerate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogEnumerate); + if (soap_out_PointerTo_apr__ConsoleWatchdogEnumerate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogEnumerate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogEnumerate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap *soap, _apr__ConsoleWatchdogEnumerate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogEnumerate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogEnumerate ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogEnumerate(struct soap *soap, const char *tag, _apr__ConsoleWatchdogEnumerate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogEnumerate **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogEnumerate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogEnumerate *)soap_instantiate__apr__ConsoleWatchdogEnumerate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogEnumerate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogEnumerate, sizeof(_apr__ConsoleWatchdogEnumerate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap *soap, _apr__ConsoleWatchdogDeleteResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap *soap, _apr__ConsoleWatchdogDeleteResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDeleteResponse); + if (soap_out_PointerTo_apr__ConsoleWatchdogDeleteResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogDeleteResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap *soap, _apr__ConsoleWatchdogDeleteResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogDeleteResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDeleteResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogDeleteResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogDeleteResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogDeleteResponse **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogDeleteResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogDeleteResponse *)soap_instantiate__apr__ConsoleWatchdogDeleteResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogDeleteResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogDeleteResponse, sizeof(_apr__ConsoleWatchdogDeleteResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogDelete(struct soap *soap, _apr__ConsoleWatchdogDelete *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogDelete)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogDelete(struct soap *soap, _apr__ConsoleWatchdogDelete *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogDelete); + if (soap_out_PointerTo_apr__ConsoleWatchdogDelete(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogDelete(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogDelete *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogDelete); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDelete ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogDelete(struct soap *soap, _apr__ConsoleWatchdogDelete **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogDelete(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogDelete ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogDelete(struct soap *soap, const char *tag, _apr__ConsoleWatchdogDelete **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogDelete **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogDelete *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogDelete *)soap_instantiate__apr__ConsoleWatchdogDelete(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogDelete **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogDelete, sizeof(_apr__ConsoleWatchdogDelete), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap *soap, _apr__ConsoleWatchdogCreateResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogCreateResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap *soap, _apr__ConsoleWatchdogCreateResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreateResponse); + if (soap_out_PointerTo_apr__ConsoleWatchdogCreateResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogCreateResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogCreateResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap *soap, _apr__ConsoleWatchdogCreateResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogCreateResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreateResponse ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogCreateResponse(struct soap *soap, const char *tag, _apr__ConsoleWatchdogCreateResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogCreateResponse **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogCreateResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogCreateResponse *)soap_instantiate__apr__ConsoleWatchdogCreateResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogCreateResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogCreateResponse, sizeof(_apr__ConsoleWatchdogCreateResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apr__ConsoleWatchdogCreate(struct soap *soap, _apr__ConsoleWatchdogCreate *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apr__ConsoleWatchdogCreate)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apr__ConsoleWatchdogCreate(struct soap *soap, _apr__ConsoleWatchdogCreate *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apr__ConsoleWatchdogCreate); + if (soap_out_PointerTo_apr__ConsoleWatchdogCreate(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apr__ConsoleWatchdogCreate(struct soap *soap, const char *tag, int id, _apr__ConsoleWatchdogCreate *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apr__ConsoleWatchdogCreate); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreate ** SOAP_FMAC4 soap_get_PointerTo_apr__ConsoleWatchdogCreate(struct soap *soap, _apr__ConsoleWatchdogCreate **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apr__ConsoleWatchdogCreate(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apr__ConsoleWatchdogCreate ** SOAP_FMAC4 soap_in_PointerTo_apr__ConsoleWatchdogCreate(struct soap *soap, const char *tag, _apr__ConsoleWatchdogCreate **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apr__ConsoleWatchdogCreate **)soap_malloc(soap, sizeof(_apr__ConsoleWatchdogCreate *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apr__ConsoleWatchdogCreate *)soap_instantiate__apr__ConsoleWatchdogCreate(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apr__ConsoleWatchdogCreate **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apr__ConsoleWatchdogCreate, sizeof(_apr__ConsoleWatchdogCreate), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap *soap, _apl__AgentWatchdogRegisterResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apl__AgentWatchdogRegisterResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap *soap, _apl__AgentWatchdogRegisterResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apl__AgentWatchdogRegisterResponse); + if (soap_out_PointerTo_apl__AgentWatchdogRegisterResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap *soap, const char *tag, int id, _apl__AgentWatchdogRegisterResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apl__AgentWatchdogRegisterResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap *soap, _apl__AgentWatchdogRegisterResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apl__AgentWatchdogRegisterResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apl__AgentWatchdogRegisterResponse ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogRegisterResponse(struct soap *soap, const char *tag, _apl__AgentWatchdogRegisterResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apl__AgentWatchdogRegisterResponse **)soap_malloc(soap, sizeof(_apl__AgentWatchdogRegisterResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apl__AgentWatchdogRegisterResponse *)soap_instantiate__apl__AgentWatchdogRegisterResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apl__AgentWatchdogRegisterResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apl__AgentWatchdogRegisterResponse, sizeof(_apl__AgentWatchdogRegisterResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogRegister(struct soap *soap, _apl__AgentWatchdogRegister *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apl__AgentWatchdogRegister)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogRegister(struct soap *soap, _apl__AgentWatchdogRegister *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apl__AgentWatchdogRegister); + if (soap_out_PointerTo_apl__AgentWatchdogRegister(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogRegister(struct soap *soap, const char *tag, int id, _apl__AgentWatchdogRegister *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apl__AgentWatchdogRegister); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogRegister ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogRegister(struct soap *soap, _apl__AgentWatchdogRegister **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apl__AgentWatchdogRegister(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apl__AgentWatchdogRegister ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogRegister(struct soap *soap, const char *tag, _apl__AgentWatchdogRegister **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apl__AgentWatchdogRegister **)soap_malloc(soap, sizeof(_apl__AgentWatchdogRegister *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apl__AgentWatchdogRegister *)soap_instantiate__apl__AgentWatchdogRegister(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apl__AgentWatchdogRegister **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apl__AgentWatchdogRegister, sizeof(_apl__AgentWatchdogRegister), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap *soap, _apl__AgentWatchdogHeartbeatResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap *soap, _apl__AgentWatchdogHeartbeatResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeatResponse); + if (soap_out_PointerTo_apl__AgentWatchdogHeartbeatResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap *soap, const char *tag, int id, _apl__AgentWatchdogHeartbeatResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap *soap, _apl__AgentWatchdogHeartbeatResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apl__AgentWatchdogHeartbeatResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeatResponse ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogHeartbeatResponse(struct soap *soap, const char *tag, _apl__AgentWatchdogHeartbeatResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apl__AgentWatchdogHeartbeatResponse **)soap_malloc(soap, sizeof(_apl__AgentWatchdogHeartbeatResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apl__AgentWatchdogHeartbeatResponse *)soap_instantiate__apl__AgentWatchdogHeartbeatResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apl__AgentWatchdogHeartbeatResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apl__AgentWatchdogHeartbeatResponse, sizeof(_apl__AgentWatchdogHeartbeatResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogHeartbeat(struct soap *soap, _apl__AgentWatchdogHeartbeat *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apl__AgentWatchdogHeartbeat)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogHeartbeat(struct soap *soap, _apl__AgentWatchdogHeartbeat *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apl__AgentWatchdogHeartbeat); + if (soap_out_PointerTo_apl__AgentWatchdogHeartbeat(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogHeartbeat(struct soap *soap, const char *tag, int id, _apl__AgentWatchdogHeartbeat *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apl__AgentWatchdogHeartbeat); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogHeartbeat(struct soap *soap, _apl__AgentWatchdogHeartbeat **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apl__AgentWatchdogHeartbeat(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apl__AgentWatchdogHeartbeat ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogHeartbeat(struct soap *soap, const char *tag, _apl__AgentWatchdogHeartbeat **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apl__AgentWatchdogHeartbeat **)soap_malloc(soap, sizeof(_apl__AgentWatchdogHeartbeat *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apl__AgentWatchdogHeartbeat *)soap_instantiate__apl__AgentWatchdogHeartbeat(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apl__AgentWatchdogHeartbeat **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apl__AgentWatchdogHeartbeat, sizeof(_apl__AgentWatchdogHeartbeat), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap *soap, _apl__AgentWatchdogShutdownResponse *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apl__AgentWatchdogShutdownResponse)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap *soap, _apl__AgentWatchdogShutdownResponse *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdownResponse); + if (soap_out_PointerTo_apl__AgentWatchdogShutdownResponse(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap *soap, const char *tag, int id, _apl__AgentWatchdogShutdownResponse *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apl__AgentWatchdogShutdownResponse); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap *soap, _apl__AgentWatchdogShutdownResponse **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apl__AgentWatchdogShutdownResponse(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdownResponse ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogShutdownResponse(struct soap *soap, const char *tag, _apl__AgentWatchdogShutdownResponse **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apl__AgentWatchdogShutdownResponse **)soap_malloc(soap, sizeof(_apl__AgentWatchdogShutdownResponse *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apl__AgentWatchdogShutdownResponse *)soap_instantiate__apl__AgentWatchdogShutdownResponse(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apl__AgentWatchdogShutdownResponse **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apl__AgentWatchdogShutdownResponse, sizeof(_apl__AgentWatchdogShutdownResponse), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTo_apl__AgentWatchdogShutdown(struct soap *soap, _apl__AgentWatchdogShutdown *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE__apl__AgentWatchdogShutdown)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTo_apl__AgentWatchdogShutdown(struct soap *soap, _apl__AgentWatchdogShutdown *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTo_apl__AgentWatchdogShutdown); + if (soap_out_PointerTo_apl__AgentWatchdogShutdown(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTo_apl__AgentWatchdogShutdown(struct soap *soap, const char *tag, int id, _apl__AgentWatchdogShutdown *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE__apl__AgentWatchdogShutdown); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdown ** SOAP_FMAC4 soap_get_PointerTo_apl__AgentWatchdogShutdown(struct soap *soap, _apl__AgentWatchdogShutdown **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTo_apl__AgentWatchdogShutdown(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 _apl__AgentWatchdogShutdown ** SOAP_FMAC4 soap_in_PointerTo_apl__AgentWatchdogShutdown(struct soap *soap, const char *tag, _apl__AgentWatchdogShutdown **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (_apl__AgentWatchdogShutdown **)soap_malloc(soap, sizeof(_apl__AgentWatchdogShutdown *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (_apl__AgentWatchdogShutdown *)soap_instantiate__apl__AgentWatchdogShutdown(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (_apl__AgentWatchdogShutdown **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE__apl__AgentWatchdogShutdown, sizeof(_apl__AgentWatchdogShutdown), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, cb__CircuitBreakerIPLayeredTCPFlagsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, cb__CircuitBreakerIPLayeredTCPFlagsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType); + if (soap_out_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerIPLayeredTCPFlagsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, cb__CircuitBreakerIPLayeredTCPFlagsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredTCPFlagsType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPLayeredTCPFlagsType(struct soap *soap, const char *tag, cb__CircuitBreakerIPLayeredTCPFlagsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerIPLayeredTCPFlagsType **)soap_malloc(soap, sizeof(cb__CircuitBreakerIPLayeredTCPFlagsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerIPLayeredTCPFlagsType *)soap_instantiate_cb__CircuitBreakerIPLayeredTCPFlagsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPLayeredTCPFlagsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerIPLayeredTCPFlagsType, sizeof(cb__CircuitBreakerIPLayeredTCPFlagsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__WirelessSettingsType(struct soap *soap, wcxs__WirelessSettingsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__WirelessSettingsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__WirelessSettingsType(struct soap *soap, wcxs__WirelessSettingsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__WirelessSettingsType); + if (soap_out_PointerTowcxs__WirelessSettingsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__WirelessSettingsType(struct soap *soap, const char *tag, int id, wcxs__WirelessSettingsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__WirelessSettingsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__WirelessSettingsType ** SOAP_FMAC4 soap_get_PointerTowcxs__WirelessSettingsType(struct soap *soap, wcxs__WirelessSettingsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__WirelessSettingsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__WirelessSettingsType ** SOAP_FMAC4 soap_in_PointerTowcxs__WirelessSettingsType(struct soap *soap, const char *tag, wcxs__WirelessSettingsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__WirelessSettingsType **)soap_malloc(soap, sizeof(wcxs__WirelessSettingsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__WirelessSettingsType *)soap_instantiate_wcxs__WirelessSettingsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__WirelessSettingsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__WirelessSettingsType, sizeof(wcxs__WirelessSettingsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__WirelessCapabilitiesType(struct soap *soap, wcxs__WirelessCapabilitiesType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__WirelessCapabilitiesType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__WirelessCapabilitiesType(struct soap *soap, wcxs__WirelessCapabilitiesType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__WirelessCapabilitiesType); + if (soap_out_PointerTowcxs__WirelessCapabilitiesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__WirelessCapabilitiesType(struct soap *soap, const char *tag, int id, wcxs__WirelessCapabilitiesType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__WirelessCapabilitiesType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__WirelessCapabilitiesType ** SOAP_FMAC4 soap_get_PointerTowcxs__WirelessCapabilitiesType(struct soap *soap, wcxs__WirelessCapabilitiesType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__WirelessCapabilitiesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__WirelessCapabilitiesType ** SOAP_FMAC4 soap_in_PointerTowcxs__WirelessCapabilitiesType(struct soap *soap, const char *tag, wcxs__WirelessCapabilitiesType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__WirelessCapabilitiesType **)soap_malloc(soap, sizeof(wcxs__WirelessCapabilitiesType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__WirelessCapabilitiesType *)soap_instantiate_wcxs__WirelessCapabilitiesType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__WirelessCapabilitiesType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__WirelessCapabilitiesType, sizeof(wcxs__WirelessCapabilitiesType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__ProfileType(struct soap *soap, wcxs__ProfileType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__ProfileType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__ProfileType(struct soap *soap, wcxs__ProfileType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__ProfileType); + if (soap_out_PointerTowcxs__ProfileType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__ProfileType(struct soap *soap, const char *tag, int id, wcxs__ProfileType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__ProfileType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__ProfileType ** SOAP_FMAC4 soap_get_PointerTowcxs__ProfileType(struct soap *soap, wcxs__ProfileType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__ProfileType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__ProfileType ** SOAP_FMAC4 soap_in_PointerTowcxs__ProfileType(struct soap *soap, const char *tag, wcxs__ProfileType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__ProfileType **)soap_malloc(soap, sizeof(wcxs__ProfileType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__ProfileType *)soap_instantiate_wcxs__ProfileType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__ProfileType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__ProfileType, sizeof(wcxs__ProfileType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__ProfileSecuritySettingsType(struct soap *soap, wcxs__ProfileSecuritySettingsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__ProfileSecuritySettingsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__ProfileSecuritySettingsType(struct soap *soap, wcxs__ProfileSecuritySettingsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingsType); + if (soap_out_PointerTowcxs__ProfileSecuritySettingsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__ProfileSecuritySettingsType(struct soap *soap, const char *tag, int id, wcxs__ProfileSecuritySettingsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__ProfileSecuritySettingsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType ** SOAP_FMAC4 soap_get_PointerTowcxs__ProfileSecuritySettingsType(struct soap *soap, wcxs__ProfileSecuritySettingsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__ProfileSecuritySettingsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingsType ** SOAP_FMAC4 soap_in_PointerTowcxs__ProfileSecuritySettingsType(struct soap *soap, const char *tag, wcxs__ProfileSecuritySettingsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__ProfileSecuritySettingsType **)soap_malloc(soap, sizeof(wcxs__ProfileSecuritySettingsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__ProfileSecuritySettingsType *)soap_instantiate_wcxs__ProfileSecuritySettingsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__ProfileSecuritySettingsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__ProfileSecuritySettingsType, sizeof(wcxs__ProfileSecuritySettingsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap *soap, wcxs__ProfileSecuritySettingRSNType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap *soap, wcxs__ProfileSecuritySettingRSNType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingRSNType); + if (soap_out_PointerTowcxs__ProfileSecuritySettingRSNType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap *soap, const char *tag, int id, wcxs__ProfileSecuritySettingRSNType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType ** SOAP_FMAC4 soap_get_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap *soap, wcxs__ProfileSecuritySettingRSNType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__ProfileSecuritySettingRSNType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingRSNType ** SOAP_FMAC4 soap_in_PointerTowcxs__ProfileSecuritySettingRSNType(struct soap *soap, const char *tag, wcxs__ProfileSecuritySettingRSNType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__ProfileSecuritySettingRSNType **)soap_malloc(soap, sizeof(wcxs__ProfileSecuritySettingRSNType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__ProfileSecuritySettingRSNType *)soap_instantiate_wcxs__ProfileSecuritySettingRSNType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__ProfileSecuritySettingRSNType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__ProfileSecuritySettingRSNType, sizeof(wcxs__ProfileSecuritySettingRSNType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap *soap, wcxs__ProfileSecuritySettingWPAType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap *soap, wcxs__ProfileSecuritySettingWPAType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__ProfileSecuritySettingWPAType); + if (soap_out_PointerTowcxs__ProfileSecuritySettingWPAType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap *soap, const char *tag, int id, wcxs__ProfileSecuritySettingWPAType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType ** SOAP_FMAC4 soap_get_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap *soap, wcxs__ProfileSecuritySettingWPAType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__ProfileSecuritySettingWPAType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__ProfileSecuritySettingWPAType ** SOAP_FMAC4 soap_in_PointerTowcxs__ProfileSecuritySettingWPAType(struct soap *soap, const char *tag, wcxs__ProfileSecuritySettingWPAType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__ProfileSecuritySettingWPAType **)soap_malloc(soap, sizeof(wcxs__ProfileSecuritySettingWPAType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__ProfileSecuritySettingWPAType *)soap_instantiate_wcxs__ProfileSecuritySettingWPAType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__ProfileSecuritySettingWPAType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__ProfileSecuritySettingWPAType, sizeof(wcxs__ProfileSecuritySettingWPAType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__DataEncryptionCCMPType(struct soap *soap, wcxs__DataEncryptionCCMPType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__DataEncryptionCCMPType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__DataEncryptionCCMPType(struct soap *soap, wcxs__DataEncryptionCCMPType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__DataEncryptionCCMPType); + if (soap_out_PointerTowcxs__DataEncryptionCCMPType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__DataEncryptionCCMPType(struct soap *soap, const char *tag, int id, wcxs__DataEncryptionCCMPType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__DataEncryptionCCMPType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionCCMPType ** SOAP_FMAC4 soap_get_PointerTowcxs__DataEncryptionCCMPType(struct soap *soap, wcxs__DataEncryptionCCMPType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__DataEncryptionCCMPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__DataEncryptionCCMPType ** SOAP_FMAC4 soap_in_PointerTowcxs__DataEncryptionCCMPType(struct soap *soap, const char *tag, wcxs__DataEncryptionCCMPType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__DataEncryptionCCMPType **)soap_malloc(soap, sizeof(wcxs__DataEncryptionCCMPType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__DataEncryptionCCMPType *)soap_instantiate_wcxs__DataEncryptionCCMPType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__DataEncryptionCCMPType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__DataEncryptionCCMPType, sizeof(wcxs__DataEncryptionCCMPType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__DataEncryptionTKIPType(struct soap *soap, wcxs__DataEncryptionTKIPType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__DataEncryptionTKIPType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__DataEncryptionTKIPType(struct soap *soap, wcxs__DataEncryptionTKIPType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__DataEncryptionTKIPType); + if (soap_out_PointerTowcxs__DataEncryptionTKIPType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__DataEncryptionTKIPType(struct soap *soap, const char *tag, int id, wcxs__DataEncryptionTKIPType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__DataEncryptionTKIPType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__DataEncryptionTKIPType ** SOAP_FMAC4 soap_get_PointerTowcxs__DataEncryptionTKIPType(struct soap *soap, wcxs__DataEncryptionTKIPType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__DataEncryptionTKIPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__DataEncryptionTKIPType ** SOAP_FMAC4 soap_in_PointerTowcxs__DataEncryptionTKIPType(struct soap *soap, const char *tag, wcxs__DataEncryptionTKIPType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__DataEncryptionTKIPType **)soap_malloc(soap, sizeof(wcxs__DataEncryptionTKIPType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__DataEncryptionTKIPType *)soap_instantiate_wcxs__DataEncryptionTKIPType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__DataEncryptionTKIPType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__DataEncryptionTKIPType, sizeof(wcxs__DataEncryptionTKIPType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__RawKey256Type(struct soap *soap, xsd__base64Binary *const*a) +{ + if (*a) + soap_serialize_wcxs__RawKey256Type(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__RawKey256Type(struct soap *soap, xsd__base64Binary *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__RawKey256Type); + if (soap_out_PointerTowcxs__RawKey256Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__RawKey256Type(struct soap *soap, const char *tag, int id, xsd__base64Binary *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, (struct soap_array*)&(*a)->__ptr, 1, type, SOAP_TYPE_wcxs__RawKey256Type); + if (id < 0) + return soap->error; + return soap_out_wcxs__RawKey256Type(soap, tag, id, *a, type); +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerTowcxs__RawKey256Type(struct soap *soap, xsd__base64Binary **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__RawKey256Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerTowcxs__RawKey256Type(struct soap *soap, const char *tag, xsd__base64Binary **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xsd__base64Binary **)soap_malloc(soap, sizeof(xsd__base64Binary *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_wcxs__RawKey256Type(soap, tag, *a, type))) + return NULL; + } + else + { a = (xsd__base64Binary **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__RawKey256Type, sizeof(xsd__base64Binary), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__PassPhrase63Type(struct soap *soap, std::string *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__PassPhrase63Type)) + soap_serialize_wcxs__PassPhrase63Type(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__PassPhrase63Type(struct soap *soap, std::string *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__PassPhrase63Type); + if (soap_out_PointerTowcxs__PassPhrase63Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__PassPhrase63Type(struct soap *soap, const char *tag, int id, std::string *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__PassPhrase63Type); + if (id < 0) + return soap->error; + return soap_out_wcxs__PassPhrase63Type(soap, tag, id, *a, type); +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTowcxs__PassPhrase63Type(struct soap *soap, std::string **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__PassPhrase63Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTowcxs__PassPhrase63Type(struct soap *soap, const char *tag, std::string **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (std::string **)soap_malloc(soap, sizeof(std::string *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_wcxs__PassPhrase63Type(soap, tag, *a, type))) + return NULL; + } + else + { a = (std::string **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__PassPhrase63Type, sizeof(std::string), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__WEP128Type(struct soap *soap, wcxs__WEP128Type *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__WEP128Type)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__WEP128Type(struct soap *soap, wcxs__WEP128Type *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__WEP128Type); + if (soap_out_PointerTowcxs__WEP128Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__WEP128Type(struct soap *soap, const char *tag, int id, wcxs__WEP128Type *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__WEP128Type); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__WEP128Type ** SOAP_FMAC4 soap_get_PointerTowcxs__WEP128Type(struct soap *soap, wcxs__WEP128Type **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__WEP128Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__WEP128Type ** SOAP_FMAC4 soap_in_PointerTowcxs__WEP128Type(struct soap *soap, const char *tag, wcxs__WEP128Type **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__WEP128Type **)soap_malloc(soap, sizeof(wcxs__WEP128Type *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__WEP128Type *)soap_instantiate_wcxs__WEP128Type(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__WEP128Type **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__WEP128Type, sizeof(wcxs__WEP128Type), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__WEP64Type(struct soap *soap, wcxs__WEP64Type *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__WEP64Type)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__WEP64Type(struct soap *soap, wcxs__WEP64Type *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__WEP64Type); + if (soap_out_PointerTowcxs__WEP64Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__WEP64Type(struct soap *soap, const char *tag, int id, wcxs__WEP64Type *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__WEP64Type); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 wcxs__WEP64Type ** SOAP_FMAC4 soap_get_PointerTowcxs__WEP64Type(struct soap *soap, wcxs__WEP64Type **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__WEP64Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 wcxs__WEP64Type ** SOAP_FMAC4 soap_in_PointerTowcxs__WEP64Type(struct soap *soap, const char *tag, wcxs__WEP64Type **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (wcxs__WEP64Type **)soap_malloc(soap, sizeof(wcxs__WEP64Type *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (wcxs__WEP64Type *)soap_instantiate_wcxs__WEP64Type(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (wcxs__WEP64Type **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__WEP64Type, sizeof(wcxs__WEP64Type), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__RawKey128Type(struct soap *soap, xsd__base64Binary *const*a) +{ + if (*a) + soap_serialize_wcxs__RawKey128Type(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__RawKey128Type(struct soap *soap, xsd__base64Binary *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__RawKey128Type); + if (soap_out_PointerTowcxs__RawKey128Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__RawKey128Type(struct soap *soap, const char *tag, int id, xsd__base64Binary *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, (struct soap_array*)&(*a)->__ptr, 1, type, SOAP_TYPE_wcxs__RawKey128Type); + if (id < 0) + return soap->error; + return soap_out_wcxs__RawKey128Type(soap, tag, id, *a, type); +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerTowcxs__RawKey128Type(struct soap *soap, xsd__base64Binary **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__RawKey128Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerTowcxs__RawKey128Type(struct soap *soap, const char *tag, xsd__base64Binary **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xsd__base64Binary **)soap_malloc(soap, sizeof(xsd__base64Binary *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_wcxs__RawKey128Type(soap, tag, *a, type))) + return NULL; + } + else + { a = (xsd__base64Binary **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__RawKey128Type, sizeof(xsd__base64Binary), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__PassPhraseWEP128Type(struct soap *soap, std::string *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__PassPhraseWEP128Type)) + soap_serialize_wcxs__PassPhraseWEP128Type(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__PassPhraseWEP128Type(struct soap *soap, std::string *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__PassPhraseWEP128Type); + if (soap_out_PointerTowcxs__PassPhraseWEP128Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__PassPhraseWEP128Type(struct soap *soap, const char *tag, int id, std::string *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__PassPhraseWEP128Type); + if (id < 0) + return soap->error; + return soap_out_wcxs__PassPhraseWEP128Type(soap, tag, id, *a, type); +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTowcxs__PassPhraseWEP128Type(struct soap *soap, std::string **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__PassPhraseWEP128Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTowcxs__PassPhraseWEP128Type(struct soap *soap, const char *tag, std::string **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (std::string **)soap_malloc(soap, sizeof(std::string *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_wcxs__PassPhraseWEP128Type(soap, tag, *a, type))) + return NULL; + } + else + { a = (std::string **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__PassPhraseWEP128Type, sizeof(std::string), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__RawKey64Type(struct soap *soap, xsd__base64Binary *const*a) +{ + if (*a) + soap_serialize_wcxs__RawKey64Type(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__RawKey64Type(struct soap *soap, xsd__base64Binary *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__RawKey64Type); + if (soap_out_PointerTowcxs__RawKey64Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__RawKey64Type(struct soap *soap, const char *tag, int id, xsd__base64Binary *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, (struct soap_array*)&(*a)->__ptr, 1, type, SOAP_TYPE_wcxs__RawKey64Type); + if (id < 0) + return soap->error; + return soap_out_wcxs__RawKey64Type(soap, tag, id, *a, type); +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerTowcxs__RawKey64Type(struct soap *soap, xsd__base64Binary **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__RawKey64Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerTowcxs__RawKey64Type(struct soap *soap, const char *tag, xsd__base64Binary **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xsd__base64Binary **)soap_malloc(soap, sizeof(xsd__base64Binary *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_wcxs__RawKey64Type(soap, tag, *a, type))) + return NULL; + } + else + { a = (xsd__base64Binary **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__RawKey64Type, sizeof(xsd__base64Binary), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTowcxs__PassPhrase5Type(struct soap *soap, std::string *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_wcxs__PassPhrase5Type)) + soap_serialize_wcxs__PassPhrase5Type(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTowcxs__PassPhrase5Type(struct soap *soap, std::string *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTowcxs__PassPhrase5Type); + if (soap_out_PointerTowcxs__PassPhrase5Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTowcxs__PassPhrase5Type(struct soap *soap, const char *tag, int id, std::string *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_wcxs__PassPhrase5Type); + if (id < 0) + return soap->error; + return soap_out_wcxs__PassPhrase5Type(soap, tag, id, *a, type); +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTowcxs__PassPhrase5Type(struct soap *soap, std::string **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTowcxs__PassPhrase5Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTowcxs__PassPhrase5Type(struct soap *soap, const char *tag, std::string **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (std::string **)soap_malloc(soap, sizeof(std::string *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_wcxs__PassPhrase5Type(soap, tag, *a, type))) + return NULL; + } + else + { a = (std::string **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_wcxs__PassPhrase5Type, sizeof(std::string), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTorci__OemParametersType(struct soap *soap, unsigned short *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_rci__OemParametersType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTorci__OemParametersType(struct soap *soap, unsigned short *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTorci__OemParametersType); + if (soap_out_PointerTorci__OemParametersType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTorci__OemParametersType(struct soap *soap, const char *tag, int id, unsigned short *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_rci__OemParametersType); + if (id < 0) + return soap->error; + return soap_out_rci__OemParametersType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_get_PointerTorci__OemParametersType(struct soap *soap, unsigned short **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTorci__OemParametersType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_in_PointerTorci__OemParametersType(struct soap *soap, const char *tag, unsigned short **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned short **)soap_malloc(soap, sizeof(unsigned short *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_rci__OemParametersType(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned short **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_rci__OemParametersType, sizeof(unsigned short), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTorci__BootOptionsType(struct soap *soap, unsigned short *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_rci__BootOptionsType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTorci__BootOptionsType(struct soap *soap, unsigned short *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTorci__BootOptionsType); + if (soap_out_PointerTorci__BootOptionsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTorci__BootOptionsType(struct soap *soap, const char *tag, int id, unsigned short *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_rci__BootOptionsType); + if (id < 0) + return soap->error; + return soap_out_rci__BootOptionsType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_get_PointerTorci__BootOptionsType(struct soap *soap, unsigned short **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTorci__BootOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_in_PointerTorci__BootOptionsType(struct soap *soap, const char *tag, unsigned short **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned short **)soap_malloc(soap, sizeof(unsigned short *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_rci__BootOptionsType(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned short **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_rci__BootOptionsType, sizeof(unsigned short), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTorci__SpecialCommandParameterType(struct soap *soap, unsigned short *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_rci__SpecialCommandParameterType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTorci__SpecialCommandParameterType(struct soap *soap, unsigned short *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTorci__SpecialCommandParameterType); + if (soap_out_PointerTorci__SpecialCommandParameterType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTorci__SpecialCommandParameterType(struct soap *soap, const char *tag, int id, unsigned short *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_rci__SpecialCommandParameterType); + if (id < 0) + return soap->error; + return soap_out_rci__SpecialCommandParameterType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_get_PointerTorci__SpecialCommandParameterType(struct soap *soap, unsigned short **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTorci__SpecialCommandParameterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_in_PointerTorci__SpecialCommandParameterType(struct soap *soap, const char *tag, unsigned short **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned short **)soap_malloc(soap, sizeof(unsigned short *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_rci__SpecialCommandParameterType(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned short **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_rci__SpecialCommandParameterType, sizeof(unsigned short), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTorci__SpecialCommandType(struct soap *soap, enum rci__SpecialCommandType *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_rci__SpecialCommandType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTorci__SpecialCommandType(struct soap *soap, enum rci__SpecialCommandType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTorci__SpecialCommandType); + if (soap_out_PointerTorci__SpecialCommandType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTorci__SpecialCommandType(struct soap *soap, const char *tag, int id, enum rci__SpecialCommandType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_rci__SpecialCommandType); + if (id < 0) + return soap->error; + return soap_out_rci__SpecialCommandType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 enum rci__SpecialCommandType ** SOAP_FMAC4 soap_get_PointerTorci__SpecialCommandType(struct soap *soap, enum rci__SpecialCommandType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTorci__SpecialCommandType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 enum rci__SpecialCommandType ** SOAP_FMAC4 soap_in_PointerTorci__SpecialCommandType(struct soap *soap, const char *tag, enum rci__SpecialCommandType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (enum rci__SpecialCommandType **)soap_malloc(soap, sizeof(enum rci__SpecialCommandType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_rci__SpecialCommandType(soap, tag, *a, type))) + return NULL; + } + else + { a = (enum rci__SpecialCommandType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_rci__SpecialCommandType, sizeof(enum rci__SpecialCommandType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToinf__IderSessionLogEntryType(struct soap *soap, inf__IderSessionLogEntryType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_inf__IderSessionLogEntryType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToinf__IderSessionLogEntryType(struct soap *soap, inf__IderSessionLogEntryType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToinf__IderSessionLogEntryType); + if (soap_out_PointerToinf__IderSessionLogEntryType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToinf__IderSessionLogEntryType(struct soap *soap, const char *tag, int id, inf__IderSessionLogEntryType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_inf__IderSessionLogEntryType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 inf__IderSessionLogEntryType ** SOAP_FMAC4 soap_get_PointerToinf__IderSessionLogEntryType(struct soap *soap, inf__IderSessionLogEntryType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToinf__IderSessionLogEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 inf__IderSessionLogEntryType ** SOAP_FMAC4 soap_in_PointerToinf__IderSessionLogEntryType(struct soap *soap, const char *tag, inf__IderSessionLogEntryType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (inf__IderSessionLogEntryType **)soap_malloc(soap, sizeof(inf__IderSessionLogEntryType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (inf__IderSessionLogEntryType *)soap_instantiate_inf__IderSessionLogEntryType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (inf__IderSessionLogEntryType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_inf__IderSessionLogEntryType, sizeof(inf__IderSessionLogEntryType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToinf__FirmwareVersionType(struct soap *soap, inf__FirmwareVersionType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_inf__FirmwareVersionType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToinf__FirmwareVersionType(struct soap *soap, inf__FirmwareVersionType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToinf__FirmwareVersionType); + if (soap_out_PointerToinf__FirmwareVersionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToinf__FirmwareVersionType(struct soap *soap, const char *tag, int id, inf__FirmwareVersionType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_inf__FirmwareVersionType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 inf__FirmwareVersionType ** SOAP_FMAC4 soap_get_PointerToinf__FirmwareVersionType(struct soap *soap, inf__FirmwareVersionType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToinf__FirmwareVersionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 inf__FirmwareVersionType ** SOAP_FMAC4 soap_in_PointerToinf__FirmwareVersionType(struct soap *soap, const char *tag, inf__FirmwareVersionType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (inf__FirmwareVersionType **)soap_malloc(soap, sizeof(inf__FirmwareVersionType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (inf__FirmwareVersionType *)soap_instantiate_inf__FirmwareVersionType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (inf__FirmwareVersionType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_inf__FirmwareVersionType, sizeof(inf__FirmwareVersionType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToidr__IderSessionLogEntryType(struct soap *soap, idr__IderSessionLogEntryType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_idr__IderSessionLogEntryType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToidr__IderSessionLogEntryType(struct soap *soap, idr__IderSessionLogEntryType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToidr__IderSessionLogEntryType); + if (soap_out_PointerToidr__IderSessionLogEntryType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToidr__IderSessionLogEntryType(struct soap *soap, const char *tag, int id, idr__IderSessionLogEntryType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_idr__IderSessionLogEntryType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 idr__IderSessionLogEntryType ** SOAP_FMAC4 soap_get_PointerToidr__IderSessionLogEntryType(struct soap *soap, idr__IderSessionLogEntryType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToidr__IderSessionLogEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 idr__IderSessionLogEntryType ** SOAP_FMAC4 soap_in_PointerToidr__IderSessionLogEntryType(struct soap *soap, const char *tag, idr__IderSessionLogEntryType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (idr__IderSessionLogEntryType **)soap_malloc(soap, sizeof(idr__IderSessionLogEntryType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (idr__IderSessionLogEntryType *)soap_instantiate_idr__IderSessionLogEntryType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (idr__IderSessionLogEntryType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_idr__IderSessionLogEntryType, sizeof(idr__IderSessionLogEntryType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapl__GUID(struct soap *soap, apl__GUID *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_apl__GUID)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapl__GUID(struct soap *soap, apl__GUID *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToapl__GUID); + if (soap_out_PointerToapl__GUID(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapl__GUID(struct soap *soap, const char *tag, int id, apl__GUID *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_apl__GUID); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 apl__GUID ** SOAP_FMAC4 soap_get_PointerToapl__GUID(struct soap *soap, apl__GUID **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToapl__GUID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 apl__GUID ** SOAP_FMAC4 soap_in_PointerToapl__GUID(struct soap *soap, const char *tag, apl__GUID **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (apl__GUID **)soap_malloc(soap, sizeof(apl__GUID *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (apl__GUID *)soap_instantiate_apl__GUID(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (apl__GUID **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_apl__GUID, sizeof(apl__GUID), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__AgentPresenceCapabilitiesType(struct soap *soap, apr__AgentPresenceCapabilitiesType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_apr__AgentPresenceCapabilitiesType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__AgentPresenceCapabilitiesType(struct soap *soap, apr__AgentPresenceCapabilitiesType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToapr__AgentPresenceCapabilitiesType); + if (soap_out_PointerToapr__AgentPresenceCapabilitiesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__AgentPresenceCapabilitiesType(struct soap *soap, const char *tag, int id, apr__AgentPresenceCapabilitiesType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_apr__AgentPresenceCapabilitiesType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType ** SOAP_FMAC4 soap_get_PointerToapr__AgentPresenceCapabilitiesType(struct soap *soap, apr__AgentPresenceCapabilitiesType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToapr__AgentPresenceCapabilitiesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 apr__AgentPresenceCapabilitiesType ** SOAP_FMAC4 soap_in_PointerToapr__AgentPresenceCapabilitiesType(struct soap *soap, const char *tag, apr__AgentPresenceCapabilitiesType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (apr__AgentPresenceCapabilitiesType **)soap_malloc(soap, sizeof(apr__AgentPresenceCapabilitiesType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (apr__AgentPresenceCapabilitiesType *)soap_instantiate_apr__AgentPresenceCapabilitiesType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (apr__AgentPresenceCapabilitiesType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_apr__AgentPresenceCapabilitiesType, sizeof(apr__AgentPresenceCapabilitiesType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, apr__CircuitBreakerHardwarePolicyType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, apr__CircuitBreakerHardwarePolicyType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToapr__CircuitBreakerHardwarePolicyType); + if (soap_out_PointerToapr__CircuitBreakerHardwarePolicyType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, int id, apr__CircuitBreakerHardwarePolicyType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType ** SOAP_FMAC4 soap_get_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, apr__CircuitBreakerHardwarePolicyType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToapr__CircuitBreakerHardwarePolicyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 apr__CircuitBreakerHardwarePolicyType ** SOAP_FMAC4 soap_in_PointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, apr__CircuitBreakerHardwarePolicyType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (apr__CircuitBreakerHardwarePolicyType **)soap_malloc(soap, sizeof(apr__CircuitBreakerHardwarePolicyType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (apr__CircuitBreakerHardwarePolicyType *)soap_instantiate_apr__CircuitBreakerHardwarePolicyType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (apr__CircuitBreakerHardwarePolicyType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType, sizeof(apr__CircuitBreakerHardwarePolicyType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__ConsoleWatchdogActionType(struct soap *soap, apr__ConsoleWatchdogActionType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_apr__ConsoleWatchdogActionType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__ConsoleWatchdogActionType(struct soap *soap, apr__ConsoleWatchdogActionType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToapr__ConsoleWatchdogActionType); + if (soap_out_PointerToapr__ConsoleWatchdogActionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__ConsoleWatchdogActionType(struct soap *soap, const char *tag, int id, apr__ConsoleWatchdogActionType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_apr__ConsoleWatchdogActionType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 apr__ConsoleWatchdogActionType ** SOAP_FMAC4 soap_get_PointerToapr__ConsoleWatchdogActionType(struct soap *soap, apr__ConsoleWatchdogActionType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToapr__ConsoleWatchdogActionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 apr__ConsoleWatchdogActionType ** SOAP_FMAC4 soap_in_PointerToapr__ConsoleWatchdogActionType(struct soap *soap, const char *tag, apr__ConsoleWatchdogActionType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (apr__ConsoleWatchdogActionType **)soap_malloc(soap, sizeof(apr__ConsoleWatchdogActionType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (apr__ConsoleWatchdogActionType *)soap_instantiate_apr__ConsoleWatchdogActionType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (apr__ConsoleWatchdogActionType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_apr__ConsoleWatchdogActionType, sizeof(apr__ConsoleWatchdogActionType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__ConsoleWatchdogEntryType(struct soap *soap, apr__ConsoleWatchdogEntryType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_apr__ConsoleWatchdogEntryType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__ConsoleWatchdogEntryType(struct soap *soap, apr__ConsoleWatchdogEntryType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToapr__ConsoleWatchdogEntryType); + if (soap_out_PointerToapr__ConsoleWatchdogEntryType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__ConsoleWatchdogEntryType(struct soap *soap, const char *tag, int id, apr__ConsoleWatchdogEntryType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_apr__ConsoleWatchdogEntryType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 apr__ConsoleWatchdogEntryType ** SOAP_FMAC4 soap_get_PointerToapr__ConsoleWatchdogEntryType(struct soap *soap, apr__ConsoleWatchdogEntryType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToapr__ConsoleWatchdogEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 apr__ConsoleWatchdogEntryType ** SOAP_FMAC4 soap_in_PointerToapr__ConsoleWatchdogEntryType(struct soap *soap, const char *tag, apr__ConsoleWatchdogEntryType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (apr__ConsoleWatchdogEntryType **)soap_malloc(soap, sizeof(apr__ConsoleWatchdogEntryType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (apr__ConsoleWatchdogEntryType *)soap_instantiate_apr__ConsoleWatchdogEntryType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (apr__ConsoleWatchdogEntryType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_apr__ConsoleWatchdogEntryType, sizeof(apr__ConsoleWatchdogEntryType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__CbActionType(struct soap *soap, enum apr__CbActionType *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_apr__CbActionType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__CbActionType(struct soap *soap, enum apr__CbActionType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToapr__CbActionType); + if (soap_out_PointerToapr__CbActionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__CbActionType(struct soap *soap, const char *tag, int id, enum apr__CbActionType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_apr__CbActionType); + if (id < 0) + return soap->error; + return soap_out_apr__CbActionType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 enum apr__CbActionType ** SOAP_FMAC4 soap_get_PointerToapr__CbActionType(struct soap *soap, enum apr__CbActionType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToapr__CbActionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 enum apr__CbActionType ** SOAP_FMAC4 soap_in_PointerToapr__CbActionType(struct soap *soap, const char *tag, enum apr__CbActionType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (enum apr__CbActionType **)soap_malloc(soap, sizeof(enum apr__CbActionType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_apr__CbActionType(soap, tag, *a, type))) + return NULL; + } + else + { a = (enum apr__CbActionType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_apr__CbActionType, sizeof(enum apr__CbActionType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToapr__GUID(struct soap *soap, apr__GUID *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_apr__GUID)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToapr__GUID(struct soap *soap, apr__GUID *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToapr__GUID); + if (soap_out_PointerToapr__GUID(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToapr__GUID(struct soap *soap, const char *tag, int id, apr__GUID *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_apr__GUID); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 apr__GUID ** SOAP_FMAC4 soap_get_PointerToapr__GUID(struct soap *soap, apr__GUID **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToapr__GUID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 apr__GUID ** SOAP_FMAC4 soap_in_PointerToapr__GUID(struct soap *soap, const char *tag, apr__GUID **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (apr__GUID **)soap_malloc(soap, sizeof(apr__GUID *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (apr__GUID *)soap_instantiate_apr__GUID(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (apr__GUID **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_apr__GUID, sizeof(apr__GUID), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTohwa__AssetDataArrayType(struct soap *soap, hwa__AssetDataArrayType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_hwa__AssetDataArrayType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTohwa__AssetDataArrayType(struct soap *soap, hwa__AssetDataArrayType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTohwa__AssetDataArrayType); + if (soap_out_PointerTohwa__AssetDataArrayType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTohwa__AssetDataArrayType(struct soap *soap, const char *tag, int id, hwa__AssetDataArrayType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_hwa__AssetDataArrayType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 hwa__AssetDataArrayType ** SOAP_FMAC4 soap_get_PointerTohwa__AssetDataArrayType(struct soap *soap, hwa__AssetDataArrayType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTohwa__AssetDataArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 hwa__AssetDataArrayType ** SOAP_FMAC4 soap_in_PointerTohwa__AssetDataArrayType(struct soap *soap, const char *tag, hwa__AssetDataArrayType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (hwa__AssetDataArrayType **)soap_malloc(soap, sizeof(hwa__AssetDataArrayType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (hwa__AssetDataArrayType *)soap_instantiate_hwa__AssetDataArrayType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (hwa__AssetDataArrayType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_hwa__AssetDataArrayType, sizeof(hwa__AssetDataArrayType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTohwa__AssetTypeArrayType(struct soap *soap, hwa__AssetTypeArrayType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_hwa__AssetTypeArrayType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTohwa__AssetTypeArrayType(struct soap *soap, hwa__AssetTypeArrayType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTohwa__AssetTypeArrayType); + if (soap_out_PointerTohwa__AssetTypeArrayType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTohwa__AssetTypeArrayType(struct soap *soap, const char *tag, int id, hwa__AssetTypeArrayType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_hwa__AssetTypeArrayType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 hwa__AssetTypeArrayType ** SOAP_FMAC4 soap_get_PointerTohwa__AssetTypeArrayType(struct soap *soap, hwa__AssetTypeArrayType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTohwa__AssetTypeArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 hwa__AssetTypeArrayType ** SOAP_FMAC4 soap_in_PointerTohwa__AssetTypeArrayType(struct soap *soap, const char *tag, hwa__AssetTypeArrayType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (hwa__AssetTypeArrayType **)soap_malloc(soap, sizeof(hwa__AssetTypeArrayType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (hwa__AssetTypeArrayType *)soap_instantiate_hwa__AssetTypeArrayType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (hwa__AssetTypeArrayType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_hwa__AssetTypeArrayType, sizeof(hwa__AssetTypeArrayType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTohwa__GUID(struct soap *soap, hwa__GUID *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_hwa__GUID)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTohwa__GUID(struct soap *soap, hwa__GUID *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTohwa__GUID); + if (soap_out_PointerTohwa__GUID(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTohwa__GUID(struct soap *soap, const char *tag, int id, hwa__GUID *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_hwa__GUID); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 hwa__GUID ** SOAP_FMAC4 soap_get_PointerTohwa__GUID(struct soap *soap, hwa__GUID **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTohwa__GUID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 hwa__GUID ** SOAP_FMAC4 soap_in_PointerTohwa__GUID(struct soap *soap, const char *tag, hwa__GUID **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (hwa__GUID **)soap_malloc(soap, sizeof(hwa__GUID *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (hwa__GUID *)soap_instantiate_hwa__GUID(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (hwa__GUID **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_hwa__GUID, sizeof(hwa__GUID), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxsd__base64Binary(struct soap *soap, xsd__base64Binary *const*a) +{ + if (*a) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxsd__base64Binary(struct soap *soap, xsd__base64Binary *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxsd__base64Binary); + if (soap_out_PointerToxsd__base64Binary(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxsd__base64Binary(struct soap *soap, const char *tag, int id, xsd__base64Binary *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, (struct soap_array*)&(*a)->__ptr, 1, type, SOAP_TYPE_xsd__base64Binary); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerToxsd__base64Binary(struct soap *soap, xsd__base64Binary **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxsd__base64Binary(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerToxsd__base64Binary(struct soap *soap, const char *tag, xsd__base64Binary **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xsd__base64Binary **)soap_malloc(soap, sizeof(xsd__base64Binary *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xsd__base64Binary *)soap_instantiate_xsd__base64Binary(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xsd__base64Binary **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xsd__base64Binary, sizeof(xsd__base64Binary), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTohwa__AssetDataType(struct soap *soap, hwa__AssetDataType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_hwa__AssetDataType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTohwa__AssetDataType(struct soap *soap, hwa__AssetDataType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTohwa__AssetDataType); + if (soap_out_PointerTohwa__AssetDataType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTohwa__AssetDataType(struct soap *soap, const char *tag, int id, hwa__AssetDataType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_hwa__AssetDataType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 hwa__AssetDataType ** SOAP_FMAC4 soap_get_PointerTohwa__AssetDataType(struct soap *soap, hwa__AssetDataType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTohwa__AssetDataType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 hwa__AssetDataType ** SOAP_FMAC4 soap_in_PointerTohwa__AssetDataType(struct soap *soap, const char *tag, hwa__AssetDataType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (hwa__AssetDataType **)soap_malloc(soap, sizeof(hwa__AssetDataType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (hwa__AssetDataType *)soap_instantiate_hwa__AssetDataType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (hwa__AssetDataType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_hwa__AssetDataType, sizeof(hwa__AssetDataType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__BlockedPortInfoType(struct soap *soap, cb__BlockedPortInfoType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__BlockedPortInfoType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__BlockedPortInfoType(struct soap *soap, cb__BlockedPortInfoType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__BlockedPortInfoType); + if (soap_out_PointerTocb__BlockedPortInfoType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__BlockedPortInfoType(struct soap *soap, const char *tag, int id, cb__BlockedPortInfoType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__BlockedPortInfoType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__BlockedPortInfoType ** SOAP_FMAC4 soap_get_PointerTocb__BlockedPortInfoType(struct soap *soap, cb__BlockedPortInfoType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__BlockedPortInfoType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__BlockedPortInfoType ** SOAP_FMAC4 soap_in_PointerTocb__BlockedPortInfoType(struct soap *soap, const char *tag, cb__BlockedPortInfoType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__BlockedPortInfoType **)soap_malloc(soap, sizeof(cb__BlockedPortInfoType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__BlockedPortInfoType *)soap_instantiate_cb__BlockedPortInfoType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__BlockedPortInfoType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__BlockedPortInfoType, sizeof(cb__BlockedPortInfoType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__HcbTriggerReasonType(struct soap *soap, enum cb__HcbTriggerReasonType *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_cb__HcbTriggerReasonType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__HcbTriggerReasonType(struct soap *soap, enum cb__HcbTriggerReasonType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__HcbTriggerReasonType); + if (soap_out_PointerTocb__HcbTriggerReasonType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__HcbTriggerReasonType(struct soap *soap, const char *tag, int id, enum cb__HcbTriggerReasonType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__HcbTriggerReasonType); + if (id < 0) + return soap->error; + return soap_out_cb__HcbTriggerReasonType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 enum cb__HcbTriggerReasonType ** SOAP_FMAC4 soap_get_PointerTocb__HcbTriggerReasonType(struct soap *soap, enum cb__HcbTriggerReasonType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__HcbTriggerReasonType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 enum cb__HcbTriggerReasonType ** SOAP_FMAC4 soap_in_PointerTocb__HcbTriggerReasonType(struct soap *soap, const char *tag, enum cb__HcbTriggerReasonType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (enum cb__HcbTriggerReasonType **)soap_malloc(soap, sizeof(enum cb__HcbTriggerReasonType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_cb__HcbTriggerReasonType(soap, tag, *a, type))) + return NULL; + } + else + { a = (enum cb__HcbTriggerReasonType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__HcbTriggerReasonType, sizeof(enum cb__HcbTriggerReasonType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__TimeType(struct soap *soap, unsigned int *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_cb__TimeType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__TimeType(struct soap *soap, unsigned int *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__TimeType); + if (soap_out_PointerTocb__TimeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__TimeType(struct soap *soap, const char *tag, int id, unsigned int *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__TimeType); + if (id < 0) + return soap->error; + return soap_out_cb__TimeType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_get_PointerTocb__TimeType(struct soap *soap, unsigned int **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__TimeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTocb__TimeType(struct soap *soap, const char *tag, unsigned int **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned int **)soap_malloc(soap, sizeof(unsigned int *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_cb__TimeType(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned int **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__TimeType, sizeof(unsigned int), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__HcbOptionsType(struct soap *soap, cb__HcbOptionsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__HcbOptionsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__HcbOptionsType(struct soap *soap, cb__HcbOptionsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__HcbOptionsType); + if (soap_out_PointerTocb__HcbOptionsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__HcbOptionsType(struct soap *soap, const char *tag, int id, cb__HcbOptionsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__HcbOptionsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__HcbOptionsType ** SOAP_FMAC4 soap_get_PointerTocb__HcbOptionsType(struct soap *soap, cb__HcbOptionsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__HcbOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__HcbOptionsType ** SOAP_FMAC4 soap_in_PointerTocb__HcbOptionsType(struct soap *soap, const char *tag, cb__HcbOptionsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__HcbOptionsType **)soap_malloc(soap, sizeof(cb__HcbOptionsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__HcbOptionsType *)soap_instantiate_cb__HcbOptionsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__HcbOptionsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__HcbOptionsType, sizeof(cb__HcbOptionsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, cb__CircuitBreakerCapabilitiesType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerCapabilitiesType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, cb__CircuitBreakerCapabilitiesType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerCapabilitiesType); + if (soap_out_PointerTocb__CircuitBreakerCapabilitiesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerCapabilitiesType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerCapabilitiesType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, cb__CircuitBreakerCapabilitiesType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerCapabilitiesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerCapabilitiesType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, const char *tag, cb__CircuitBreakerCapabilitiesType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerCapabilitiesType **)soap_malloc(soap, sizeof(cb__CircuitBreakerCapabilitiesType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerCapabilitiesType *)soap_instantiate_cb__CircuitBreakerCapabilitiesType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerCapabilitiesType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerCapabilitiesType, sizeof(cb__CircuitBreakerCapabilitiesType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, cb__CircuitBreakerFilterInfoType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerFilterInfoType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, cb__CircuitBreakerFilterInfoType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerFilterInfoType); + if (soap_out_PointerTocb__CircuitBreakerFilterInfoType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerFilterInfoType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerFilterInfoType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, cb__CircuitBreakerFilterInfoType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerFilterInfoType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerFilterInfoType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, const char *tag, cb__CircuitBreakerFilterInfoType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerFilterInfoType **)soap_malloc(soap, sizeof(cb__CircuitBreakerFilterInfoType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerFilterInfoType *)soap_instantiate_cb__CircuitBreakerFilterInfoType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerFilterInfoType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerFilterInfoType, sizeof(cb__CircuitBreakerFilterInfoType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, cb__CircuitBreakerFilterStatisticsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, cb__CircuitBreakerFilterStatisticsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerFilterStatisticsType); + if (soap_out_PointerTocb__CircuitBreakerFilterStatisticsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerFilterStatisticsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, cb__CircuitBreakerFilterStatisticsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerFilterStatisticsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerFilterStatisticsType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, const char *tag, cb__CircuitBreakerFilterStatisticsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerFilterStatisticsType **)soap_malloc(soap, sizeof(cb__CircuitBreakerFilterStatisticsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerFilterStatisticsType *)soap_instantiate_cb__CircuitBreakerFilterStatisticsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerFilterStatisticsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType, sizeof(cb__CircuitBreakerFilterStatisticsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerApplicationType(struct soap *soap, enum cb__CircuitBreakerApplicationType *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerApplicationType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerApplicationType(struct soap *soap, enum cb__CircuitBreakerApplicationType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerApplicationType); + if (soap_out_PointerTocb__CircuitBreakerApplicationType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerApplicationType(struct soap *soap, const char *tag, int id, enum cb__CircuitBreakerApplicationType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerApplicationType); + if (id < 0) + return soap->error; + return soap_out_cb__CircuitBreakerApplicationType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 enum cb__CircuitBreakerApplicationType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerApplicationType(struct soap *soap, enum cb__CircuitBreakerApplicationType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerApplicationType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 enum cb__CircuitBreakerApplicationType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerApplicationType(struct soap *soap, const char *tag, enum cb__CircuitBreakerApplicationType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (enum cb__CircuitBreakerApplicationType **)soap_malloc(soap, sizeof(enum cb__CircuitBreakerApplicationType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_cb__CircuitBreakerApplicationType(soap, tag, *a, type))) + return NULL; + } + else + { a = (enum cb__CircuitBreakerApplicationType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerApplicationType, sizeof(enum cb__CircuitBreakerApplicationType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, cb__CircuitBreakerHardwarePolicyType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, cb__CircuitBreakerHardwarePolicyType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerHardwarePolicyType); + if (soap_out_PointerTocb__CircuitBreakerHardwarePolicyType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerHardwarePolicyType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, cb__CircuitBreakerHardwarePolicyType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerHardwarePolicyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerHardwarePolicyType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, cb__CircuitBreakerHardwarePolicyType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerHardwarePolicyType **)soap_malloc(soap, sizeof(cb__CircuitBreakerHardwarePolicyType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerHardwarePolicyType *)soap_instantiate_cb__CircuitBreakerHardwarePolicyType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerHardwarePolicyType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType, sizeof(cb__CircuitBreakerHardwarePolicyType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, cb__CircuitBreakerPolicyInfoType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerPolicyInfoType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, cb__CircuitBreakerPolicyInfoType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerPolicyInfoType); + if (soap_out_PointerTocb__CircuitBreakerPolicyInfoType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerPolicyInfoType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerPolicyInfoType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, cb__CircuitBreakerPolicyInfoType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerPolicyInfoType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyInfoType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, const char *tag, cb__CircuitBreakerPolicyInfoType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerPolicyInfoType **)soap_malloc(soap, sizeof(cb__CircuitBreakerPolicyInfoType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerPolicyInfoType *)soap_instantiate_cb__CircuitBreakerPolicyInfoType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerPolicyInfoType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerPolicyInfoType, sizeof(cb__CircuitBreakerPolicyInfoType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__TimedCounterType(struct soap *soap, cb__TimedCounterType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__TimedCounterType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__TimedCounterType(struct soap *soap, cb__TimedCounterType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__TimedCounterType); + if (soap_out_PointerTocb__TimedCounterType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__TimedCounterType(struct soap *soap, const char *tag, int id, cb__TimedCounterType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__TimedCounterType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__TimedCounterType ** SOAP_FMAC4 soap_get_PointerTocb__TimedCounterType(struct soap *soap, cb__TimedCounterType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__TimedCounterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__TimedCounterType ** SOAP_FMAC4 soap_in_PointerTocb__TimedCounterType(struct soap *soap, const char *tag, cb__TimedCounterType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__TimedCounterType **)soap_malloc(soap, sizeof(cb__TimedCounterType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__TimedCounterType *)soap_instantiate_cb__TimedCounterType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__TimedCounterType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__TimedCounterType, sizeof(cb__TimedCounterType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerFilterType(struct soap *soap, cb__CircuitBreakerFilterType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerFilterType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerFilterType(struct soap *soap, cb__CircuitBreakerFilterType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerFilterType); + if (soap_out_PointerTocb__CircuitBreakerFilterType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerFilterType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerFilterType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerFilterType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerFilterType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerFilterType(struct soap *soap, cb__CircuitBreakerFilterType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerFilterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerFilterType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerFilterType(struct soap *soap, const char *tag, cb__CircuitBreakerFilterType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerFilterType **)soap_malloc(soap, sizeof(cb__CircuitBreakerFilterType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerFilterType *)soap_instantiate_cb__CircuitBreakerFilterType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerFilterType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerFilterType, sizeof(cb__CircuitBreakerFilterType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketType(struct soap *soap, cb__CircuitBreakerPacketType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerPacketType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketType(struct soap *soap, cb__CircuitBreakerPacketType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerPacketType); + if (soap_out_PointerTocb__CircuitBreakerPacketType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerPacketType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerPacketType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketType(struct soap *soap, cb__CircuitBreakerPacketType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerPacketType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerPacketType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerPacketType **)soap_malloc(soap, sizeof(cb__CircuitBreakerPacketType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerPacketType *)soap_instantiate_cb__CircuitBreakerPacketType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerPacketType, sizeof(cb__CircuitBreakerPacketType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketETHType(struct soap *soap, cb__CircuitBreakerPacketETHType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerPacketETHType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketETHType(struct soap *soap, cb__CircuitBreakerPacketETHType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerPacketETHType); + if (soap_out_PointerTocb__CircuitBreakerPacketETHType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketETHType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerPacketETHType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerPacketETHType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketETHType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketETHType(struct soap *soap, cb__CircuitBreakerPacketETHType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerPacketETHType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerPacketETHType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketETHType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketETHType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerPacketETHType **)soap_malloc(soap, sizeof(cb__CircuitBreakerPacketETHType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerPacketETHType *)soap_instantiate_cb__CircuitBreakerPacketETHType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketETHType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerPacketETHType, sizeof(cb__CircuitBreakerPacketETHType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketIPType(struct soap *soap, cb__CircuitBreakerPacketIPType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerPacketIPType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketIPType(struct soap *soap, cb__CircuitBreakerPacketIPType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerPacketIPType); + if (soap_out_PointerTocb__CircuitBreakerPacketIPType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketIPType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerPacketIPType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerPacketIPType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketIPType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketIPType(struct soap *soap, cb__CircuitBreakerPacketIPType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerPacketIPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerPacketIPType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketIPType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketIPType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerPacketIPType **)soap_malloc(soap, sizeof(cb__CircuitBreakerPacketIPType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerPacketIPType *)soap_instantiate_cb__CircuitBreakerPacketIPType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketIPType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerPacketIPType, sizeof(cb__CircuitBreakerPacketIPType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketUDPType(struct soap *soap, cb__CircuitBreakerPacketUDPType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerPacketUDPType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketUDPType(struct soap *soap, cb__CircuitBreakerPacketUDPType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerPacketUDPType); + if (soap_out_PointerTocb__CircuitBreakerPacketUDPType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketUDPType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerPacketUDPType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerPacketUDPType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketUDPType(struct soap *soap, cb__CircuitBreakerPacketUDPType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerPacketUDPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerPacketUDPType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketUDPType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketUDPType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerPacketUDPType **)soap_malloc(soap, sizeof(cb__CircuitBreakerPacketUDPType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerPacketUDPType *)soap_instantiate_cb__CircuitBreakerPacketUDPType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketUDPType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerPacketUDPType, sizeof(cb__CircuitBreakerPacketUDPType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPacketTCPType(struct soap *soap, cb__CircuitBreakerPacketTCPType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerPacketTCPType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPacketTCPType(struct soap *soap, cb__CircuitBreakerPacketTCPType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerPacketTCPType); + if (soap_out_PointerTocb__CircuitBreakerPacketTCPType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPacketTCPType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerPacketTCPType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerPacketTCPType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPacketTCPType(struct soap *soap, cb__CircuitBreakerPacketTCPType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerPacketTCPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerPacketTCPType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPacketTCPType(struct soap *soap, const char *tag, cb__CircuitBreakerPacketTCPType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerPacketTCPType **)soap_malloc(soap, sizeof(cb__CircuitBreakerPacketTCPType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerPacketTCPType *)soap_instantiate_cb__CircuitBreakerPacketTCPType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerPacketTCPType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerPacketTCPType, sizeof(cb__CircuitBreakerPacketTCPType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap *soap, cb__CircuitBreakerIPLayeredPortType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap *soap, cb__CircuitBreakerIPLayeredPortType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortType); + if (soap_out_PointerTocb__CircuitBreakerIPLayeredPortType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerIPLayeredPortType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap *soap, cb__CircuitBreakerIPLayeredPortType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerIPLayeredPortType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPLayeredPortType(struct soap *soap, const char *tag, cb__CircuitBreakerIPLayeredPortType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerIPLayeredPortType **)soap_malloc(soap, sizeof(cb__CircuitBreakerIPLayeredPortType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerIPLayeredPortType *)soap_instantiate_cb__CircuitBreakerIPLayeredPortType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPLayeredPortType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortType, sizeof(cb__CircuitBreakerIPLayeredPortType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPPacketType(struct soap *soap, cb__CircuitBreakerIPPacketType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerIPPacketType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPPacketType(struct soap *soap, cb__CircuitBreakerIPPacketType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerIPPacketType); + if (soap_out_PointerTocb__CircuitBreakerIPPacketType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPPacketType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerIPPacketType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerIPPacketType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPPacketType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPPacketType(struct soap *soap, cb__CircuitBreakerIPPacketType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerIPPacketType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerIPPacketType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPPacketType(struct soap *soap, const char *tag, cb__CircuitBreakerIPPacketType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerIPPacketType **)soap_malloc(soap, sizeof(cb__CircuitBreakerIPPacketType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerIPPacketType *)soap_instantiate_cb__CircuitBreakerIPPacketType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPPacketType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerIPPacketType, sizeof(cb__CircuitBreakerIPPacketType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPv6Type(struct soap *soap, cb__CircuitBreakerIPv6Type *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerIPv6Type)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPv6Type(struct soap *soap, cb__CircuitBreakerIPv6Type *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerIPv6Type); + if (soap_out_PointerTocb__CircuitBreakerIPv6Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPv6Type(struct soap *soap, const char *tag, int id, cb__CircuitBreakerIPv6Type *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerIPv6Type); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6Type ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPv6Type(struct soap *soap, cb__CircuitBreakerIPv6Type **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerIPv6Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6Type ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPv6Type(struct soap *soap, const char *tag, cb__CircuitBreakerIPv6Type **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerIPv6Type **)soap_malloc(soap, sizeof(cb__CircuitBreakerIPv6Type *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerIPv6Type *)soap_instantiate_cb__CircuitBreakerIPv6Type(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPv6Type **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerIPv6Type, sizeof(cb__CircuitBreakerIPv6Type), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPv4Type(struct soap *soap, cb__CircuitBreakerIPv4Type *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerIPv4Type)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPv4Type(struct soap *soap, cb__CircuitBreakerIPv4Type *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerIPv4Type); + if (soap_out_PointerTocb__CircuitBreakerIPv4Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPv4Type(struct soap *soap, const char *tag, int id, cb__CircuitBreakerIPv4Type *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerIPv4Type); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4Type ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPv4Type(struct soap *soap, cb__CircuitBreakerIPv4Type **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerIPv4Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4Type ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPv4Type(struct soap *soap, const char *tag, cb__CircuitBreakerIPv4Type **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerIPv4Type **)soap_malloc(soap, sizeof(cb__CircuitBreakerIPv4Type *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerIPv4Type *)soap_instantiate_cb__CircuitBreakerIPv4Type(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPv4Type **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerIPv4Type, sizeof(cb__CircuitBreakerIPv4Type), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv6AddressAndMaskType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv6AddressAndMaskType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerIPv6AddressAndMaskType); + if (soap_out_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerIPv6AddressAndMaskType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv6AddressAndMaskType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerIPv6AddressAndMaskType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPv6AddressAndMaskType(struct soap *soap, const char *tag, cb__CircuitBreakerIPv6AddressAndMaskType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerIPv6AddressAndMaskType **)soap_malloc(soap, sizeof(cb__CircuitBreakerIPv6AddressAndMaskType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerIPv6AddressAndMaskType *)soap_instantiate_cb__CircuitBreakerIPv6AddressAndMaskType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPv6AddressAndMaskType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerIPv6AddressAndMaskType, sizeof(cb__CircuitBreakerIPv6AddressAndMaskType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv4AddressAndMaskType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv4AddressAndMaskType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerIPv4AddressAndMaskType); + if (soap_out_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerIPv4AddressAndMaskType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, cb__CircuitBreakerIPv4AddressAndMaskType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerIPv4AddressAndMaskType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPv4AddressAndMaskType(struct soap *soap, const char *tag, cb__CircuitBreakerIPv4AddressAndMaskType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerIPv4AddressAndMaskType **)soap_malloc(soap, sizeof(cb__CircuitBreakerIPv4AddressAndMaskType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerIPv4AddressAndMaskType *)soap_instantiate_cb__CircuitBreakerIPv4AddressAndMaskType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPv4AddressAndMaskType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerIPv4AddressAndMaskType, sizeof(cb__CircuitBreakerIPv4AddressAndMaskType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, cb__CircuitBreakerIPLayeredPortRangeType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, cb__CircuitBreakerIPLayeredPortRangeType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortRangeType); + if (soap_out_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerIPLayeredPortRangeType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, cb__CircuitBreakerIPLayeredPortRangeType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerIPLayeredPortRangeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortRangeType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPLayeredPortRangeType(struct soap *soap, const char *tag, cb__CircuitBreakerIPLayeredPortRangeType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerIPLayeredPortRangeType **)soap_malloc(soap, sizeof(cb__CircuitBreakerIPLayeredPortRangeType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerIPLayeredPortRangeType *)soap_instantiate_cb__CircuitBreakerIPLayeredPortRangeType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPLayeredPortRangeType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortRangeType, sizeof(cb__CircuitBreakerIPLayeredPortRangeType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, cb__CircuitBreakerIPLayeredPortSimpleType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, cb__CircuitBreakerIPLayeredPortSimpleType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerIPLayeredPortSimpleType); + if (soap_out_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerIPLayeredPortSimpleType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, cb__CircuitBreakerIPLayeredPortSimpleType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerIPLayeredPortSimpleType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerIPLayeredPortSimpleType(struct soap *soap, const char *tag, cb__CircuitBreakerIPLayeredPortSimpleType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerIPLayeredPortSimpleType **)soap_malloc(soap, sizeof(cb__CircuitBreakerIPLayeredPortSimpleType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerIPLayeredPortSimpleType *)soap_instantiate_cb__CircuitBreakerIPLayeredPortSimpleType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerIPLayeredPortSimpleType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerIPLayeredPortSimpleType, sizeof(cb__CircuitBreakerIPLayeredPortSimpleType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerPolicyType(struct soap *soap, cb__CircuitBreakerPolicyType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerPolicyType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerPolicyType(struct soap *soap, cb__CircuitBreakerPolicyType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerPolicyType); + if (soap_out_PointerTocb__CircuitBreakerPolicyType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerPolicyType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerPolicyType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerPolicyType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerPolicyType(struct soap *soap, cb__CircuitBreakerPolicyType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerPolicyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerPolicyType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerPolicyType(struct soap *soap, const char *tag, cb__CircuitBreakerPolicyType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerPolicyType **)soap_malloc(soap, sizeof(cb__CircuitBreakerPolicyType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerPolicyType *)soap_instantiate_cb__CircuitBreakerPolicyType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerPolicyType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerPolicyType, sizeof(cb__CircuitBreakerPolicyType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerDefaultFilterType(struct soap *soap, cb__CircuitBreakerDefaultFilterType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerDefaultFilterType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerDefaultFilterType(struct soap *soap, cb__CircuitBreakerDefaultFilterType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerDefaultFilterType); + if (soap_out_PointerTocb__CircuitBreakerDefaultFilterType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerDefaultFilterType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerDefaultFilterType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerDefaultFilterType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerDefaultFilterType(struct soap *soap, cb__CircuitBreakerDefaultFilterType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerDefaultFilterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerDefaultFilterType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerDefaultFilterType(struct soap *soap, const char *tag, cb__CircuitBreakerDefaultFilterType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerDefaultFilterType **)soap_malloc(soap, sizeof(cb__CircuitBreakerDefaultFilterType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerDefaultFilterType *)soap_instantiate_cb__CircuitBreakerDefaultFilterType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerDefaultFilterType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerDefaultFilterType, sizeof(cb__CircuitBreakerDefaultFilterType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, cb__CircuitBreakerAntiSpoofingFilterType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, cb__CircuitBreakerAntiSpoofingFilterType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocb__CircuitBreakerAntiSpoofingFilterType); + if (soap_out_PointerTocb__CircuitBreakerAntiSpoofingFilterType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, const char *tag, int id, cb__CircuitBreakerAntiSpoofingFilterType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType ** SOAP_FMAC4 soap_get_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, cb__CircuitBreakerAntiSpoofingFilterType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocb__CircuitBreakerAntiSpoofingFilterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cb__CircuitBreakerAntiSpoofingFilterType ** SOAP_FMAC4 soap_in_PointerTocb__CircuitBreakerAntiSpoofingFilterType(struct soap *soap, const char *tag, cb__CircuitBreakerAntiSpoofingFilterType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cb__CircuitBreakerAntiSpoofingFilterType **)soap_malloc(soap, sizeof(cb__CircuitBreakerAntiSpoofingFilterType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cb__CircuitBreakerAntiSpoofingFilterType *)soap_instantiate_cb__CircuitBreakerAntiSpoofingFilterType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cb__CircuitBreakerAntiSpoofingFilterType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cb__CircuitBreakerAntiSpoofingFilterType, sizeof(cb__CircuitBreakerAntiSpoofingFilterType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionGeneralType(struct soap *soap, emi__AlertSubscriptionGeneralType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__AlertSubscriptionGeneralType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionGeneralType(struct soap *soap, emi__AlertSubscriptionGeneralType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__AlertSubscriptionGeneralType); + if (soap_out_PointerToemi__AlertSubscriptionGeneralType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionGeneralType(struct soap *soap, const char *tag, int id, emi__AlertSubscriptionGeneralType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__AlertSubscriptionGeneralType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionGeneralType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionGeneralType(struct soap *soap, emi__AlertSubscriptionGeneralType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__AlertSubscriptionGeneralType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__AlertSubscriptionGeneralType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionGeneralType(struct soap *soap, const char *tag, emi__AlertSubscriptionGeneralType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__AlertSubscriptionGeneralType **)soap_malloc(soap, sizeof(emi__AlertSubscriptionGeneralType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__AlertSubscriptionGeneralType *)soap_instantiate_emi__AlertSubscriptionGeneralType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__AlertSubscriptionGeneralType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__AlertSubscriptionGeneralType, sizeof(emi__AlertSubscriptionGeneralType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__SensorAttributesType(struct soap *soap, emi__SensorAttributesType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__SensorAttributesType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__SensorAttributesType(struct soap *soap, emi__SensorAttributesType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__SensorAttributesType); + if (soap_out_PointerToemi__SensorAttributesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__SensorAttributesType(struct soap *soap, const char *tag, int id, emi__SensorAttributesType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__SensorAttributesType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__SensorAttributesType ** SOAP_FMAC4 soap_get_PointerToemi__SensorAttributesType(struct soap *soap, emi__SensorAttributesType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__SensorAttributesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__SensorAttributesType ** SOAP_FMAC4 soap_in_PointerToemi__SensorAttributesType(struct soap *soap, const char *tag, emi__SensorAttributesType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__SensorAttributesType **)soap_malloc(soap, sizeof(emi__SensorAttributesType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__SensorAttributesType *)soap_instantiate_emi__SensorAttributesType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__SensorAttributesType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__SensorAttributesType, sizeof(emi__SensorAttributesType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__SensorHandleArrayType(struct soap *soap, emi__SensorHandleArrayType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__SensorHandleArrayType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__SensorHandleArrayType(struct soap *soap, emi__SensorHandleArrayType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__SensorHandleArrayType); + if (soap_out_PointerToemi__SensorHandleArrayType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__SensorHandleArrayType(struct soap *soap, const char *tag, int id, emi__SensorHandleArrayType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__SensorHandleArrayType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__SensorHandleArrayType ** SOAP_FMAC4 soap_get_PointerToemi__SensorHandleArrayType(struct soap *soap, emi__SensorHandleArrayType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__SensorHandleArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__SensorHandleArrayType ** SOAP_FMAC4 soap_in_PointerToemi__SensorHandleArrayType(struct soap *soap, const char *tag, emi__SensorHandleArrayType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__SensorHandleArrayType **)soap_malloc(soap, sizeof(emi__SensorHandleArrayType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__SensorHandleArrayType *)soap_instantiate_emi__SensorHandleArrayType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__SensorHandleArrayType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__SensorHandleArrayType, sizeof(emi__SensorHandleArrayType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__EventLogRecordArrayType(struct soap *soap, emi__EventLogRecordArrayType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__EventLogRecordArrayType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__EventLogRecordArrayType(struct soap *soap, emi__EventLogRecordArrayType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__EventLogRecordArrayType); + if (soap_out_PointerToemi__EventLogRecordArrayType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__EventLogRecordArrayType(struct soap *soap, const char *tag, int id, emi__EventLogRecordArrayType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__EventLogRecordArrayType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__EventLogRecordArrayType ** SOAP_FMAC4 soap_get_PointerToemi__EventLogRecordArrayType(struct soap *soap, emi__EventLogRecordArrayType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__EventLogRecordArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__EventLogRecordArrayType ** SOAP_FMAC4 soap_in_PointerToemi__EventLogRecordArrayType(struct soap *soap, const char *tag, emi__EventLogRecordArrayType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__EventLogRecordArrayType **)soap_malloc(soap, sizeof(emi__EventLogRecordArrayType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__EventLogRecordArrayType *)soap_instantiate_emi__EventLogRecordArrayType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__EventLogRecordArrayType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__EventLogRecordArrayType, sizeof(emi__EventLogRecordArrayType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__EventFilterHandleArrayType(struct soap *soap, emi__EventFilterHandleArrayType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__EventFilterHandleArrayType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__EventFilterHandleArrayType(struct soap *soap, emi__EventFilterHandleArrayType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__EventFilterHandleArrayType); + if (soap_out_PointerToemi__EventFilterHandleArrayType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__EventFilterHandleArrayType(struct soap *soap, const char *tag, int id, emi__EventFilterHandleArrayType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__EventFilterHandleArrayType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__EventFilterHandleArrayType ** SOAP_FMAC4 soap_get_PointerToemi__EventFilterHandleArrayType(struct soap *soap, emi__EventFilterHandleArrayType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__EventFilterHandleArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__EventFilterHandleArrayType ** SOAP_FMAC4 soap_in_PointerToemi__EventFilterHandleArrayType(struct soap *soap, const char *tag, emi__EventFilterHandleArrayType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__EventFilterHandleArrayType **)soap_malloc(soap, sizeof(emi__EventFilterHandleArrayType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__EventFilterHandleArrayType *)soap_instantiate_emi__EventFilterHandleArrayType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__EventFilterHandleArrayType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__EventFilterHandleArrayType, sizeof(emi__EventFilterHandleArrayType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__EventFilterType(struct soap *soap, emi__EventFilterType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__EventFilterType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__EventFilterType(struct soap *soap, emi__EventFilterType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__EventFilterType); + if (soap_out_PointerToemi__EventFilterType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__EventFilterType(struct soap *soap, const char *tag, int id, emi__EventFilterType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__EventFilterType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__EventFilterType ** SOAP_FMAC4 soap_get_PointerToemi__EventFilterType(struct soap *soap, emi__EventFilterType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__EventFilterType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__EventFilterType ** SOAP_FMAC4 soap_in_PointerToemi__EventFilterType(struct soap *soap, const char *tag, emi__EventFilterType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__EventFilterType **)soap_malloc(soap, sizeof(emi__EventFilterType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__EventFilterType *)soap_instantiate_emi__EventFilterType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__EventFilterType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__EventFilterType, sizeof(emi__EventFilterType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__ByteStr(struct soap *soap, emi__ByteStr *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__ByteStr)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__ByteStr(struct soap *soap, emi__ByteStr *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__ByteStr); + if (soap_out_PointerToemi__ByteStr(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__ByteStr(struct soap *soap, const char *tag, int id, emi__ByteStr *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__ByteStr); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__ByteStr ** SOAP_FMAC4 soap_get_PointerToemi__ByteStr(struct soap *soap, emi__ByteStr **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__ByteStr(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__ByteStr ** SOAP_FMAC4 soap_in_PointerToemi__ByteStr(struct soap *soap, const char *tag, emi__ByteStr **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__ByteStr **)soap_malloc(soap, sizeof(emi__ByteStr *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__ByteStr *)soap_instantiate_emi__ByteStr(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__ByteStr **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__ByteStr, sizeof(emi__ByteStr), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, emi__AlertSubscriptionPolicyIDArrayType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, emi__AlertSubscriptionPolicyIDArrayType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDArrayType); + if (soap_out_PointerToemi__AlertSubscriptionPolicyIDArrayType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, const char *tag, int id, emi__AlertSubscriptionPolicyIDArrayType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, emi__AlertSubscriptionPolicyIDArrayType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__AlertSubscriptionPolicyIDArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__AlertSubscriptionPolicyIDArrayType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionPolicyIDArrayType(struct soap *soap, const char *tag, emi__AlertSubscriptionPolicyIDArrayType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__AlertSubscriptionPolicyIDArrayType **)soap_malloc(soap, sizeof(emi__AlertSubscriptionPolicyIDArrayType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__AlertSubscriptionPolicyIDArrayType *)soap_instantiate_emi__AlertSubscriptionPolicyIDArrayType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__AlertSubscriptionPolicyIDArrayType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__AlertSubscriptionPolicyIDArrayType, sizeof(emi__AlertSubscriptionPolicyIDArrayType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionHandleArrayType(struct soap *soap, emi__AlertSubscriptionHandleArrayType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__AlertSubscriptionHandleArrayType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionHandleArrayType(struct soap *soap, emi__AlertSubscriptionHandleArrayType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__AlertSubscriptionHandleArrayType); + if (soap_out_PointerToemi__AlertSubscriptionHandleArrayType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionHandleArrayType(struct soap *soap, const char *tag, int id, emi__AlertSubscriptionHandleArrayType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__AlertSubscriptionHandleArrayType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionHandleArrayType(struct soap *soap, emi__AlertSubscriptionHandleArrayType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__AlertSubscriptionHandleArrayType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__AlertSubscriptionHandleArrayType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionHandleArrayType(struct soap *soap, const char *tag, emi__AlertSubscriptionHandleArrayType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__AlertSubscriptionHandleArrayType **)soap_malloc(soap, sizeof(emi__AlertSubscriptionHandleArrayType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__AlertSubscriptionHandleArrayType *)soap_instantiate_emi__AlertSubscriptionHandleArrayType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__AlertSubscriptionHandleArrayType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__AlertSubscriptionHandleArrayType, sizeof(emi__AlertSubscriptionHandleArrayType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionPolicyIDType(struct soap *soap, unsigned char *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_emi__AlertSubscriptionPolicyIDType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionPolicyIDType(struct soap *soap, unsigned char *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__AlertSubscriptionPolicyIDType); + if (soap_out_PointerToemi__AlertSubscriptionPolicyIDType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionPolicyIDType(struct soap *soap, const char *tag, int id, unsigned char *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__AlertSubscriptionPolicyIDType); + if (id < 0) + return soap->error; + return soap_out_emi__AlertSubscriptionPolicyIDType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionPolicyIDType(struct soap *soap, unsigned char **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__AlertSubscriptionPolicyIDType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionPolicyIDType(struct soap *soap, const char *tag, unsigned char **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned char **)soap_malloc(soap, sizeof(unsigned char *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_emi__AlertSubscriptionPolicyIDType(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned char **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__AlertSubscriptionPolicyIDType, sizeof(unsigned char), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionType(struct soap *soap, emi__AlertSubscriptionType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__AlertSubscriptionType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionType(struct soap *soap, emi__AlertSubscriptionType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__AlertSubscriptionType); + if (soap_out_PointerToemi__AlertSubscriptionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionType(struct soap *soap, const char *tag, int id, emi__AlertSubscriptionType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__AlertSubscriptionType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionType(struct soap *soap, emi__AlertSubscriptionType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__AlertSubscriptionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__AlertSubscriptionType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionType(struct soap *soap, const char *tag, emi__AlertSubscriptionType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__AlertSubscriptionType **)soap_malloc(soap, sizeof(emi__AlertSubscriptionType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__AlertSubscriptionType *)soap_instantiate_emi__AlertSubscriptionType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__AlertSubscriptionType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__AlertSubscriptionType, sizeof(emi__AlertSubscriptionType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionSoapType(struct soap *soap, emi__AlertSubscriptionSoapType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__AlertSubscriptionSoapType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionSoapType(struct soap *soap, emi__AlertSubscriptionSoapType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__AlertSubscriptionSoapType); + if (soap_out_PointerToemi__AlertSubscriptionSoapType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionSoapType(struct soap *soap, const char *tag, int id, emi__AlertSubscriptionSoapType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__AlertSubscriptionSoapType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionSoapType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionSoapType(struct soap *soap, emi__AlertSubscriptionSoapType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__AlertSubscriptionSoapType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__AlertSubscriptionSoapType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionSoapType(struct soap *soap, const char *tag, emi__AlertSubscriptionSoapType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__AlertSubscriptionSoapType **)soap_malloc(soap, sizeof(emi__AlertSubscriptionSoapType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__AlertSubscriptionSoapType *)soap_instantiate_emi__AlertSubscriptionSoapType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__AlertSubscriptionSoapType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__AlertSubscriptionSoapType, sizeof(emi__AlertSubscriptionSoapType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertSubscriptionSNMPType(struct soap *soap, emi__AlertSubscriptionSNMPType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__AlertSubscriptionSNMPType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertSubscriptionSNMPType(struct soap *soap, emi__AlertSubscriptionSNMPType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__AlertSubscriptionSNMPType); + if (soap_out_PointerToemi__AlertSubscriptionSNMPType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertSubscriptionSNMPType(struct soap *soap, const char *tag, int id, emi__AlertSubscriptionSNMPType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__AlertSubscriptionSNMPType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__AlertSubscriptionSNMPType ** SOAP_FMAC4 soap_get_PointerToemi__AlertSubscriptionSNMPType(struct soap *soap, emi__AlertSubscriptionSNMPType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__AlertSubscriptionSNMPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__AlertSubscriptionSNMPType ** SOAP_FMAC4 soap_in_PointerToemi__AlertSubscriptionSNMPType(struct soap *soap, const char *tag, emi__AlertSubscriptionSNMPType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__AlertSubscriptionSNMPType **)soap_malloc(soap, sizeof(emi__AlertSubscriptionSNMPType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__AlertSubscriptionSNMPType *)soap_instantiate_emi__AlertSubscriptionSNMPType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__AlertSubscriptionSNMPType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__AlertSubscriptionSNMPType, sizeof(emi__AlertSubscriptionSNMPType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__AlertCredentialsType(struct soap *soap, emi__AlertCredentialsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__AlertCredentialsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__AlertCredentialsType(struct soap *soap, emi__AlertCredentialsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__AlertCredentialsType); + if (soap_out_PointerToemi__AlertCredentialsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__AlertCredentialsType(struct soap *soap, const char *tag, int id, emi__AlertCredentialsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__AlertCredentialsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__AlertCredentialsType ** SOAP_FMAC4 soap_get_PointerToemi__AlertCredentialsType(struct soap *soap, emi__AlertCredentialsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__AlertCredentialsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__AlertCredentialsType ** SOAP_FMAC4 soap_in_PointerToemi__AlertCredentialsType(struct soap *soap, const char *tag, emi__AlertCredentialsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__AlertCredentialsType **)soap_malloc(soap, sizeof(emi__AlertCredentialsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__AlertCredentialsType *)soap_instantiate_emi__AlertCredentialsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__AlertCredentialsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__AlertCredentialsType, sizeof(emi__AlertCredentialsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__URLType(struct soap *soap, cmn__URLType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cmn__URLType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__URLType(struct soap *soap, cmn__URLType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocmn__URLType); + if (soap_out_PointerTocmn__URLType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__URLType(struct soap *soap, const char *tag, int id, cmn__URLType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cmn__URLType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cmn__URLType ** SOAP_FMAC4 soap_get_PointerTocmn__URLType(struct soap *soap, cmn__URLType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocmn__URLType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cmn__URLType ** SOAP_FMAC4 soap_in_PointerTocmn__URLType(struct soap *soap, const char *tag, cmn__URLType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cmn__URLType **)soap_malloc(soap, sizeof(cmn__URLType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cmn__URLType *)soap_instantiate_cmn__URLType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cmn__URLType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cmn__URLType, sizeof(cmn__URLType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__CommunityStringType(struct soap *soap, std::string *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__CommunityStringType)) + soap_serialize_emi__CommunityStringType(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__CommunityStringType(struct soap *soap, std::string *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__CommunityStringType); + if (soap_out_PointerToemi__CommunityStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__CommunityStringType(struct soap *soap, const char *tag, int id, std::string *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__CommunityStringType); + if (id < 0) + return soap->error; + return soap_out_emi__CommunityStringType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerToemi__CommunityStringType(struct soap *soap, std::string **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__CommunityStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerToemi__CommunityStringType(struct soap *soap, const char *tag, std::string **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (std::string **)soap_malloc(soap, sizeof(std::string *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_emi__CommunityStringType(soap, tag, *a, type))) + return NULL; + } + else + { a = (std::string **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__CommunityStringType, sizeof(std::string), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__NodeAddressType(struct soap *soap, cmn__NodeAddressType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cmn__NodeAddressType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__NodeAddressType(struct soap *soap, cmn__NodeAddressType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocmn__NodeAddressType); + if (soap_out_PointerTocmn__NodeAddressType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__NodeAddressType(struct soap *soap, const char *tag, int id, cmn__NodeAddressType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cmn__NodeAddressType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cmn__NodeAddressType ** SOAP_FMAC4 soap_get_PointerTocmn__NodeAddressType(struct soap *soap, cmn__NodeAddressType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocmn__NodeAddressType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cmn__NodeAddressType ** SOAP_FMAC4 soap_in_PointerTocmn__NodeAddressType(struct soap *soap, const char *tag, cmn__NodeAddressType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cmn__NodeAddressType **)soap_malloc(soap, sizeof(cmn__NodeAddressType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cmn__NodeAddressType *)soap_instantiate_cmn__NodeAddressType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cmn__NodeAddressType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cmn__NodeAddressType, sizeof(cmn__NodeAddressType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__EventLogRecordType(struct soap *soap, emi__EventLogRecordType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__EventLogRecordType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__EventLogRecordType(struct soap *soap, emi__EventLogRecordType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__EventLogRecordType); + if (soap_out_PointerToemi__EventLogRecordType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__EventLogRecordType(struct soap *soap, const char *tag, int id, emi__EventLogRecordType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__EventLogRecordType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__EventLogRecordType ** SOAP_FMAC4 soap_get_PointerToemi__EventLogRecordType(struct soap *soap, emi__EventLogRecordType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__EventLogRecordType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__EventLogRecordType ** SOAP_FMAC4 soap_in_PointerToemi__EventLogRecordType(struct soap *soap, const char *tag, emi__EventLogRecordType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__EventLogRecordType **)soap_malloc(soap, sizeof(emi__EventLogRecordType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__EventLogRecordType *)soap_instantiate_emi__EventLogRecordType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__EventLogRecordType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__EventLogRecordType, sizeof(emi__EventLogRecordType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToemi__ByteData(struct soap *soap, emi__ByteData *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_emi__ByteData)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToemi__ByteData(struct soap *soap, emi__ByteData *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToemi__ByteData); + if (soap_out_PointerToemi__ByteData(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToemi__ByteData(struct soap *soap, const char *tag, int id, emi__ByteData *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_emi__ByteData); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 emi__ByteData ** SOAP_FMAC4 soap_get_PointerToemi__ByteData(struct soap *soap, emi__ByteData **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToemi__ByteData(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 emi__ByteData ** SOAP_FMAC4 soap_in_PointerToemi__ByteData(struct soap *soap, const char *tag, emi__ByteData **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (emi__ByteData **)soap_malloc(soap, sizeof(emi__ByteData *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (emi__ByteData *)soap_instantiate_emi__ByteData(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (emi__ByteData **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_emi__ByteData, sizeof(emi__ByteData), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageAllocEntryHandleListType(struct soap *soap, stra__StorageAllocEntryHandleListType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__StorageAllocEntryHandleListType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageAllocEntryHandleListType(struct soap *soap, stra__StorageAllocEntryHandleListType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__StorageAllocEntryHandleListType); + if (soap_out_PointerTostra__StorageAllocEntryHandleListType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageAllocEntryHandleListType(struct soap *soap, const char *tag, int id, stra__StorageAllocEntryHandleListType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__StorageAllocEntryHandleListType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__StorageAllocEntryHandleListType ** SOAP_FMAC4 soap_get_PointerTostra__StorageAllocEntryHandleListType(struct soap *soap, stra__StorageAllocEntryHandleListType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__StorageAllocEntryHandleListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__StorageAllocEntryHandleListType ** SOAP_FMAC4 soap_in_PointerTostra__StorageAllocEntryHandleListType(struct soap *soap, const char *tag, stra__StorageAllocEntryHandleListType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__StorageAllocEntryHandleListType **)soap_malloc(soap, sizeof(stra__StorageAllocEntryHandleListType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__StorageAllocEntryHandleListType *)soap_instantiate_stra__StorageAllocEntryHandleListType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__StorageAllocEntryHandleListType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__StorageAllocEntryHandleListType, sizeof(stra__StorageAllocEntryHandleListType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageAllocEntryType(struct soap *soap, stra__StorageAllocEntryType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__StorageAllocEntryType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageAllocEntryType(struct soap *soap, stra__StorageAllocEntryType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__StorageAllocEntryType); + if (soap_out_PointerTostra__StorageAllocEntryType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageAllocEntryType(struct soap *soap, const char *tag, int id, stra__StorageAllocEntryType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__StorageAllocEntryType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__StorageAllocEntryType ** SOAP_FMAC4 soap_get_PointerTostra__StorageAllocEntryType(struct soap *soap, stra__StorageAllocEntryType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__StorageAllocEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__StorageAllocEntryType ** SOAP_FMAC4 soap_in_PointerTostra__StorageAllocEntryType(struct soap *soap, const char *tag, stra__StorageAllocEntryType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__StorageAllocEntryType **)soap_malloc(soap, sizeof(stra__StorageAllocEntryType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__StorageAllocEntryType *)soap_instantiate_stra__StorageAllocEntryType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__StorageAllocEntryType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__StorageAllocEntryType, sizeof(stra__StorageAllocEntryType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageEaclEntryHandleListType(struct soap *soap, stra__StorageEaclEntryHandleListType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__StorageEaclEntryHandleListType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageEaclEntryHandleListType(struct soap *soap, stra__StorageEaclEntryHandleListType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__StorageEaclEntryHandleListType); + if (soap_out_PointerTostra__StorageEaclEntryHandleListType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageEaclEntryHandleListType(struct soap *soap, const char *tag, int id, stra__StorageEaclEntryHandleListType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__StorageEaclEntryHandleListType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__StorageEaclEntryHandleListType ** SOAP_FMAC4 soap_get_PointerTostra__StorageEaclEntryHandleListType(struct soap *soap, stra__StorageEaclEntryHandleListType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__StorageEaclEntryHandleListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__StorageEaclEntryHandleListType ** SOAP_FMAC4 soap_in_PointerTostra__StorageEaclEntryHandleListType(struct soap *soap, const char *tag, stra__StorageEaclEntryHandleListType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__StorageEaclEntryHandleListType **)soap_malloc(soap, sizeof(stra__StorageEaclEntryHandleListType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__StorageEaclEntryHandleListType *)soap_instantiate_stra__StorageEaclEntryHandleListType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__StorageEaclEntryHandleListType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__StorageEaclEntryHandleListType, sizeof(stra__StorageEaclEntryHandleListType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageEaclEntryType(struct soap *soap, stra__StorageEaclEntryType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__StorageEaclEntryType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageEaclEntryType(struct soap *soap, stra__StorageEaclEntryType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__StorageEaclEntryType); + if (soap_out_PointerTostra__StorageEaclEntryType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageEaclEntryType(struct soap *soap, const char *tag, int id, stra__StorageEaclEntryType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__StorageEaclEntryType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__StorageEaclEntryType ** SOAP_FMAC4 soap_get_PointerTostra__StorageEaclEntryType(struct soap *soap, stra__StorageEaclEntryType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__StorageEaclEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__StorageEaclEntryType ** SOAP_FMAC4 soap_in_PointerTostra__StorageEaclEntryType(struct soap *soap, const char *tag, stra__StorageEaclEntryType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__StorageEaclEntryType **)soap_malloc(soap, sizeof(stra__StorageEaclEntryType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__StorageEaclEntryType *)soap_instantiate_stra__StorageEaclEntryType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__StorageEaclEntryType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__StorageEaclEntryType, sizeof(stra__StorageEaclEntryType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageApplicationAttributesType(struct soap *soap, stra__StorageApplicationAttributesType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__StorageApplicationAttributesType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageApplicationAttributesType(struct soap *soap, stra__StorageApplicationAttributesType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__StorageApplicationAttributesType); + if (soap_out_PointerTostra__StorageApplicationAttributesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageApplicationAttributesType(struct soap *soap, const char *tag, int id, stra__StorageApplicationAttributesType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__StorageApplicationAttributesType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__StorageApplicationAttributesType ** SOAP_FMAC4 soap_get_PointerTostra__StorageApplicationAttributesType(struct soap *soap, stra__StorageApplicationAttributesType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__StorageApplicationAttributesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__StorageApplicationAttributesType ** SOAP_FMAC4 soap_in_PointerTostra__StorageApplicationAttributesType(struct soap *soap, const char *tag, stra__StorageApplicationAttributesType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__StorageApplicationAttributesType **)soap_malloc(soap, sizeof(stra__StorageApplicationAttributesType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__StorageApplicationAttributesType *)soap_instantiate_stra__StorageApplicationAttributesType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__StorageApplicationAttributesType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__StorageApplicationAttributesType, sizeof(stra__StorageApplicationAttributesType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageApplicationHandleListType(struct soap *soap, stra__StorageApplicationHandleListType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__StorageApplicationHandleListType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageApplicationHandleListType(struct soap *soap, stra__StorageApplicationHandleListType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__StorageApplicationHandleListType); + if (soap_out_PointerTostra__StorageApplicationHandleListType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageApplicationHandleListType(struct soap *soap, const char *tag, int id, stra__StorageApplicationHandleListType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__StorageApplicationHandleListType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__StorageApplicationHandleListType ** SOAP_FMAC4 soap_get_PointerTostra__StorageApplicationHandleListType(struct soap *soap, stra__StorageApplicationHandleListType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__StorageApplicationHandleListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__StorageApplicationHandleListType ** SOAP_FMAC4 soap_in_PointerTostra__StorageApplicationHandleListType(struct soap *soap, const char *tag, stra__StorageApplicationHandleListType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__StorageApplicationHandleListType **)soap_malloc(soap, sizeof(stra__StorageApplicationHandleListType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__StorageApplicationHandleListType *)soap_instantiate_stra__StorageApplicationHandleListType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__StorageApplicationHandleListType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__StorageApplicationHandleListType, sizeof(stra__StorageApplicationHandleListType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__GlobalStorageAttributesType(struct soap *soap, stra__GlobalStorageAttributesType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__GlobalStorageAttributesType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__GlobalStorageAttributesType(struct soap *soap, stra__GlobalStorageAttributesType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__GlobalStorageAttributesType); + if (soap_out_PointerTostra__GlobalStorageAttributesType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__GlobalStorageAttributesType(struct soap *soap, const char *tag, int id, stra__GlobalStorageAttributesType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__GlobalStorageAttributesType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__GlobalStorageAttributesType ** SOAP_FMAC4 soap_get_PointerTostra__GlobalStorageAttributesType(struct soap *soap, stra__GlobalStorageAttributesType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__GlobalStorageAttributesType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__GlobalStorageAttributesType ** SOAP_FMAC4 soap_in_PointerTostra__GlobalStorageAttributesType(struct soap *soap, const char *tag, stra__GlobalStorageAttributesType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__GlobalStorageAttributesType **)soap_malloc(soap, sizeof(stra__GlobalStorageAttributesType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__GlobalStorageAttributesType *)soap_instantiate_stra__GlobalStorageAttributesType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__GlobalStorageAttributesType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__GlobalStorageAttributesType, sizeof(stra__GlobalStorageAttributesType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageSnrpApplicationAttributeType(struct soap *soap, stra__StorageSnrpApplicationAttributeType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__StorageSnrpApplicationAttributeType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageSnrpApplicationAttributeType(struct soap *soap, stra__StorageSnrpApplicationAttributeType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__StorageSnrpApplicationAttributeType); + if (soap_out_PointerTostra__StorageSnrpApplicationAttributeType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageSnrpApplicationAttributeType(struct soap *soap, const char *tag, int id, stra__StorageSnrpApplicationAttributeType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__StorageSnrpApplicationAttributeType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType ** SOAP_FMAC4 soap_get_PointerTostra__StorageSnrpApplicationAttributeType(struct soap *soap, stra__StorageSnrpApplicationAttributeType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__StorageSnrpApplicationAttributeType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__StorageSnrpApplicationAttributeType ** SOAP_FMAC4 soap_in_PointerTostra__StorageSnrpApplicationAttributeType(struct soap *soap, const char *tag, stra__StorageSnrpApplicationAttributeType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__StorageSnrpApplicationAttributeType **)soap_malloc(soap, sizeof(stra__StorageSnrpApplicationAttributeType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__StorageSnrpApplicationAttributeType *)soap_instantiate_stra__StorageSnrpApplicationAttributeType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__StorageSnrpApplicationAttributeType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__StorageSnrpApplicationAttributeType, sizeof(stra__StorageSnrpApplicationAttributeType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__GUID(struct soap *soap, stra__GUID *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__GUID)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__GUID(struct soap *soap, stra__GUID *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__GUID); + if (soap_out_PointerTostra__GUID(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__GUID(struct soap *soap, const char *tag, int id, stra__GUID *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__GUID); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__GUID ** SOAP_FMAC4 soap_get_PointerTostra__GUID(struct soap *soap, stra__GUID **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__GUID(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__GUID ** SOAP_FMAC4 soap_in_PointerTostra__GUID(struct soap *soap, const char *tag, stra__GUID **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__GUID **)soap_malloc(soap, sizeof(stra__GUID *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__GUID *)soap_instantiate_stra__GUID(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__GUID **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__GUID, sizeof(stra__GUID), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostra__StorageAllocSnrpEntryType(struct soap *soap, stra__StorageAllocSnrpEntryType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_stra__StorageAllocSnrpEntryType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostra__StorageAllocSnrpEntryType(struct soap *soap, stra__StorageAllocSnrpEntryType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostra__StorageAllocSnrpEntryType); + if (soap_out_PointerTostra__StorageAllocSnrpEntryType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostra__StorageAllocSnrpEntryType(struct soap *soap, const char *tag, int id, stra__StorageAllocSnrpEntryType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_stra__StorageAllocSnrpEntryType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 stra__StorageAllocSnrpEntryType ** SOAP_FMAC4 soap_get_PointerTostra__StorageAllocSnrpEntryType(struct soap *soap, stra__StorageAllocSnrpEntryType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostra__StorageAllocSnrpEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 stra__StorageAllocSnrpEntryType ** SOAP_FMAC4 soap_in_PointerTostra__StorageAllocSnrpEntryType(struct soap *soap, const char *tag, stra__StorageAllocSnrpEntryType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (stra__StorageAllocSnrpEntryType **)soap_malloc(soap, sizeof(stra__StorageAllocSnrpEntryType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (stra__StorageAllocSnrpEntryType *)soap_instantiate_stra__StorageAllocSnrpEntryType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (stra__StorageAllocSnrpEntryType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_stra__StorageAllocSnrpEntryType, sizeof(stra__StorageAllocSnrpEntryType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileType(struct soap *soap, xcfg__XProfileType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__XProfileType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileType(struct soap *soap, xcfg__XProfileType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__XProfileType); + if (soap_out_PointerToxcfg__XProfileType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileType(struct soap *soap, const char *tag, int id, xcfg__XProfileType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__XProfileType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__XProfileType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileType(struct soap *soap, xcfg__XProfileType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__XProfileType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__XProfileType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileType(struct soap *soap, const char *tag, xcfg__XProfileType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__XProfileType **)soap_malloc(soap, sizeof(xcfg__XProfileType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__XProfileType *)soap_instantiate_xcfg__XProfileType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__XProfileType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__XProfileType, sizeof(xcfg__XProfileType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTonet__InterfaceDescriptorSetType(struct soap *soap, net__InterfaceDescriptorSetType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_net__InterfaceDescriptorSetType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTonet__InterfaceDescriptorSetType(struct soap *soap, net__InterfaceDescriptorSetType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTonet__InterfaceDescriptorSetType); + if (soap_out_PointerTonet__InterfaceDescriptorSetType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTonet__InterfaceDescriptorSetType(struct soap *soap, const char *tag, int id, net__InterfaceDescriptorSetType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_net__InterfaceDescriptorSetType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 net__InterfaceDescriptorSetType ** SOAP_FMAC4 soap_get_PointerTonet__InterfaceDescriptorSetType(struct soap *soap, net__InterfaceDescriptorSetType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTonet__InterfaceDescriptorSetType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 net__InterfaceDescriptorSetType ** SOAP_FMAC4 soap_in_PointerTonet__InterfaceDescriptorSetType(struct soap *soap, const char *tag, net__InterfaceDescriptorSetType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (net__InterfaceDescriptorSetType **)soap_malloc(soap, sizeof(net__InterfaceDescriptorSetType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (net__InterfaceDescriptorSetType *)soap_instantiate_net__InterfaceDescriptorSetType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (net__InterfaceDescriptorSetType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_net__InterfaceDescriptorSetType, sizeof(net__InterfaceDescriptorSetType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTonet__InterfaceDescriptorGetType(struct soap *soap, net__InterfaceDescriptorGetType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_net__InterfaceDescriptorGetType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTonet__InterfaceDescriptorGetType(struct soap *soap, net__InterfaceDescriptorGetType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTonet__InterfaceDescriptorGetType); + if (soap_out_PointerTonet__InterfaceDescriptorGetType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTonet__InterfaceDescriptorGetType(struct soap *soap, const char *tag, int id, net__InterfaceDescriptorGetType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_net__InterfaceDescriptorGetType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 net__InterfaceDescriptorGetType ** SOAP_FMAC4 soap_get_PointerTonet__InterfaceDescriptorGetType(struct soap *soap, net__InterfaceDescriptorGetType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTonet__InterfaceDescriptorGetType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 net__InterfaceDescriptorGetType ** SOAP_FMAC4 soap_in_PointerTonet__InterfaceDescriptorGetType(struct soap *soap, const char *tag, net__InterfaceDescriptorGetType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (net__InterfaceDescriptorGetType **)soap_malloc(soap, sizeof(net__InterfaceDescriptorGetType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (net__InterfaceDescriptorGetType *)soap_instantiate_net__InterfaceDescriptorGetType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (net__InterfaceDescriptorGetType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_net__InterfaceDescriptorGetType, sizeof(net__InterfaceDescriptorGetType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__InterfaceHandleType(struct soap *soap, unsigned int *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_cmn__InterfaceHandleType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__InterfaceHandleType(struct soap *soap, unsigned int *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocmn__InterfaceHandleType); + if (soap_out_PointerTocmn__InterfaceHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__InterfaceHandleType(struct soap *soap, const char *tag, int id, unsigned int *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cmn__InterfaceHandleType); + if (id < 0) + return soap->error; + return soap_out_cmn__InterfaceHandleType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_get_PointerTocmn__InterfaceHandleType(struct soap *soap, unsigned int **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocmn__InterfaceHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTocmn__InterfaceHandleType(struct soap *soap, const char *tag, unsigned int **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned int **)soap_malloc(soap, sizeof(unsigned int *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_cmn__InterfaceHandleType(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned int **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cmn__InterfaceHandleType, sizeof(unsigned int), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTonet__StaticIPv4ParametersType(struct soap *soap, net__StaticIPv4ParametersType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_net__StaticIPv4ParametersType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTonet__StaticIPv4ParametersType(struct soap *soap, net__StaticIPv4ParametersType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTonet__StaticIPv4ParametersType); + if (soap_out_PointerTonet__StaticIPv4ParametersType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTonet__StaticIPv4ParametersType(struct soap *soap, const char *tag, int id, net__StaticIPv4ParametersType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_net__StaticIPv4ParametersType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 net__StaticIPv4ParametersType ** SOAP_FMAC4 soap_get_PointerTonet__StaticIPv4ParametersType(struct soap *soap, net__StaticIPv4ParametersType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTonet__StaticIPv4ParametersType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 net__StaticIPv4ParametersType ** SOAP_FMAC4 soap_in_PointerTonet__StaticIPv4ParametersType(struct soap *soap, const char *tag, net__StaticIPv4ParametersType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (net__StaticIPv4ParametersType **)soap_malloc(soap, sizeof(net__StaticIPv4ParametersType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (net__StaticIPv4ParametersType *)soap_instantiate_net__StaticIPv4ParametersType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (net__StaticIPv4ParametersType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_net__StaticIPv4ParametersType, sizeof(net__StaticIPv4ParametersType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTonet__IPv4ParametersType(struct soap *soap, net__IPv4ParametersType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_net__IPv4ParametersType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTonet__IPv4ParametersType(struct soap *soap, net__IPv4ParametersType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTonet__IPv4ParametersType); + if (soap_out_PointerTonet__IPv4ParametersType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTonet__IPv4ParametersType(struct soap *soap, const char *tag, int id, net__IPv4ParametersType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_net__IPv4ParametersType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 net__IPv4ParametersType ** SOAP_FMAC4 soap_get_PointerTonet__IPv4ParametersType(struct soap *soap, net__IPv4ParametersType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTonet__IPv4ParametersType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 net__IPv4ParametersType ** SOAP_FMAC4 soap_in_PointerTonet__IPv4ParametersType(struct soap *soap, const char *tag, net__IPv4ParametersType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (net__IPv4ParametersType **)soap_malloc(soap, sizeof(net__IPv4ParametersType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (net__IPv4ParametersType *)soap_instantiate_net__IPv4ParametersType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (net__IPv4ParametersType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_net__IPv4ParametersType, sizeof(net__IPv4ParametersType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, xcfg__XProfileEAPFAST_USCORETLSType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, xcfg__XProfileEAPFAST_USCORETLSType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCORETLSType); + if (soap_out_PointerToxcfg__XProfileEAPFAST_USCORETLSType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, const char *tag, int id, xcfg__XProfileEAPFAST_USCORETLSType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, xcfg__XProfileEAPFAST_USCORETLSType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__XProfileEAPFAST_USCORETLSType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCORETLSType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileEAPFAST_USCORETLSType(struct soap *soap, const char *tag, xcfg__XProfileEAPFAST_USCORETLSType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__XProfileEAPFAST_USCORETLSType **)soap_malloc(soap, sizeof(xcfg__XProfileEAPFAST_USCORETLSType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__XProfileEAPFAST_USCORETLSType *)soap_instantiate_xcfg__XProfileEAPFAST_USCORETLSType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__XProfileEAPFAST_USCORETLSType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCORETLSType, sizeof(xcfg__XProfileEAPFAST_USCORETLSType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, xcfg__XProfileEAPFAST_USCOREGTCType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, xcfg__XProfileEAPFAST_USCOREGTCType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREGTCType); + if (soap_out_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, const char *tag, int id, xcfg__XProfileEAPFAST_USCOREGTCType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, xcfg__XProfileEAPFAST_USCOREGTCType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREGTCType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileEAPFAST_USCOREGTCType(struct soap *soap, const char *tag, xcfg__XProfileEAPFAST_USCOREGTCType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__XProfileEAPFAST_USCOREGTCType **)soap_malloc(soap, sizeof(xcfg__XProfileEAPFAST_USCOREGTCType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__XProfileEAPFAST_USCOREGTCType *)soap_instantiate_xcfg__XProfileEAPFAST_USCOREGTCType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__XProfileEAPFAST_USCOREGTCType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREGTCType, sizeof(xcfg__XProfileEAPFAST_USCOREGTCType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type); + if (soap_out_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, int id, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type **)soap_malloc(soap, sizeof(xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type *)soap_instantiate_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type, sizeof(xcfg__XProfileEAPFAST_USCOREMSCHAPv2Type), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap *soap, xcfg__XProfileEAP_USCOREGTCType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap *soap, xcfg__XProfileEAP_USCOREGTCType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__XProfileEAP_USCOREGTCType); + if (soap_out_PointerToxcfg__XProfileEAP_USCOREGTCType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap *soap, const char *tag, int id, xcfg__XProfileEAP_USCOREGTCType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap *soap, xcfg__XProfileEAP_USCOREGTCType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__XProfileEAP_USCOREGTCType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__XProfileEAP_USCOREGTCType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileEAP_USCOREGTCType(struct soap *soap, const char *tag, xcfg__XProfileEAP_USCOREGTCType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__XProfileEAP_USCOREGTCType **)soap_malloc(soap, sizeof(xcfg__XProfileEAP_USCOREGTCType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__XProfileEAP_USCOREGTCType *)soap_instantiate_xcfg__XProfileEAP_USCOREGTCType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__XProfileEAP_USCOREGTCType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__XProfileEAP_USCOREGTCType, sizeof(xcfg__XProfileEAP_USCOREGTCType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type); + if (soap_out_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, int id, xcfg__XProfilePEAP_USCOREMSCHAPv2Type *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfilePEAP_USCOREMSCHAPv2Type **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__XProfilePEAP_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfilePEAP_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, xcfg__XProfilePEAP_USCOREMSCHAPv2Type **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__XProfilePEAP_USCOREMSCHAPv2Type **)soap_malloc(soap, sizeof(xcfg__XProfilePEAP_USCOREMSCHAPv2Type *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__XProfilePEAP_USCOREMSCHAPv2Type *)soap_instantiate_xcfg__XProfilePEAP_USCOREMSCHAPv2Type(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__XProfilePEAP_USCOREMSCHAPv2Type **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__XProfilePEAP_USCOREMSCHAPv2Type, sizeof(xcfg__XProfilePEAP_USCOREMSCHAPv2Type), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type); + if (soap_out_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, int id, xcfg__XProfileTTLS_USCOREMSCHAPv2Type *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, xcfg__XProfileTTLS_USCOREMSCHAPv2Type **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__XProfileTTLS_USCOREMSCHAPv2Type ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileTTLS_USCOREMSCHAPv2Type(struct soap *soap, const char *tag, xcfg__XProfileTTLS_USCOREMSCHAPv2Type **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__XProfileTTLS_USCOREMSCHAPv2Type **)soap_malloc(soap, sizeof(xcfg__XProfileTTLS_USCOREMSCHAPv2Type *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__XProfileTTLS_USCOREMSCHAPv2Type *)soap_instantiate_xcfg__XProfileTTLS_USCOREMSCHAPv2Type(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__XProfileTTLS_USCOREMSCHAPv2Type **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__XProfileTTLS_USCOREMSCHAPv2Type, sizeof(xcfg__XProfileTTLS_USCOREMSCHAPv2Type), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__XProfileTLSType(struct soap *soap, xcfg__XProfileTLSType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__XProfileTLSType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__XProfileTLSType(struct soap *soap, xcfg__XProfileTLSType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__XProfileTLSType); + if (soap_out_PointerToxcfg__XProfileTLSType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__XProfileTLSType(struct soap *soap, const char *tag, int id, xcfg__XProfileTLSType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__XProfileTLSType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__XProfileTLSType ** SOAP_FMAC4 soap_get_PointerToxcfg__XProfileTLSType(struct soap *soap, xcfg__XProfileTLSType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__XProfileTLSType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__XProfileTLSType ** SOAP_FMAC4 soap_in_PointerToxcfg__XProfileTLSType(struct soap *soap, const char *tag, xcfg__XProfileTLSType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__XProfileTLSType **)soap_malloc(soap, sizeof(xcfg__XProfileTLSType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__XProfileTLSType *)soap_instantiate_xcfg__XProfileTLSType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__XProfileTLSType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__XProfileTLSType, sizeof(xcfg__XProfileTLSType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__ManualPACType(struct soap *soap, xcfg__ManualPACType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__ManualPACType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__ManualPACType(struct soap *soap, xcfg__ManualPACType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__ManualPACType); + if (soap_out_PointerToxcfg__ManualPACType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__ManualPACType(struct soap *soap, const char *tag, int id, xcfg__ManualPACType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__ManualPACType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__ManualPACType ** SOAP_FMAC4 soap_get_PointerToxcfg__ManualPACType(struct soap *soap, xcfg__ManualPACType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__ManualPACType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__ManualPACType ** SOAP_FMAC4 soap_in_PointerToxcfg__ManualPACType(struct soap *soap, const char *tag, xcfg__ManualPACType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__ManualPACType **)soap_malloc(soap, sizeof(xcfg__ManualPACType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__ManualPACType *)soap_instantiate_xcfg__ManualPACType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__ManualPACType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__ManualPACType, sizeof(xcfg__ManualPACType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__UserCredentialsType(struct soap *soap, xcfg__UserCredentialsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__UserCredentialsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__UserCredentialsType(struct soap *soap, xcfg__UserCredentialsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__UserCredentialsType); + if (soap_out_PointerToxcfg__UserCredentialsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__UserCredentialsType(struct soap *soap, const char *tag, int id, xcfg__UserCredentialsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__UserCredentialsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__UserCredentialsType ** SOAP_FMAC4 soap_get_PointerToxcfg__UserCredentialsType(struct soap *soap, xcfg__UserCredentialsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__UserCredentialsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__UserCredentialsType ** SOAP_FMAC4 soap_in_PointerToxcfg__UserCredentialsType(struct soap *soap, const char *tag, xcfg__UserCredentialsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__UserCredentialsType **)soap_malloc(soap, sizeof(xcfg__UserCredentialsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__UserCredentialsType *)soap_instantiate_xcfg__UserCredentialsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__UserCredentialsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__UserCredentialsType, sizeof(xcfg__UserCredentialsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__ServerIdentityType(struct soap *soap, xcfg__ServerIdentityType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__ServerIdentityType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__ServerIdentityType(struct soap *soap, xcfg__ServerIdentityType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__ServerIdentityType); + if (soap_out_PointerToxcfg__ServerIdentityType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__ServerIdentityType(struct soap *soap, const char *tag, int id, xcfg__ServerIdentityType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__ServerIdentityType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__ServerIdentityType ** SOAP_FMAC4 soap_get_PointerToxcfg__ServerIdentityType(struct soap *soap, xcfg__ServerIdentityType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__ServerIdentityType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__ServerIdentityType ** SOAP_FMAC4 soap_in_PointerToxcfg__ServerIdentityType(struct soap *soap, const char *tag, xcfg__ServerIdentityType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__ServerIdentityType **)soap_malloc(soap, sizeof(xcfg__ServerIdentityType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__ServerIdentityType *)soap_instantiate_xcfg__ServerIdentityType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__ServerIdentityType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__ServerIdentityType, sizeof(xcfg__ServerIdentityType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToxcfg__CertificateNameType(struct soap *soap, xcfg__CertificateNameType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_xcfg__CertificateNameType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToxcfg__CertificateNameType(struct soap *soap, xcfg__CertificateNameType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToxcfg__CertificateNameType); + if (soap_out_PointerToxcfg__CertificateNameType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToxcfg__CertificateNameType(struct soap *soap, const char *tag, int id, xcfg__CertificateNameType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_xcfg__CertificateNameType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 xcfg__CertificateNameType ** SOAP_FMAC4 soap_get_PointerToxcfg__CertificateNameType(struct soap *soap, xcfg__CertificateNameType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerToxcfg__CertificateNameType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xcfg__CertificateNameType ** SOAP_FMAC4 soap_in_PointerToxcfg__CertificateNameType(struct soap *soap, const char *tag, xcfg__CertificateNameType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xcfg__CertificateNameType **)soap_malloc(soap, sizeof(xcfg__CertificateNameType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (xcfg__CertificateNameType *)soap_instantiate_xcfg__CertificateNameType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (xcfg__CertificateNameType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_xcfg__CertificateNameType, sizeof(xcfg__CertificateNameType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CertificateHandleType(struct soap *soap, unsigned int *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_sai__CertificateHandleType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CertificateHandleType(struct soap *soap, unsigned int *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__CertificateHandleType); + if (soap_out_PointerTosai__CertificateHandleType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CertificateHandleType(struct soap *soap, const char *tag, int id, unsigned int *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__CertificateHandleType); + if (id < 0) + return soap->error; + return soap_out_sai__CertificateHandleType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_get_PointerTosai__CertificateHandleType(struct soap *soap, unsigned int **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__CertificateHandleType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTosai__CertificateHandleType(struct soap *soap, const char *tag, unsigned int **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned int **)soap_malloc(soap, sizeof(unsigned int *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_sai__CertificateHandleType(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned int **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__CertificateHandleType, sizeof(unsigned int), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocstr__KeyPairType(struct soap *soap, cstr__KeyPairType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cstr__KeyPairType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocstr__KeyPairType(struct soap *soap, cstr__KeyPairType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocstr__KeyPairType); + if (soap_out_PointerTocstr__KeyPairType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocstr__KeyPairType(struct soap *soap, const char *tag, int id, cstr__KeyPairType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cstr__KeyPairType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cstr__KeyPairType ** SOAP_FMAC4 soap_get_PointerTocstr__KeyPairType(struct soap *soap, cstr__KeyPairType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocstr__KeyPairType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cstr__KeyPairType ** SOAP_FMAC4 soap_in_PointerTocstr__KeyPairType(struct soap *soap, const char *tag, cstr__KeyPairType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cstr__KeyPairType **)soap_malloc(soap, sizeof(cstr__KeyPairType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cstr__KeyPairType *)soap_instantiate_cstr__KeyPairType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cstr__KeyPairType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cstr__KeyPairType, sizeof(cstr__KeyPairType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__GlobalPowerPolicyType(struct soap *soap, sai__GlobalPowerPolicyType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__GlobalPowerPolicyType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__GlobalPowerPolicyType(struct soap *soap, sai__GlobalPowerPolicyType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__GlobalPowerPolicyType); + if (soap_out_PointerTosai__GlobalPowerPolicyType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__GlobalPowerPolicyType(struct soap *soap, const char *tag, int id, sai__GlobalPowerPolicyType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__GlobalPowerPolicyType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__GlobalPowerPolicyType ** SOAP_FMAC4 soap_get_PointerTosai__GlobalPowerPolicyType(struct soap *soap, sai__GlobalPowerPolicyType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__GlobalPowerPolicyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__GlobalPowerPolicyType ** SOAP_FMAC4 soap_in_PointerTosai__GlobalPowerPolicyType(struct soap *soap, const char *tag, sai__GlobalPowerPolicyType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__GlobalPowerPolicyType **)soap_malloc(soap, sizeof(sai__GlobalPowerPolicyType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__GlobalPowerPolicyType *)soap_instantiate_sai__GlobalPowerPolicyType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__GlobalPowerPolicyType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__GlobalPowerPolicyType, sizeof(sai__GlobalPowerPolicyType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__EnvironmentDetectionType(struct soap *soap, sai__EnvironmentDetectionType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__EnvironmentDetectionType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__EnvironmentDetectionType(struct soap *soap, sai__EnvironmentDetectionType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__EnvironmentDetectionType); + if (soap_out_PointerTosai__EnvironmentDetectionType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__EnvironmentDetectionType(struct soap *soap, const char *tag, int id, sai__EnvironmentDetectionType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__EnvironmentDetectionType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__EnvironmentDetectionType ** SOAP_FMAC4 soap_get_PointerTosai__EnvironmentDetectionType(struct soap *soap, sai__EnvironmentDetectionType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__EnvironmentDetectionType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__EnvironmentDetectionType ** SOAP_FMAC4 soap_in_PointerTosai__EnvironmentDetectionType(struct soap *soap, const char *tag, sai__EnvironmentDetectionType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__EnvironmentDetectionType **)soap_malloc(soap, sizeof(sai__EnvironmentDetectionType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__EnvironmentDetectionType *)soap_instantiate_sai__EnvironmentDetectionType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__EnvironmentDetectionType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__EnvironmentDetectionType, sizeof(sai__EnvironmentDetectionType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__ProvisioningAuditRecordType(struct soap *soap, sai__ProvisioningAuditRecordType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__ProvisioningAuditRecordType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__ProvisioningAuditRecordType(struct soap *soap, sai__ProvisioningAuditRecordType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__ProvisioningAuditRecordType); + if (soap_out_PointerTosai__ProvisioningAuditRecordType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__ProvisioningAuditRecordType(struct soap *soap, const char *tag, int id, sai__ProvisioningAuditRecordType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__ProvisioningAuditRecordType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__ProvisioningAuditRecordType ** SOAP_FMAC4 soap_get_PointerTosai__ProvisioningAuditRecordType(struct soap *soap, sai__ProvisioningAuditRecordType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__ProvisioningAuditRecordType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__ProvisioningAuditRecordType ** SOAP_FMAC4 soap_in_PointerTosai__ProvisioningAuditRecordType(struct soap *soap, const char *tag, sai__ProvisioningAuditRecordType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__ProvisioningAuditRecordType **)soap_malloc(soap, sizeof(sai__ProvisioningAuditRecordType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__ProvisioningAuditRecordType *)soap_instantiate_sai__ProvisioningAuditRecordType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__ProvisioningAuditRecordType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__ProvisioningAuditRecordType, sizeof(sai__ProvisioningAuditRecordType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CertHashEntryType(struct soap *soap, sai__CertHashEntryType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__CertHashEntryType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CertHashEntryType(struct soap *soap, sai__CertHashEntryType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__CertHashEntryType); + if (soap_out_PointerTosai__CertHashEntryType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CertHashEntryType(struct soap *soap, const char *tag, int id, sai__CertHashEntryType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__CertHashEntryType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__CertHashEntryType ** SOAP_FMAC4 soap_get_PointerTosai__CertHashEntryType(struct soap *soap, sai__CertHashEntryType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__CertHashEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__CertHashEntryType ** SOAP_FMAC4 soap_in_PointerTosai__CertHashEntryType(struct soap *soap, const char *tag, sai__CertHashEntryType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__CertHashEntryType **)soap_malloc(soap, sizeof(sai__CertHashEntryType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__CertHashEntryType *)soap_instantiate_sai__CertHashEntryType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__CertHashEntryType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__CertHashEntryType, sizeof(sai__CertHashEntryType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__ProvisioningOTPType(struct soap *soap, xsd__base64Binary *const*a) +{ + if (*a) + soap_serialize_sai__ProvisioningOTPType(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__ProvisioningOTPType(struct soap *soap, xsd__base64Binary *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__ProvisioningOTPType); + if (soap_out_PointerTosai__ProvisioningOTPType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__ProvisioningOTPType(struct soap *soap, const char *tag, int id, xsd__base64Binary *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, (struct soap_array*)&(*a)->__ptr, 1, type, SOAP_TYPE_sai__ProvisioningOTPType); + if (id < 0) + return soap->error; + return soap_out_sai__ProvisioningOTPType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_get_PointerTosai__ProvisioningOTPType(struct soap *soap, xsd__base64Binary **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__ProvisioningOTPType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 xsd__base64Binary ** SOAP_FMAC4 soap_in_PointerTosai__ProvisioningOTPType(struct soap *soap, const char *tag, xsd__base64Binary **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (xsd__base64Binary **)soap_malloc(soap, sizeof(xsd__base64Binary *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_sai__ProvisioningOTPType(soap, tag, *a, type))) + return NULL; + } + else + { a = (xsd__base64Binary **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__ProvisioningOTPType, sizeof(xsd__base64Binary), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTounsignedShort(struct soap *soap, unsigned short *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_unsignedShort); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTounsignedShort(struct soap *soap, unsigned short *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTounsignedShort); + if (soap_out_PointerTounsignedShort(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTounsignedShort(struct soap *soap, const char *tag, int id, unsigned short *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_unsignedShort); + if (id < 0) + return soap->error; + return soap_out_unsignedShort(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_get_PointerTounsignedShort(struct soap *soap, unsigned short **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTounsignedShort(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned short ** SOAP_FMAC4 soap_in_PointerTounsignedShort(struct soap *soap, const char *tag, unsigned short **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned short **)soap_malloc(soap, sizeof(unsigned short *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_unsignedShort(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned short **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_unsignedShort, sizeof(unsigned short), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__PowerStateType(struct soap *soap, enum sai__PowerStateType *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_sai__PowerStateType); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__PowerStateType(struct soap *soap, enum sai__PowerStateType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__PowerStateType); + if (soap_out_PointerTosai__PowerStateType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__PowerStateType(struct soap *soap, const char *tag, int id, enum sai__PowerStateType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__PowerStateType); + if (id < 0) + return soap->error; + return soap_out_sai__PowerStateType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 enum sai__PowerStateType ** SOAP_FMAC4 soap_get_PointerTosai__PowerStateType(struct soap *soap, enum sai__PowerStateType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__PowerStateType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 enum sai__PowerStateType ** SOAP_FMAC4 soap_in_PointerTosai__PowerStateType(struct soap *soap, const char *tag, enum sai__PowerStateType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (enum sai__PowerStateType **)soap_malloc(soap, sizeof(enum sai__PowerStateType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_sai__PowerStateType(soap, tag, *a, type))) + return NULL; + } + else + { a = (enum sai__PowerStateType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__PowerStateType, sizeof(enum sai__PowerStateType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__PkiCapsType(struct soap *soap, sai__PkiCapsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__PkiCapsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__PkiCapsType(struct soap *soap, sai__PkiCapsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__PkiCapsType); + if (soap_out_PointerTosai__PkiCapsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__PkiCapsType(struct soap *soap, const char *tag, int id, sai__PkiCapsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__PkiCapsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__PkiCapsType ** SOAP_FMAC4 soap_get_PointerTosai__PkiCapsType(struct soap *soap, sai__PkiCapsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__PkiCapsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__PkiCapsType ** SOAP_FMAC4 soap_in_PointerTosai__PkiCapsType(struct soap *soap, const char *tag, sai__PkiCapsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__PkiCapsType **)soap_malloc(soap, sizeof(sai__PkiCapsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__PkiCapsType *)soap_instantiate_sai__PkiCapsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__PkiCapsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__PkiCapsType, sizeof(sai__PkiCapsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CrlType(struct soap *soap, sai__CrlType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__CrlType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CrlType(struct soap *soap, sai__CrlType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__CrlType); + if (soap_out_PointerTosai__CrlType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CrlType(struct soap *soap, const char *tag, int id, sai__CrlType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__CrlType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__CrlType ** SOAP_FMAC4 soap_get_PointerTosai__CrlType(struct soap *soap, sai__CrlType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__CrlType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__CrlType ** SOAP_FMAC4 soap_in_PointerTosai__CrlType(struct soap *soap, const char *tag, sai__CrlType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__CrlType **)soap_malloc(soap, sizeof(sai__CrlType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__CrlType *)soap_instantiate_sai__CrlType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__CrlType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__CrlType, sizeof(sai__CrlType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CertificateType(struct soap *soap, sai__CertificateType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__CertificateType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CertificateType(struct soap *soap, sai__CertificateType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__CertificateType); + if (soap_out_PointerTosai__CertificateType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CertificateType(struct soap *soap, const char *tag, int id, sai__CertificateType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__CertificateType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__CertificateType ** SOAP_FMAC4 soap_get_PointerTosai__CertificateType(struct soap *soap, sai__CertificateType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__CertificateType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__CertificateType ** SOAP_FMAC4 soap_in_PointerTosai__CertificateType(struct soap *soap, const char *tag, sai__CertificateType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__CertificateType **)soap_malloc(soap, sizeof(sai__CertificateType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__CertificateType *)soap_instantiate_sai__CertificateType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__CertificateType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__CertificateType, sizeof(sai__CertificateType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__TlsOptionsType(struct soap *soap, sai__TlsOptionsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__TlsOptionsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__TlsOptionsType(struct soap *soap, sai__TlsOptionsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__TlsOptionsType); + if (soap_out_PointerTosai__TlsOptionsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__TlsOptionsType(struct soap *soap, const char *tag, int id, sai__TlsOptionsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__TlsOptionsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__TlsOptionsType ** SOAP_FMAC4 soap_get_PointerTosai__TlsOptionsType(struct soap *soap, sai__TlsOptionsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__TlsOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__TlsOptionsType ** SOAP_FMAC4 soap_in_PointerTosai__TlsOptionsType(struct soap *soap, const char *tag, sai__TlsOptionsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__TlsOptionsType **)soap_malloc(soap, sizeof(sai__TlsOptionsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__TlsOptionsType *)soap_instantiate_sai__TlsOptionsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__TlsOptionsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__TlsOptionsType, sizeof(sai__TlsOptionsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__KerberosOptionsType(struct soap *soap, sai__KerberosOptionsType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__KerberosOptionsType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__KerberosOptionsType(struct soap *soap, sai__KerberosOptionsType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__KerberosOptionsType); + if (soap_out_PointerTosai__KerberosOptionsType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__KerberosOptionsType(struct soap *soap, const char *tag, int id, sai__KerberosOptionsType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__KerberosOptionsType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__KerberosOptionsType ** SOAP_FMAC4 soap_get_PointerTosai__KerberosOptionsType(struct soap *soap, sai__KerberosOptionsType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__KerberosOptionsType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__KerberosOptionsType ** SOAP_FMAC4 soap_in_PointerTosai__KerberosOptionsType(struct soap *soap, const char *tag, sai__KerberosOptionsType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__KerberosOptionsType **)soap_malloc(soap, sizeof(sai__KerberosOptionsType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__KerberosOptionsType *)soap_instantiate_sai__KerberosOptionsType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__KerberosOptionsType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__KerberosOptionsType, sizeof(sai__KerberosOptionsType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__AdminAclEntryExType(struct soap *soap, sai__AdminAclEntryExType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__AdminAclEntryExType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__AdminAclEntryExType(struct soap *soap, sai__AdminAclEntryExType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__AdminAclEntryExType); + if (soap_out_PointerTosai__AdminAclEntryExType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__AdminAclEntryExType(struct soap *soap, const char *tag, int id, sai__AdminAclEntryExType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__AdminAclEntryExType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__AdminAclEntryExType ** SOAP_FMAC4 soap_get_PointerTosai__AdminAclEntryExType(struct soap *soap, sai__AdminAclEntryExType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__AdminAclEntryExType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__AdminAclEntryExType ** SOAP_FMAC4 soap_in_PointerTosai__AdminAclEntryExType(struct soap *soap, const char *tag, sai__AdminAclEntryExType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__AdminAclEntryExType **)soap_malloc(soap, sizeof(sai__AdminAclEntryExType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__AdminAclEntryExType *)soap_instantiate_sai__AdminAclEntryExType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__AdminAclEntryExType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__AdminAclEntryExType, sizeof(sai__AdminAclEntryExType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserAclEntryExType(struct soap *soap, sai__UserAclEntryExType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__UserAclEntryExType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserAclEntryExType(struct soap *soap, sai__UserAclEntryExType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__UserAclEntryExType); + if (soap_out_PointerTosai__UserAclEntryExType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserAclEntryExType(struct soap *soap, const char *tag, int id, sai__UserAclEntryExType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__UserAclEntryExType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__UserAclEntryExType ** SOAP_FMAC4 soap_get_PointerTosai__UserAclEntryExType(struct soap *soap, sai__UserAclEntryExType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__UserAclEntryExType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__UserAclEntryExType ** SOAP_FMAC4 soap_in_PointerTosai__UserAclEntryExType(struct soap *soap, const char *tag, sai__UserAclEntryExType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__UserAclEntryExType **)soap_malloc(soap, sizeof(sai__UserAclEntryExType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__UserAclEntryExType *)soap_instantiate_sai__UserAclEntryExType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__UserAclEntryExType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__UserAclEntryExType, sizeof(sai__UserAclEntryExType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UpdateCoreUrlKeyType(struct soap *soap, sai__UpdateCoreUrlKeyType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__UpdateCoreUrlKeyType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UpdateCoreUrlKeyType(struct soap *soap, sai__UpdateCoreUrlKeyType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__UpdateCoreUrlKeyType); + if (soap_out_PointerTosai__UpdateCoreUrlKeyType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UpdateCoreUrlKeyType(struct soap *soap, const char *tag, int id, sai__UpdateCoreUrlKeyType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__UpdateCoreUrlKeyType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__UpdateCoreUrlKeyType ** SOAP_FMAC4 soap_get_PointerTosai__UpdateCoreUrlKeyType(struct soap *soap, sai__UpdateCoreUrlKeyType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__UpdateCoreUrlKeyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__UpdateCoreUrlKeyType ** SOAP_FMAC4 soap_in_PointerTosai__UpdateCoreUrlKeyType(struct soap *soap, const char *tag, sai__UpdateCoreUrlKeyType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__UpdateCoreUrlKeyType **)soap_malloc(soap, sizeof(sai__UpdateCoreUrlKeyType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__UpdateCoreUrlKeyType *)soap_instantiate_sai__UpdateCoreUrlKeyType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__UpdateCoreUrlKeyType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__UpdateCoreUrlKeyType, sizeof(sai__UpdateCoreUrlKeyType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__AmtVersion(struct soap *soap, sai__AmtVersion *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__AmtVersion)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__AmtVersion(struct soap *soap, sai__AmtVersion *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__AmtVersion); + if (soap_out_PointerTosai__AmtVersion(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__AmtVersion(struct soap *soap, const char *tag, int id, sai__AmtVersion *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__AmtVersion); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__AmtVersion ** SOAP_FMAC4 soap_get_PointerTosai__AmtVersion(struct soap *soap, sai__AmtVersion **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__AmtVersion(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__AmtVersion ** SOAP_FMAC4 soap_in_PointerTosai__AmtVersion(struct soap *soap, const char *tag, sai__AmtVersion **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__AmtVersion **)soap_malloc(soap, sizeof(sai__AmtVersion *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__AmtVersion *)soap_instantiate_sai__AmtVersion(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__AmtVersion **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__AmtVersion, sizeof(sai__AmtVersion), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__RngKeyType(struct soap *soap, sai__RngKeyType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__RngKeyType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__RngKeyType(struct soap *soap, sai__RngKeyType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__RngKeyType); + if (soap_out_PointerTosai__RngKeyType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__RngKeyType(struct soap *soap, const char *tag, int id, sai__RngKeyType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__RngKeyType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__RngKeyType ** SOAP_FMAC4 soap_get_PointerTosai__RngKeyType(struct soap *soap, sai__RngKeyType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__RngKeyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__RngKeyType ** SOAP_FMAC4 soap_in_PointerTosai__RngKeyType(struct soap *soap, const char *tag, sai__RngKeyType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__RngKeyType **)soap_malloc(soap, sizeof(sai__RngKeyType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__RngKeyType *)soap_instantiate_sai__RngKeyType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__RngKeyType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__RngKeyType, sizeof(sai__RngKeyType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__CertificateChainType(struct soap *soap, sai__CertificateChainType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__CertificateChainType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__CertificateChainType(struct soap *soap, sai__CertificateChainType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__CertificateChainType); + if (soap_out_PointerTosai__CertificateChainType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__CertificateChainType(struct soap *soap, const char *tag, int id, sai__CertificateChainType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__CertificateChainType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__CertificateChainType ** SOAP_FMAC4 soap_get_PointerTosai__CertificateChainType(struct soap *soap, sai__CertificateChainType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__CertificateChainType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__CertificateChainType ** SOAP_FMAC4 soap_in_PointerTosai__CertificateChainType(struct soap *soap, const char *tag, sai__CertificateChainType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__CertificateChainType **)soap_malloc(soap, sizeof(sai__CertificateChainType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__CertificateChainType *)soap_instantiate_sai__CertificateChainType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__CertificateChainType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__CertificateChainType, sizeof(sai__CertificateChainType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__RsaKeyType(struct soap *soap, sai__RsaKeyType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__RsaKeyType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__RsaKeyType(struct soap *soap, sai__RsaKeyType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__RsaKeyType); + if (soap_out_PointerTosai__RsaKeyType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__RsaKeyType(struct soap *soap, const char *tag, int id, sai__RsaKeyType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__RsaKeyType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__RsaKeyType ** SOAP_FMAC4 soap_get_PointerTosai__RsaKeyType(struct soap *soap, sai__RsaKeyType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__RsaKeyType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__RsaKeyType ** SOAP_FMAC4 soap_in_PointerTosai__RsaKeyType(struct soap *soap, const char *tag, sai__RsaKeyType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__RsaKeyType **)soap_malloc(soap, sizeof(sai__RsaKeyType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__RsaKeyType *)soap_instantiate_sai__RsaKeyType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__RsaKeyType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__RsaKeyType, sizeof(sai__RsaKeyType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserAclEntryHandleListType(struct soap *soap, sai__UserAclEntryHandleListType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__UserAclEntryHandleListType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserAclEntryHandleListType(struct soap *soap, sai__UserAclEntryHandleListType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__UserAclEntryHandleListType); + if (soap_out_PointerTosai__UserAclEntryHandleListType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserAclEntryHandleListType(struct soap *soap, const char *tag, int id, sai__UserAclEntryHandleListType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__UserAclEntryHandleListType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__UserAclEntryHandleListType ** SOAP_FMAC4 soap_get_PointerTosai__UserAclEntryHandleListType(struct soap *soap, sai__UserAclEntryHandleListType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__UserAclEntryHandleListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__UserAclEntryHandleListType ** SOAP_FMAC4 soap_in_PointerTosai__UserAclEntryHandleListType(struct soap *soap, const char *tag, sai__UserAclEntryHandleListType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__UserAclEntryHandleListType **)soap_malloc(soap, sizeof(sai__UserAclEntryHandleListType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__UserAclEntryHandleListType *)soap_instantiate_sai__UserAclEntryHandleListType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__UserAclEntryHandleListType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__UserAclEntryHandleListType, sizeof(sai__UserAclEntryHandleListType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__AdminAclEntryType(struct soap *soap, sai__AdminAclEntryType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__AdminAclEntryType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__AdminAclEntryType(struct soap *soap, sai__AdminAclEntryType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__AdminAclEntryType); + if (soap_out_PointerTosai__AdminAclEntryType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__AdminAclEntryType(struct soap *soap, const char *tag, int id, sai__AdminAclEntryType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__AdminAclEntryType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__AdminAclEntryType ** SOAP_FMAC4 soap_get_PointerTosai__AdminAclEntryType(struct soap *soap, sai__AdminAclEntryType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__AdminAclEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__AdminAclEntryType ** SOAP_FMAC4 soap_in_PointerTosai__AdminAclEntryType(struct soap *soap, const char *tag, sai__AdminAclEntryType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__AdminAclEntryType **)soap_malloc(soap, sizeof(sai__AdminAclEntryType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__AdminAclEntryType *)soap_instantiate_sai__AdminAclEntryType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__AdminAclEntryType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__AdminAclEntryType, sizeof(sai__AdminAclEntryType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserAclEntryType(struct soap *soap, sai__UserAclEntryType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__UserAclEntryType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserAclEntryType(struct soap *soap, sai__UserAclEntryType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__UserAclEntryType); + if (soap_out_PointerTosai__UserAclEntryType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserAclEntryType(struct soap *soap, const char *tag, int id, sai__UserAclEntryType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__UserAclEntryType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__UserAclEntryType ** SOAP_FMAC4 soap_get_PointerTosai__UserAclEntryType(struct soap *soap, sai__UserAclEntryType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__UserAclEntryType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__UserAclEntryType ** SOAP_FMAC4 soap_in_PointerTosai__UserAclEntryType(struct soap *soap, const char *tag, sai__UserAclEntryType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__UserAclEntryType **)soap_malloc(soap, sizeof(sai__UserAclEntryType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__UserAclEntryType *)soap_instantiate_sai__UserAclEntryType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__UserAclEntryType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__UserAclEntryType, sizeof(sai__UserAclEntryType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTounsignedInt(struct soap *soap, unsigned int *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_unsignedInt); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTounsignedInt(struct soap *soap, unsigned int *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTounsignedInt); + if (soap_out_PointerTounsignedInt(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTounsignedInt(struct soap *soap, const char *tag, int id, unsigned int *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_unsignedInt); + if (id < 0) + return soap->error; + return soap_out_unsignedInt(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_get_PointerTounsignedInt(struct soap *soap, unsigned int **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTounsignedInt(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned int ** SOAP_FMAC4 soap_in_PointerTounsignedInt(struct soap *soap, const char *tag, unsigned int **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned int **)soap_malloc(soap, sizeof(unsigned int *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_unsignedInt(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned int **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_unsignedInt, sizeof(unsigned int), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__EnvironmentDetectionDomainType(struct soap *soap, sai__EnvironmentDetectionDomainType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__EnvironmentDetectionDomainType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__EnvironmentDetectionDomainType(struct soap *soap, sai__EnvironmentDetectionDomainType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__EnvironmentDetectionDomainType); + if (soap_out_PointerTosai__EnvironmentDetectionDomainType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__EnvironmentDetectionDomainType(struct soap *soap, const char *tag, int id, sai__EnvironmentDetectionDomainType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__EnvironmentDetectionDomainType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__EnvironmentDetectionDomainType ** SOAP_FMAC4 soap_get_PointerTosai__EnvironmentDetectionDomainType(struct soap *soap, sai__EnvironmentDetectionDomainType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__EnvironmentDetectionDomainType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__EnvironmentDetectionDomainType ** SOAP_FMAC4 soap_in_PointerTosai__EnvironmentDetectionDomainType(struct soap *soap, const char *tag, sai__EnvironmentDetectionDomainType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__EnvironmentDetectionDomainType **)soap_malloc(soap, sizeof(sai__EnvironmentDetectionDomainType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__EnvironmentDetectionDomainType *)soap_instantiate_sai__EnvironmentDetectionDomainType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__EnvironmentDetectionDomainType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__EnvironmentDetectionDomainType, sizeof(sai__EnvironmentDetectionDomainType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTobool(struct soap *soap, bool *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_bool); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTobool(struct soap *soap, bool *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTobool); + if (soap_out_PointerTobool(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTobool(struct soap *soap, const char *tag, int id, bool *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_bool); + if (id < 0) + return soap->error; + return soap_out_bool(soap, tag, id, *a, type); +} + +SOAP_FMAC3 bool ** SOAP_FMAC4 soap_get_PointerTobool(struct soap *soap, bool **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTobool(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 bool ** SOAP_FMAC4 soap_in_PointerTobool(struct soap *soap, const char *tag, bool **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (bool **)soap_malloc(soap, sizeof(bool *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_bool(soap, tag, *a, type))) + return NULL; + } + else + { a = (bool **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_bool, sizeof(bool), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTostd__string(struct soap *soap, std::string *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_std__string)) + soap_serialize_std__string(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTostd__string(struct soap *soap, std::string *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTostd__string); + if (soap_out_PointerTostd__string(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTostd__string(struct soap *soap, const char *tag, int id, std::string *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_std__string); + if (id < 0) + return soap->error; + return soap_out_std__string(soap, tag, id, *a, type); +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTostd__string(struct soap *soap, std::string **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTostd__string(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTostd__string(struct soap *soap, const char *tag, std::string **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (std::string **)soap_malloc(soap, sizeof(std::string *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_std__string(soap, tag, *a, type))) + return NULL; + } + else + { a = (std::string **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_std__string, sizeof(std::string), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__KerberosSpnType(struct soap *soap, sai__KerberosSpnType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__KerberosSpnType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__KerberosSpnType(struct soap *soap, sai__KerberosSpnType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__KerberosSpnType); + if (soap_out_PointerTosai__KerberosSpnType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__KerberosSpnType(struct soap *soap, const char *tag, int id, sai__KerberosSpnType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__KerberosSpnType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__KerberosSpnType ** SOAP_FMAC4 soap_get_PointerTosai__KerberosSpnType(struct soap *soap, sai__KerberosSpnType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__KerberosSpnType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__KerberosSpnType ** SOAP_FMAC4 soap_in_PointerTosai__KerberosSpnType(struct soap *soap, const char *tag, sai__KerberosSpnType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__KerberosSpnType **)soap_malloc(soap, sizeof(sai__KerberosSpnType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__KerberosSpnType *)soap_instantiate_sai__KerberosSpnType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__KerberosSpnType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__KerberosSpnType, sizeof(sai__KerberosSpnType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserEntryKerberosType(struct soap *soap, sai__UserEntryKerberosType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__UserEntryKerberosType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserEntryKerberosType(struct soap *soap, sai__UserEntryKerberosType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__UserEntryKerberosType); + if (soap_out_PointerTosai__UserEntryKerberosType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserEntryKerberosType(struct soap *soap, const char *tag, int id, sai__UserEntryKerberosType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__UserEntryKerberosType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__UserEntryKerberosType ** SOAP_FMAC4 soap_get_PointerTosai__UserEntryKerberosType(struct soap *soap, sai__UserEntryKerberosType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__UserEntryKerberosType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__UserEntryKerberosType ** SOAP_FMAC4 soap_in_PointerTosai__UserEntryKerberosType(struct soap *soap, const char *tag, sai__UserEntryKerberosType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__UserEntryKerberosType **)soap_malloc(soap, sizeof(sai__UserEntryKerberosType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__UserEntryKerberosType *)soap_instantiate_sai__UserEntryKerberosType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__UserEntryKerberosType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__UserEntryKerberosType, sizeof(sai__UserEntryKerberosType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserEntryDigestType(struct soap *soap, sai__UserEntryDigestType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__UserEntryDigestType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserEntryDigestType(struct soap *soap, sai__UserEntryDigestType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__UserEntryDigestType); + if (soap_out_PointerTosai__UserEntryDigestType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserEntryDigestType(struct soap *soap, const char *tag, int id, sai__UserEntryDigestType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__UserEntryDigestType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__UserEntryDigestType ** SOAP_FMAC4 soap_get_PointerTosai__UserEntryDigestType(struct soap *soap, sai__UserEntryDigestType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__UserEntryDigestType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__UserEntryDigestType ** SOAP_FMAC4 soap_in_PointerTosai__UserEntryDigestType(struct soap *soap, const char *tag, sai__UserEntryDigestType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__UserEntryDigestType **)soap_malloc(soap, sizeof(sai__UserEntryDigestType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__UserEntryDigestType *)soap_instantiate_sai__UserEntryDigestType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__UserEntryDigestType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__UserEntryDigestType, sizeof(sai__UserEntryDigestType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTosai__UserAclRealmListType(struct soap *soap, sai__UserAclRealmListType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_sai__UserAclRealmListType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTosai__UserAclRealmListType(struct soap *soap, sai__UserAclRealmListType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTosai__UserAclRealmListType); + if (soap_out_PointerTosai__UserAclRealmListType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTosai__UserAclRealmListType(struct soap *soap, const char *tag, int id, sai__UserAclRealmListType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_sai__UserAclRealmListType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 sai__UserAclRealmListType ** SOAP_FMAC4 soap_get_PointerTosai__UserAclRealmListType(struct soap *soap, sai__UserAclRealmListType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTosai__UserAclRealmListType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 sai__UserAclRealmListType ** SOAP_FMAC4 soap_in_PointerTosai__UserAclRealmListType(struct soap *soap, const char *tag, sai__UserAclRealmListType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (sai__UserAclRealmListType **)soap_malloc(soap, sizeof(sai__UserAclRealmListType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (sai__UserAclRealmListType *)soap_instantiate_sai__UserAclRealmListType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (sai__UserAclRealmListType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_sai__UserAclRealmListType, sizeof(sai__UserAclRealmListType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocstr__RSAKeyPairType(struct soap *soap, cstr__RSAKeyPairType *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cstr__RSAKeyPairType)) + (*a)->soap_serialize(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocstr__RSAKeyPairType(struct soap *soap, cstr__RSAKeyPairType *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocstr__RSAKeyPairType); + if (soap_out_PointerTocstr__RSAKeyPairType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocstr__RSAKeyPairType(struct soap *soap, const char *tag, int id, cstr__RSAKeyPairType *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cstr__RSAKeyPairType); + if (id < 0) + return soap->error; + return (*a)->soap_out(soap, tag, id, type); +} + +SOAP_FMAC3 cstr__RSAKeyPairType ** SOAP_FMAC4 soap_get_PointerTocstr__RSAKeyPairType(struct soap *soap, cstr__RSAKeyPairType **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocstr__RSAKeyPairType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 cstr__RSAKeyPairType ** SOAP_FMAC4 soap_in_PointerTocstr__RSAKeyPairType(struct soap *soap, const char *tag, cstr__RSAKeyPairType **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (cstr__RSAKeyPairType **)soap_malloc(soap, sizeof(cstr__RSAKeyPairType *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = (cstr__RSAKeyPairType *)soap_instantiate_cstr__RSAKeyPairType(soap, -1, soap->type, soap->arrayType, NULL))) + return NULL; + (*a)->soap_default(soap); + if (!(*a)->soap_in(soap, tag, NULL)) + return NULL; + } + else + { a = (cstr__RSAKeyPairType **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cstr__RSAKeyPairType, sizeof(cstr__RSAKeyPairType), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__IPv6AddressStringType(struct soap *soap, std::string *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cmn__IPv6AddressStringType)) + soap_serialize_cmn__IPv6AddressStringType(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__IPv6AddressStringType(struct soap *soap, std::string *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocmn__IPv6AddressStringType); + if (soap_out_PointerTocmn__IPv6AddressStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__IPv6AddressStringType(struct soap *soap, const char *tag, int id, std::string *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cmn__IPv6AddressStringType); + if (id < 0) + return soap->error; + return soap_out_cmn__IPv6AddressStringType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTocmn__IPv6AddressStringType(struct soap *soap, std::string **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocmn__IPv6AddressStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTocmn__IPv6AddressStringType(struct soap *soap, const char *tag, std::string **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (std::string **)soap_malloc(soap, sizeof(std::string *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_cmn__IPv6AddressStringType(soap, tag, *a, type))) + return NULL; + } + else + { a = (std::string **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cmn__IPv6AddressStringType, sizeof(std::string), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__IPv4AddressStringType(struct soap *soap, std::string *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cmn__IPv4AddressStringType)) + soap_serialize_cmn__IPv4AddressStringType(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__IPv4AddressStringType(struct soap *soap, std::string *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocmn__IPv4AddressStringType); + if (soap_out_PointerTocmn__IPv4AddressStringType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__IPv4AddressStringType(struct soap *soap, const char *tag, int id, std::string *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cmn__IPv4AddressStringType); + if (id < 0) + return soap->error; + return soap_out_cmn__IPv4AddressStringType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTocmn__IPv4AddressStringType(struct soap *soap, std::string **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocmn__IPv4AddressStringType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTocmn__IPv4AddressStringType(struct soap *soap, const char *tag, std::string **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (std::string **)soap_malloc(soap, sizeof(std::string *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_cmn__IPv4AddressStringType(soap, tag, *a, type))) + return NULL; + } + else + { a = (std::string **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cmn__IPv4AddressStringType, sizeof(std::string), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTocmn__HostNameType(struct soap *soap, std::string *const*a) +{ + if (!soap_reference(soap, *a, SOAP_TYPE_cmn__HostNameType)) + soap_serialize_cmn__HostNameType(soap, *a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTocmn__HostNameType(struct soap *soap, std::string *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTocmn__HostNameType); + if (soap_out_PointerTocmn__HostNameType(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTocmn__HostNameType(struct soap *soap, const char *tag, int id, std::string *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_cmn__HostNameType); + if (id < 0) + return soap->error; + return soap_out_cmn__HostNameType(soap, tag, id, *a, type); +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_get_PointerTocmn__HostNameType(struct soap *soap, std::string **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTocmn__HostNameType(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 std::string ** SOAP_FMAC4 soap_in_PointerTocmn__HostNameType(struct soap *soap, const char *tag, std::string **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (std::string **)soap_malloc(soap, sizeof(std::string *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_cmn__HostNameType(soap, tag, *a, type))) + return NULL; + } + else + { a = (std::string **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_cmn__HostNameType, sizeof(std::string), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTounsignedByte(struct soap *soap, unsigned char *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_unsignedByte); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTounsignedByte(struct soap *soap, unsigned char *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerTounsignedByte); + if (soap_out_PointerTounsignedByte(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTounsignedByte(struct soap *soap, const char *tag, int id, unsigned char *const*a, const char *type) +{ + id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_unsignedByte); + if (id < 0) + return soap->error; + return soap_out_unsignedByte(soap, tag, id, *a, type); +} + +SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_get_PointerTounsignedByte(struct soap *soap, unsigned char **p, const char *tag, const char *type) +{ + if ((p = soap_in_PointerTounsignedByte(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_in_PointerTounsignedByte(struct soap *soap, const char *tag, unsigned char **a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a) + if (!(a = (unsigned char **)soap_malloc(soap, sizeof(unsigned char *)))) + return NULL; + *a = NULL; + if (!soap->null && *soap->href != '#') + { soap_revert(soap); + if (!(*a = soap_in_unsignedByte(soap, tag, *a, type))) + return NULL; + } + else + { a = (unsigned char **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_unsignedByte, sizeof(unsigned char), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + } + return a; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default__QName(struct soap *soap, char **a) +{ soap_default_string(soap, a); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap *soap, char *const*a) +{ soap_serialize_string(soap, a); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__QName); + if (soap_out__QName(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type) +{ + return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName); +} + +SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type) +{ + if ((p = soap_in__QName(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type) +{ + return soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, -1, -1); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a) +{ (void)soap; /* appease -Wall -Werror */ +#ifdef SOAP_DEFAULT_string + *a = SOAP_DEFAULT_string; +#else + *a = (char *)0; +#endif +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a) +{ + soap_reference(soap, *a, SOAP_TYPE_string); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type) +{ + register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_string); + if (soap_out_string(soap, tag, id, a, type)) + return soap->error; + return soap_putindependent(soap); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type) +{ + return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string); +} + +SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type) +{ + if ((p = soap_in_string(soap, tag, p, type))) + soap_getindependent(soap); + return p; +} + +SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type) +{ + return soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, -1, -1); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfwcxs__ProfileNameType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_wcxs__ProfileNameType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfwcxs__ProfileNameType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfwcxs__ProfileNameType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_wcxs__ProfileNameType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfwcxs__ProfileNameType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfwcxs__ProfileNameType(soap, -1))) + return NULL; + std::string n; + std::string *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_wcxs__ProfileNameType, SOAP_TYPE_std__vectorTemplateOfwcxs__ProfileNameType, sizeof(std::string), 0)) + break; + if (!(p = soap_in_wcxs__ProfileNameType(soap, tag, NULL, "wcxs:ProfileNameType"))) + break; + } + else + { soap_default_wcxs__ProfileNameType(soap, &n); + if (!soap_in_wcxs__ProfileNameType(soap, tag, &n, "wcxs:ProfileNameType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfwcxs__ProfileNameType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfwcxs__ProfileNameType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfwcxs__ProfileNameType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfwcxs__ProfileNameType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfwcxs__ProfileNameType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfwcxs__ProfileNameType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfwcxs__ProfileNameType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfwcxs__FeatureType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfwcxs__FeatureType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfwcxs__FeatureType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_wcxs__FeatureType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfwcxs__FeatureType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfwcxs__FeatureType(soap, -1))) + return NULL; + enum wcxs__FeatureType n; + enum wcxs__FeatureType *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_wcxs__FeatureType, SOAP_TYPE_std__vectorTemplateOfwcxs__FeatureType, sizeof(enum wcxs__FeatureType), 0)) + break; + if (!(p = soap_in_wcxs__FeatureType(soap, tag, NULL, "wcxs:FeatureType"))) + break; + } + else + { soap_default_wcxs__FeatureType(soap, &n); + if (!soap_in_wcxs__FeatureType(soap, tag, &n, "wcxs:FeatureType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfwcxs__FeatureType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfwcxs__FeatureType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfwcxs__FeatureType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfwcxs__FeatureType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfwcxs__FeatureType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfwcxs__FeatureType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfwcxs__FeatureType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerToinf__IderSessionLogEntryType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerToinf__IderSessionLogEntryType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(soap, -1))) + return NULL; + inf__IderSessionLogEntryType *n; + inf__IderSessionLogEntryType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_inf__IderSessionLogEntryType, SOAP_TYPE_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType, sizeof(inf__IderSessionLogEntryType), 1)) + break; + if (!(p = soap_in_PointerToinf__IderSessionLogEntryType(soap, tag, NULL, "inf:IderSessionLogEntryType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerToinf__IderSessionLogEntryType(soap, tag, &n, "inf:IderSessionLogEntryType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToinf__IderSessionLogEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_inf__EnabledInterfacesType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfinf__EnabledInterfacesType(soap, -1))) + return NULL; + enum inf__EnabledInterfacesType n; + enum inf__EnabledInterfacesType *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_inf__EnabledInterfacesType, SOAP_TYPE_std__vectorTemplateOfinf__EnabledInterfacesType, sizeof(enum inf__EnabledInterfacesType), 0)) + break; + if (!(p = soap_in_inf__EnabledInterfacesType(soap, tag, NULL, "inf:EnabledInterfacesType"))) + break; + } + else + { soap_default_inf__EnabledInterfacesType(soap, &n); + if (!soap_in_inf__EnabledInterfacesType(soap, tag, &n, "inf:EnabledInterfacesType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfinf__EnabledInterfacesType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfinf__EnabledInterfacesType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfinf__EnabledInterfacesType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfinf__EnabledInterfacesType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerToinf__FirmwareVersionType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerToinf__FirmwareVersionType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerToinf__FirmwareVersionType(soap, -1))) + return NULL; + inf__FirmwareVersionType *n; + inf__FirmwareVersionType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_inf__FirmwareVersionType, SOAP_TYPE_std__vectorTemplateOfPointerToinf__FirmwareVersionType, sizeof(inf__FirmwareVersionType), 1)) + break; + if (!(p = soap_in_PointerToinf__FirmwareVersionType(soap, tag, NULL, "inf:FirmwareVersionType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerToinf__FirmwareVersionType(soap, tag, &n, "inf:FirmwareVersionType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerToinf__FirmwareVersionType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerToinf__FirmwareVersionType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerToinf__FirmwareVersionType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToinf__FirmwareVersionType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerToidr__IderSessionLogEntryType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerToidr__IderSessionLogEntryType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(soap, -1))) + return NULL; + idr__IderSessionLogEntryType *n; + idr__IderSessionLogEntryType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_idr__IderSessionLogEntryType, SOAP_TYPE_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType, sizeof(idr__IderSessionLogEntryType), 1)) + break; + if (!(p = soap_in_PointerToidr__IderSessionLogEntryType(soap, tag, NULL, "idr:IderSessionLogEntryType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerToidr__IderSessionLogEntryType(soap, tag, &n, "idr:IderSessionLogEntryType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToidr__IderSessionLogEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerToapr__CircuitBreakerHardwarePolicyType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerToapr__CircuitBreakerHardwarePolicyType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, -1))) + return NULL; + apr__CircuitBreakerHardwarePolicyType *n; + apr__CircuitBreakerHardwarePolicyType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_apr__CircuitBreakerHardwarePolicyType, SOAP_TYPE_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType, sizeof(apr__CircuitBreakerHardwarePolicyType), 1)) + break; + if (!(p = soap_in_PointerToapr__CircuitBreakerHardwarePolicyType(soap, tag, NULL, "apr:CircuitBreakerHardwarePolicyType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerToapr__CircuitBreakerHardwarePolicyType(soap, tag, &n, "apr:CircuitBreakerHardwarePolicyType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToapr__CircuitBreakerHardwarePolicyType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerToapr__ConsoleWatchdogActionType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerToapr__ConsoleWatchdogActionType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, -1))) + return NULL; + apr__ConsoleWatchdogActionType *n; + apr__ConsoleWatchdogActionType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_apr__ConsoleWatchdogActionType, SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType, sizeof(apr__ConsoleWatchdogActionType), 1)) + break; + if (!(p = soap_in_PointerToapr__ConsoleWatchdogActionType(soap, tag, NULL, "apr:ConsoleWatchdogActionType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerToapr__ConsoleWatchdogActionType(soap, tag, &n, "apr:ConsoleWatchdogActionType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToapr__ConsoleWatchdogActionType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerToapr__ConsoleWatchdogEntryType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerToapr__ConsoleWatchdogEntryType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(soap, -1))) + return NULL; + apr__ConsoleWatchdogEntryType *n; + apr__ConsoleWatchdogEntryType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_apr__ConsoleWatchdogEntryType, SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType, sizeof(apr__ConsoleWatchdogEntryType), 1)) + break; + if (!(p = soap_in_PointerToapr__ConsoleWatchdogEntryType(soap, tag, NULL, "apr:ConsoleWatchdogEntryType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerToapr__ConsoleWatchdogEntryType(soap, tag, &n, "apr:ConsoleWatchdogEntryType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToapr__ConsoleWatchdogEntryType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfunsignedShort(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfunsignedShort(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfunsignedShort(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_unsignedShort(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfunsignedShort(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfunsignedShort(soap, -1))) + return NULL; + unsigned short n; + unsigned short *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_unsignedShort, SOAP_TYPE_std__vectorTemplateOfunsignedShort, sizeof(unsigned short), 0)) + break; + if (!(p = soap_in_unsignedShort(soap, tag, NULL, "xsd:unsignedShort"))) + break; + } + else + { soap_default_unsignedShort(soap, &n); + if (!soap_in_unsignedShort(soap, tag, &n, "xsd:unsignedShort")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfunsignedShort(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfunsignedShort(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfunsignedShort(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfunsignedShort(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfunsignedShort(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfunsignedShort, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfunsignedShort(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerTohwa__AssetDataType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerTohwa__AssetDataType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerTohwa__AssetDataType(soap, -1))) + return NULL; + hwa__AssetDataType *n; + hwa__AssetDataType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_hwa__AssetDataType, SOAP_TYPE_std__vectorTemplateOfPointerTohwa__AssetDataType, sizeof(hwa__AssetDataType), 1)) + break; + if (!(p = soap_in_PointerTohwa__AssetDataType(soap, tag, NULL, "hwa:AssetDataType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerTohwa__AssetDataType(soap, tag, &n, "hwa:AssetDataType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerTohwa__AssetDataType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerTohwa__AssetDataType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerTohwa__AssetDataType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTohwa__AssetDataType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfhwa__AssetTypeType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfhwa__AssetTypeType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfhwa__AssetTypeType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_hwa__AssetTypeType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfhwa__AssetTypeType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfhwa__AssetTypeType(soap, -1))) + return NULL; + enum hwa__AssetTypeType n; + enum hwa__AssetTypeType *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_hwa__AssetTypeType, SOAP_TYPE_std__vectorTemplateOfhwa__AssetTypeType, sizeof(enum hwa__AssetTypeType), 0)) + break; + if (!(p = soap_in_hwa__AssetTypeType(soap, tag, NULL, "hwa:AssetTypeType"))) + break; + } + else + { soap_default_hwa__AssetTypeType(soap, &n); + if (!soap_in_hwa__AssetTypeType(soap, tag, &n, "hwa:AssetTypeType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfhwa__AssetTypeType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfhwa__AssetTypeType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfhwa__AssetTypeType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfhwa__AssetTypeType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfhwa__AssetTypeType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfhwa__AssetTypeType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfhwa__AssetTypeType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerTocb__CircuitBreakerCapabilitiesType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerTocb__CircuitBreakerCapabilitiesType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(soap, -1))) + return NULL; + cb__CircuitBreakerCapabilitiesType *n; + cb__CircuitBreakerCapabilitiesType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_cb__CircuitBreakerCapabilitiesType, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType, sizeof(cb__CircuitBreakerCapabilitiesType), 1)) + break; + if (!(p = soap_in_PointerTocb__CircuitBreakerCapabilitiesType(soap, tag, NULL, "cb:CircuitBreakerCapabilitiesType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerTocb__CircuitBreakerCapabilitiesType(soap, tag, &n, "cb:CircuitBreakerCapabilitiesType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerCapabilitiesType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerTocb__CircuitBreakerFilterInfoType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerTocb__CircuitBreakerFilterInfoType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(soap, -1))) + return NULL; + cb__CircuitBreakerFilterInfoType *n; + cb__CircuitBreakerFilterInfoType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_cb__CircuitBreakerFilterInfoType, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType, sizeof(cb__CircuitBreakerFilterInfoType), 1)) + break; + if (!(p = soap_in_PointerTocb__CircuitBreakerFilterInfoType(soap, tag, NULL, "cb:CircuitBreakerFilterInfoType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerTocb__CircuitBreakerFilterInfoType(soap, tag, &n, "cb:CircuitBreakerFilterInfoType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterInfoType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerTocb__CircuitBreakerFilterStatisticsType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerTocb__CircuitBreakerFilterStatisticsType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(soap, -1))) + return NULL; + cb__CircuitBreakerFilterStatisticsType *n; + cb__CircuitBreakerFilterStatisticsType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_cb__CircuitBreakerFilterStatisticsType, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType, sizeof(cb__CircuitBreakerFilterStatisticsType), 1)) + break; + if (!(p = soap_in_PointerTocb__CircuitBreakerFilterStatisticsType(soap, tag, NULL, "cb:CircuitBreakerFilterStatisticsType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerTocb__CircuitBreakerFilterStatisticsType(soap, tag, &n, "cb:CircuitBreakerFilterStatisticsType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerFilterStatisticsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerTocb__CircuitBreakerHardwarePolicyType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerTocb__CircuitBreakerHardwarePolicyType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, -1))) + return NULL; + cb__CircuitBreakerHardwarePolicyType *n; + cb__CircuitBreakerHardwarePolicyType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_cb__CircuitBreakerHardwarePolicyType, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType, sizeof(cb__CircuitBreakerHardwarePolicyType), 1)) + break; + if (!(p = soap_in_PointerTocb__CircuitBreakerHardwarePolicyType(soap, tag, NULL, "cb:CircuitBreakerHardwarePolicyType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerTocb__CircuitBreakerHardwarePolicyType(soap, tag, &n, "cb:CircuitBreakerHardwarePolicyType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerHardwarePolicyType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerTocb__CircuitBreakerPolicyInfoType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerTocb__CircuitBreakerPolicyInfoType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(soap, -1))) + return NULL; + cb__CircuitBreakerPolicyInfoType *n; + cb__CircuitBreakerPolicyInfoType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_cb__CircuitBreakerPolicyInfoType, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType, sizeof(cb__CircuitBreakerPolicyInfoType), 1)) + break; + if (!(p = soap_in_PointerTocb__CircuitBreakerPolicyInfoType(soap, tag, NULL, "cb:CircuitBreakerPolicyInfoType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerTocb__CircuitBreakerPolicyInfoType(soap, tag, &n, "cb:CircuitBreakerPolicyInfoType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTocb__CircuitBreakerPolicyInfoType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_emi__AlertAuthOptionsType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfemi__AlertAuthOptionsType(soap, -1))) + return NULL; + enum emi__AlertAuthOptionsType n; + enum emi__AlertAuthOptionsType *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_emi__AlertAuthOptionsType, SOAP_TYPE_std__vectorTemplateOfemi__AlertAuthOptionsType, sizeof(enum emi__AlertAuthOptionsType), 0)) + break; + if (!(p = soap_in_emi__AlertAuthOptionsType(soap, tag, NULL, "emi:AlertAuthOptionsType"))) + break; + } + else + { soap_default_emi__AlertAuthOptionsType(soap, &n); + if (!soap_in_emi__AlertAuthOptionsType(soap, tag, &n, "emi:AlertAuthOptionsType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfemi__AlertAuthOptionsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfemi__AlertAuthOptionsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfemi__AlertAuthOptionsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__AlertAuthOptionsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__SensorHandleType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__SensorHandleType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__SensorHandleType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_emi__SensorHandleType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__SensorHandleType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfemi__SensorHandleType(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_emi__SensorHandleType, SOAP_TYPE_std__vectorTemplateOfemi__SensorHandleType, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_emi__SensorHandleType(soap, tag, NULL, "emi:SensorHandleType"))) + break; + } + else + { soap_default_emi__SensorHandleType(soap, &n); + if (!soap_in_emi__SensorHandleType(soap, tag, &n, "emi:SensorHandleType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__SensorHandleType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfemi__SensorHandleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__SensorHandleType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__SensorHandleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfemi__SensorHandleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfemi__SensorHandleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__SensorHandleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerToemi__EventLogRecordType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerToemi__EventLogRecordType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerToemi__EventLogRecordType(soap, -1))) + return NULL; + emi__EventLogRecordType *n; + emi__EventLogRecordType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_emi__EventLogRecordType, SOAP_TYPE_std__vectorTemplateOfPointerToemi__EventLogRecordType, sizeof(emi__EventLogRecordType), 1)) + break; + if (!(p = soap_in_PointerToemi__EventLogRecordType(soap, tag, NULL, "emi:EventLogRecordType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerToemi__EventLogRecordType(soap, tag, &n, "emi:EventLogRecordType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerToemi__EventLogRecordType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerToemi__EventLogRecordType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerToemi__EventLogRecordType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerToemi__EventLogRecordType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__EventFilterHandleType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__EventFilterHandleType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__EventFilterHandleType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_emi__EventFilterHandleType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__EventFilterHandleType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfemi__EventFilterHandleType(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_emi__EventFilterHandleType, SOAP_TYPE_std__vectorTemplateOfemi__EventFilterHandleType, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_emi__EventFilterHandleType(soap, tag, NULL, "emi:EventFilterHandleType"))) + break; + } + else + { soap_default_emi__EventFilterHandleType(soap, &n); + if (!soap_in_emi__EventFilterHandleType(soap, tag, &n, "emi:EventFilterHandleType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__EventFilterHandleType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfemi__EventFilterHandleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__EventFilterHandleType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__EventFilterHandleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfemi__EventFilterHandleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfemi__EventFilterHandleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__EventFilterHandleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_emi__AlertSubscriptionHandleType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_emi__AlertSubscriptionHandleType, SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionHandleType, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_emi__AlertSubscriptionHandleType(soap, tag, NULL, "emi:AlertSubscriptionHandleType"))) + break; + } + else + { soap_default_emi__AlertSubscriptionHandleType(soap, &n); + if (!soap_in_emi__AlertSubscriptionHandleType(soap, tag, &n, "emi:AlertSubscriptionHandleType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionHandleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionHandleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionHandleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__AlertSubscriptionHandleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_emi__AlertSubscriptionPolicyIDType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(soap, -1))) + return NULL; + unsigned char n; + unsigned char *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_emi__AlertSubscriptionPolicyIDType, SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType, sizeof(unsigned char), 0)) + break; + if (!(p = soap_in_emi__AlertSubscriptionPolicyIDType(soap, tag, NULL, "emi:AlertSubscriptionPolicyIDType"))) + break; + } + else + { soap_default_emi__AlertSubscriptionPolicyIDType(soap, &n); + if (!soap_in_emi__AlertSubscriptionPolicyIDType(soap, tag, &n, "emi:AlertSubscriptionPolicyIDType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfemi__AlertSubscriptionPolicyIDType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_stra__StorageApplicationHandleType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfstra__StorageApplicationHandleType(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_stra__StorageApplicationHandleType, SOAP_TYPE_std__vectorTemplateOfstra__StorageApplicationHandleType, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_stra__StorageApplicationHandleType(soap, tag, NULL, "stra:StorageApplicationHandleType"))) + break; + } + else + { soap_default_stra__StorageApplicationHandleType(soap, &n); + if (!soap_in_stra__StorageApplicationHandleType(soap, tag, &n, "stra:StorageApplicationHandleType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfstra__StorageApplicationHandleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfstra__StorageApplicationHandleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfstra__StorageApplicationHandleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfstra__StorageApplicationHandleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfunsignedByte(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfunsignedByte(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfunsignedByte(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_unsignedByte(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfunsignedByte(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfunsignedByte(soap, -1))) + return NULL; + unsigned char n; + unsigned char *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_unsignedByte, SOAP_TYPE_std__vectorTemplateOfunsignedByte, sizeof(unsigned char), 0)) + break; + if (!(p = soap_in_unsignedByte(soap, tag, NULL, "xsd:unsignedByte"))) + break; + } + else + { soap_default_unsignedByte(soap, &n); + if (!soap_in_unsignedByte(soap, tag, &n, "xsd:unsignedByte")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfunsignedByte(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfunsignedByte(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfunsignedByte(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfunsignedByte(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfunsignedByte(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfunsignedByte, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfunsignedByte(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_stra__StorageAllocEntryHandleType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfstra__StorageAllocEntryHandleType(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_stra__StorageAllocEntryHandleType, SOAP_TYPE_std__vectorTemplateOfstra__StorageAllocEntryHandleType, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_stra__StorageAllocEntryHandleType(soap, tag, NULL, "stra:StorageAllocEntryHandleType"))) + break; + } + else + { soap_default_stra__StorageAllocEntryHandleType(soap, &n); + if (!soap_in_stra__StorageAllocEntryHandleType(soap, tag, &n, "stra:StorageAllocEntryHandleType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfstra__StorageAllocEntryHandleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfstra__StorageAllocEntryHandleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfstra__StorageAllocEntryHandleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfstra__StorageAllocEntryHandleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_stra__StorageEaclEntryHandleType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfstra__StorageEaclEntryHandleType(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_stra__StorageEaclEntryHandleType, SOAP_TYPE_std__vectorTemplateOfstra__StorageEaclEntryHandleType, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_stra__StorageEaclEntryHandleType(soap, tag, NULL, "stra:StorageEaclEntryHandleType"))) + break; + } + else + { soap_default_stra__StorageEaclEntryHandleType(soap, &n); + if (!soap_in_stra__StorageEaclEntryHandleType(soap, tag, &n, "stra:StorageEaclEntryHandleType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfstra__StorageEaclEntryHandleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfstra__StorageEaclEntryHandleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfstra__StorageEaclEntryHandleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfstra__StorageEaclEntryHandleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfnet__InterfaceHandleType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfnet__InterfaceHandleType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfnet__InterfaceHandleType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_net__InterfaceHandleType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfnet__InterfaceHandleType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfnet__InterfaceHandleType(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_net__InterfaceHandleType, SOAP_TYPE_std__vectorTemplateOfnet__InterfaceHandleType, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_net__InterfaceHandleType(soap, tag, NULL, "net:InterfaceHandleType"))) + break; + } + else + { soap_default_net__InterfaceHandleType(soap, &n); + if (!soap_in_net__InterfaceHandleType(soap, tag, &n, "net:InterfaceHandleType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfnet__InterfaceHandleType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfnet__InterfaceHandleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfnet__InterfaceHandleType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfnet__InterfaceHandleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfnet__InterfaceHandleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfnet__InterfaceHandleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfnet__InterfaceHandleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfcmn__GuidBuf(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_cmn__GuidBuf(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfcmn__GuidBuf(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfcmn__GuidBuf(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_cmn__GuidBuf(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfcmn__GuidBuf(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfcmn__GuidBuf(soap, -1))) + return NULL; + xsd__base64Binary n; + xsd__base64Binary *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_cmn__GuidBuf, SOAP_TYPE_std__vectorTemplateOfcmn__GuidBuf, sizeof(xsd__base64Binary), 0)) + break; + if (!(p = soap_in_cmn__GuidBuf(soap, tag, NULL, "cmn:GuidBuf"))) + break; + } + else + { soap_default_cmn__GuidBuf(soap, &n); + if (!soap_in_cmn__GuidBuf(soap, tag, &n, "cmn:GuidBuf")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfcmn__GuidBuf(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfcmn__GuidBuf(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfcmn__GuidBuf(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfcmn__GuidBuf(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfcmn__GuidBuf(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfcmn__GuidBuf, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfcmn__GuidBuf(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTosai__CrlType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerTosai__CrlType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTosai__CrlType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTosai__CrlType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerTosai__CrlType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTosai__CrlType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerTosai__CrlType(soap, -1))) + return NULL; + sai__CrlType *n; + sai__CrlType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_sai__CrlType, SOAP_TYPE_std__vectorTemplateOfPointerTosai__CrlType, sizeof(sai__CrlType), 1)) + break; + if (!(p = soap_in_PointerTosai__CrlType(soap, tag, NULL, "sai:CrlType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerTosai__CrlType(soap, tag, &n, "sai:CrlType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTosai__CrlType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerTosai__CrlType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTosai__CrlType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTosai__CrlType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerTosai__CrlType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerTosai__CrlType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTosai__CrlType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfsai__CertificateHandleType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfsai__CertificateHandleType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfsai__CertificateHandleType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_sai__CertificateHandleType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfsai__CertificateHandleType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfsai__CertificateHandleType(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_sai__CertificateHandleType, SOAP_TYPE_std__vectorTemplateOfsai__CertificateHandleType, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_sai__CertificateHandleType(soap, tag, NULL, "sai:CertificateHandleType"))) + break; + } + else + { soap_default_sai__CertificateHandleType(soap, &n); + if (!soap_in_sai__CertificateHandleType(soap, tag, &n, "sai:CertificateHandleType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfsai__CertificateHandleType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfsai__CertificateHandleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfsai__CertificateHandleType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfsai__CertificateHandleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfsai__CertificateHandleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfsai__CertificateHandleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfsai__CertificateHandleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerTosai__TlsOptionsType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerTosai__TlsOptionsType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, -1))) + return NULL; + sai__TlsOptionsType *n; + sai__TlsOptionsType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_sai__TlsOptionsType, SOAP_TYPE_std__vectorTemplateOfPointerTosai__TlsOptionsType, sizeof(sai__TlsOptionsType), 1)) + break; + if (!(p = soap_in_PointerTosai__TlsOptionsType(soap, tag, NULL, "sai:TlsOptionsType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerTosai__TlsOptionsType(soap, tag, &n, "sai:TlsOptionsType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerTosai__TlsOptionsType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerTosai__TlsOptionsType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerTosai__TlsOptionsType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTosai__TlsOptionsType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_sai__EnabledInterfacesType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfsai__EnabledInterfacesType(soap, -1))) + return NULL; + enum sai__EnabledInterfacesType n; + enum sai__EnabledInterfacesType *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_sai__EnabledInterfacesType, SOAP_TYPE_std__vectorTemplateOfsai__EnabledInterfacesType, sizeof(enum sai__EnabledInterfacesType), 0)) + break; + if (!(p = soap_in_sai__EnabledInterfacesType(soap, tag, NULL, "sai:EnabledInterfacesType"))) + break; + } + else + { soap_default_sai__EnabledInterfacesType(soap, &n); + if (!soap_in_sai__EnabledInterfacesType(soap, tag, &n, "sai:EnabledInterfacesType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfsai__EnabledInterfacesType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfsai__EnabledInterfacesType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfsai__EnabledInterfacesType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfsai__EnabledInterfacesType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfstd__string(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_std__string(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfstd__string(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfstd__string(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_std__string(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfstd__string(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfstd__string(soap, -1))) + return NULL; + std::string n; + std::string *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_std__string, SOAP_TYPE_std__vectorTemplateOfstd__string, sizeof(std::string), 0)) + break; + if (!(p = soap_in_std__string(soap, tag, NULL, "xsd:string"))) + break; + } + else + { soap_default_std__string(soap, &n); + if (!soap_in_std__string(soap, tag, &n, "xsd:string")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfstd__string(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfstd__string(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfstd__string(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfstd__string(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfstd__string(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfstd__string, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfstd__string(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfunsignedInt(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfunsignedInt(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfunsignedInt(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_unsignedInt(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfunsignedInt(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfunsignedInt(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_unsignedInt, SOAP_TYPE_std__vectorTemplateOfunsignedInt, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_unsignedInt(soap, tag, NULL, "xsd:unsignedInt"))) + break; + } + else + { soap_default_unsignedInt(soap, &n); + if (!soap_in_unsignedInt(soap, tag, &n, "xsd:unsignedInt")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfunsignedInt(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfunsignedInt(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfunsignedInt(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfunsignedInt(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfunsignedInt(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfunsignedInt, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfunsignedInt(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfxsd__base64Binary(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + (*i).soap_serialize(soap); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfxsd__base64Binary(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfxsd__base64Binary(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if ((*i).soap_out(soap, tag, id, "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfxsd__base64Binary(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfxsd__base64Binary(soap, -1))) + return NULL; + xsd__base64Binary n; + xsd__base64Binary *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_xsd__base64Binary, SOAP_TYPE_std__vectorTemplateOfxsd__base64Binary, sizeof(xsd__base64Binary), 0)) + break; + if (!(p = soap_in_xsd__base64Binary(soap, tag, NULL, "xsd:base64Binary"))) + break; + } + else + { n.soap_default(soap); + if (!soap_in_xsd__base64Binary(soap, tag, &n, "xsd:base64Binary")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfxsd__base64Binary(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfxsd__base64Binary(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfxsd__base64Binary(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfxsd__base64Binary(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfxsd__base64Binary(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfxsd__base64Binary, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfxsd__base64Binary(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap *soap, const std::vector*a) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + soap_serialize_PointerTosai__KerberosSpnType(soap, &(*i)); +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_PointerTosai__KerberosSpnType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfPointerTosai__KerberosSpnType(soap, -1))) + return NULL; + sai__KerberosSpnType *n; + sai__KerberosSpnType **p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_sai__KerberosSpnType, SOAP_TYPE_std__vectorTemplateOfPointerTosai__KerberosSpnType, sizeof(sai__KerberosSpnType), 1)) + break; + if (!(p = soap_in_PointerTosai__KerberosSpnType(soap, tag, NULL, "sai:KerberosSpnType"))) + break; + } + else + { n = NULL; + if (!soap_in_PointerTosai__KerberosSpnType(soap, tag, &n, "sai:KerberosSpnType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfPointerTosai__KerberosSpnType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfPointerTosai__KerberosSpnType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfPointerTosai__KerberosSpnType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfPointerTosai__KerberosSpnType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfsai__UserAclRealmType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfsai__UserAclRealmType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfsai__UserAclRealmType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_sai__UserAclRealmType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfsai__UserAclRealmType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfsai__UserAclRealmType(soap, -1))) + return NULL; + enum sai__UserAclRealmType n; + enum sai__UserAclRealmType *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_sai__UserAclRealmType, SOAP_TYPE_std__vectorTemplateOfsai__UserAclRealmType, sizeof(enum sai__UserAclRealmType), 0)) + break; + if (!(p = soap_in_sai__UserAclRealmType(soap, tag, NULL, "sai:UserAclRealmType"))) + break; + } + else + { soap_default_sai__UserAclRealmType(soap, &n); + if (!soap_in_sai__UserAclRealmType(soap, tag, &n, "sai:UserAclRealmType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfsai__UserAclRealmType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfsai__UserAclRealmType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfsai__UserAclRealmType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfsai__UserAclRealmType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfsai__UserAclRealmType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfsai__UserAclRealmType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfsai__UserAclRealmType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap *soap, const std::vector*a) +{ +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_default_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap *soap, std::vector*p) +{ + p->clear(); +} + +SOAP_FMAC3 int SOAP_FMAC4 soap_out_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap *soap, const char *tag, int id, const std::vector*a, const char *type) +{ + for (std::vector::const_iterator i = a->begin(); i != a->end(); ++i) + { + if (soap_out_sai__UserAclEntryHandleType(soap, tag, id, &(*i), "")) + return soap->error; + } + return SOAP_OK; +} + +SOAP_FMAC3 std::vector* SOAP_FMAC4 soap_in_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap *soap, const char *tag, std::vector*a, const char *type) +{ + if (soap_element_begin_in(soap, tag, 1, NULL)) + return NULL; + if (!a && !(a = soap_new_std__vectorTemplateOfsai__UserAclEntryHandleType(soap, -1))) + return NULL; + unsigned int n; + unsigned int *p; + do + { soap_revert(soap); + if (*soap->id || *soap->href) + { if (!soap_container_id_forward(soap, *soap->id?soap->id:soap->href, a, (size_t)a->size(), SOAP_TYPE_sai__UserAclEntryHandleType, SOAP_TYPE_std__vectorTemplateOfsai__UserAclEntryHandleType, sizeof(unsigned int), 0)) + break; + if (!(p = soap_in_sai__UserAclEntryHandleType(soap, tag, NULL, "sai:UserAclEntryHandleType"))) + break; + } + else + { soap_default_sai__UserAclEntryHandleType(soap, &n); + if (!soap_in_sai__UserAclEntryHandleType(soap, tag, &n, "sai:UserAclEntryHandleType")) + break; + } + a->push_back(n); + } + while (!soap_element_begin_in(soap, tag, 1, NULL)); + if (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG) + { soap->error = SOAP_OK; + return a; + } + return NULL; +} + +SOAP_FMAC5 std::vector * SOAP_FMAC6 soap_new_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap *soap, int n) +{ return soap_instantiate_std__vectorTemplateOfsai__UserAclEntryHandleType(soap, n, NULL, NULL, NULL); +} + +SOAP_FMAC5 void SOAP_FMAC6 soap_delete_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap *soap, std::vector*p) +{ soap_delete(soap, p); +} + +SOAP_FMAC3 std::vector * SOAP_FMAC4 soap_instantiate_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_std__vectorTemplateOfsai__UserAclEntryHandleType(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:"")); + struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_std__vectorTemplateOfsai__UserAclEntryHandleType, n, soap_fdelete); + if (!cp) + return NULL; + if (n < 0) + { cp->ptr = (void*)new std::vector; + if (size) + *size = sizeof(std::vector); + } + else + { cp->ptr = (void*)new std::vector[n]; + if (size) + *size = n * sizeof(std::vector); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr)); + return (std::vector*)cp->ptr; +} + +SOAP_FMAC3 void SOAP_FMAC4 soap_copy_std__vectorTemplateOfsai__UserAclEntryHandleType(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying std::vector %p -> %p\n", q, p)); + *(std::vector*)p = *(std::vector*)q; +} + +/* End of soapC.cpp */ diff --git a/pcucontrol/models/intelamt/soapClient.cpp b/pcucontrol/models/intelamt/soapClient.cpp new file mode 100644 index 0000000..bf5a808 --- /dev/null +++ b/pcucontrol/models/intelamt/soapClient.cpp @@ -0,0 +1,10812 @@ +/* soapClient.cpp + Generated by gSOAP 2.7.8c from ../../Samples/gSoapGeneratedCode/AmtWsdlInterface.h + Copyright (C) 2000-2006, Robert van Engelen, Genivia Inc. All Rights Reserved. + This part of the software is released under one of the following licenses: + GPL, the gSOAP public license, or Genivia's license for commercial use. +*/ +#include "soapH.h" + +SOAP_SOURCE_STAMP("@(#) soapClient.cpp ver 2.7.8c 2007-06-07 16:01:49 GMT") + + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apl__AgentWatchdogShutdown(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apl__AgentWatchdogShutdown *apl__AgentWatchdogShutdown, _apl__AgentWatchdogShutdownResponse *apl__AgentWatchdogShutdownResponse) +{ struct __apl__AgentWatchdogShutdown soap_tmp___apl__AgentWatchdogShutdown; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogLocalService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogLocal/AgentWatchdogShutdown"; + soap->encodingStyle = NULL; + soap_tmp___apl__AgentWatchdogShutdown.apl__AgentWatchdogShutdown = apl__AgentWatchdogShutdown; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apl__AgentWatchdogShutdown(soap, &soap_tmp___apl__AgentWatchdogShutdown); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apl__AgentWatchdogShutdown(soap, &soap_tmp___apl__AgentWatchdogShutdown, "-apl:AgentWatchdogShutdown", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apl__AgentWatchdogShutdown(soap, &soap_tmp___apl__AgentWatchdogShutdown, "-apl:AgentWatchdogShutdown", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apl__AgentWatchdogShutdownResponse) + return soap_closesock(soap); + apl__AgentWatchdogShutdownResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apl__AgentWatchdogShutdownResponse->soap_get(soap, "apl:AgentWatchdogShutdownResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apl__AgentWatchdogHeartbeat(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apl__AgentWatchdogHeartbeat *apl__AgentWatchdogHeartbeat, _apl__AgentWatchdogHeartbeatResponse *apl__AgentWatchdogHeartbeatResponse) +{ struct __apl__AgentWatchdogHeartbeat soap_tmp___apl__AgentWatchdogHeartbeat; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogLocalService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogLocal/AgentWatchdogHeartbeat"; + soap->encodingStyle = NULL; + soap_tmp___apl__AgentWatchdogHeartbeat.apl__AgentWatchdogHeartbeat = apl__AgentWatchdogHeartbeat; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apl__AgentWatchdogHeartbeat(soap, &soap_tmp___apl__AgentWatchdogHeartbeat); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apl__AgentWatchdogHeartbeat(soap, &soap_tmp___apl__AgentWatchdogHeartbeat, "-apl:AgentWatchdogHeartbeat", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apl__AgentWatchdogHeartbeat(soap, &soap_tmp___apl__AgentWatchdogHeartbeat, "-apl:AgentWatchdogHeartbeat", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apl__AgentWatchdogHeartbeatResponse) + return soap_closesock(soap); + apl__AgentWatchdogHeartbeatResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apl__AgentWatchdogHeartbeatResponse->soap_get(soap, "apl:AgentWatchdogHeartbeatResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apl__AgentWatchdogRegister(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apl__AgentWatchdogRegister *apl__AgentWatchdogRegister, _apl__AgentWatchdogRegisterResponse *apl__AgentWatchdogRegisterResponse) +{ struct __apl__AgentWatchdogRegister soap_tmp___apl__AgentWatchdogRegister; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogLocalService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogLocal/AgentWatchdogRegister"; + soap->encodingStyle = NULL; + soap_tmp___apl__AgentWatchdogRegister.apl__AgentWatchdogRegister = apl__AgentWatchdogRegister; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apl__AgentWatchdogRegister(soap, &soap_tmp___apl__AgentWatchdogRegister); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apl__AgentWatchdogRegister(soap, &soap_tmp___apl__AgentWatchdogRegister, "-apl:AgentWatchdogRegister", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apl__AgentWatchdogRegister(soap, &soap_tmp___apl__AgentWatchdogRegister, "-apl:AgentWatchdogRegister", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apl__AgentWatchdogRegisterResponse) + return soap_closesock(soap); + apl__AgentWatchdogRegisterResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apl__AgentWatchdogRegisterResponse->soap_get(soap, "apl:AgentWatchdogRegisterResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogCreate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogCreate *apr__ConsoleWatchdogCreate, _apr__ConsoleWatchdogCreateResponse *apr__ConsoleWatchdogCreateResponse) +{ struct __apr__ConsoleWatchdogCreate soap_tmp___apr__ConsoleWatchdogCreate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogRemoteService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote/ConsoleWatchdogCreate"; + soap->encodingStyle = NULL; + soap_tmp___apr__ConsoleWatchdogCreate.apr__ConsoleWatchdogCreate = apr__ConsoleWatchdogCreate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apr__ConsoleWatchdogCreate(soap, &soap_tmp___apr__ConsoleWatchdogCreate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogCreate(soap, &soap_tmp___apr__ConsoleWatchdogCreate, "-apr:ConsoleWatchdogCreate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogCreate(soap, &soap_tmp___apr__ConsoleWatchdogCreate, "-apr:ConsoleWatchdogCreate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apr__ConsoleWatchdogCreateResponse) + return soap_closesock(soap); + apr__ConsoleWatchdogCreateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apr__ConsoleWatchdogCreateResponse->soap_get(soap, "apr:ConsoleWatchdogCreateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogDelete(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogDelete *apr__ConsoleWatchdogDelete, _apr__ConsoleWatchdogDeleteResponse *apr__ConsoleWatchdogDeleteResponse) +{ struct __apr__ConsoleWatchdogDelete soap_tmp___apr__ConsoleWatchdogDelete; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogRemoteService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote/ConsoleWatchdogDelete"; + soap->encodingStyle = NULL; + soap_tmp___apr__ConsoleWatchdogDelete.apr__ConsoleWatchdogDelete = apr__ConsoleWatchdogDelete; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apr__ConsoleWatchdogDelete(soap, &soap_tmp___apr__ConsoleWatchdogDelete); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogDelete(soap, &soap_tmp___apr__ConsoleWatchdogDelete, "-apr:ConsoleWatchdogDelete", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogDelete(soap, &soap_tmp___apr__ConsoleWatchdogDelete, "-apr:ConsoleWatchdogDelete", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apr__ConsoleWatchdogDeleteResponse) + return soap_closesock(soap); + apr__ConsoleWatchdogDeleteResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apr__ConsoleWatchdogDeleteResponse->soap_get(soap, "apr:ConsoleWatchdogDeleteResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogEnumerate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogEnumerate *apr__ConsoleWatchdogEnumerate, _apr__ConsoleWatchdogEnumerateResponse *apr__ConsoleWatchdogEnumerateResponse) +{ struct __apr__ConsoleWatchdogEnumerate soap_tmp___apr__ConsoleWatchdogEnumerate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogRemoteService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote/ConsoleWatchdogEnumerate"; + soap->encodingStyle = NULL; + soap_tmp___apr__ConsoleWatchdogEnumerate.apr__ConsoleWatchdogEnumerate = apr__ConsoleWatchdogEnumerate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apr__ConsoleWatchdogEnumerate(soap, &soap_tmp___apr__ConsoleWatchdogEnumerate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogEnumerate(soap, &soap_tmp___apr__ConsoleWatchdogEnumerate, "-apr:ConsoleWatchdogEnumerate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogEnumerate(soap, &soap_tmp___apr__ConsoleWatchdogEnumerate, "-apr:ConsoleWatchdogEnumerate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apr__ConsoleWatchdogEnumerateResponse) + return soap_closesock(soap); + apr__ConsoleWatchdogEnumerateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apr__ConsoleWatchdogEnumerateResponse->soap_get(soap, "apr:ConsoleWatchdogEnumerateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogSetActions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogSetActions *apr__ConsoleWatchdogSetActions, _apr__ConsoleWatchdogSetActionsResponse *apr__ConsoleWatchdogSetActionsResponse) +{ struct __apr__ConsoleWatchdogSetActions soap_tmp___apr__ConsoleWatchdogSetActions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogRemoteService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote/ConsoleWatchdogSetActions"; + soap->encodingStyle = NULL; + soap_tmp___apr__ConsoleWatchdogSetActions.apr__ConsoleWatchdogSetActions = apr__ConsoleWatchdogSetActions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apr__ConsoleWatchdogSetActions(soap, &soap_tmp___apr__ConsoleWatchdogSetActions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogSetActions(soap, &soap_tmp___apr__ConsoleWatchdogSetActions, "-apr:ConsoleWatchdogSetActions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogSetActions(soap, &soap_tmp___apr__ConsoleWatchdogSetActions, "-apr:ConsoleWatchdogSetActions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apr__ConsoleWatchdogSetActionsResponse) + return soap_closesock(soap); + apr__ConsoleWatchdogSetActionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apr__ConsoleWatchdogSetActionsResponse->soap_get(soap, "apr:ConsoleWatchdogSetActionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogGetActions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogGetActions *apr__ConsoleWatchdogGetActions, _apr__ConsoleWatchdogGetActionsResponse *apr__ConsoleWatchdogGetActionsResponse) +{ struct __apr__ConsoleWatchdogGetActions soap_tmp___apr__ConsoleWatchdogGetActions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogRemoteService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote/ConsoleWatchdogGetActions"; + soap->encodingStyle = NULL; + soap_tmp___apr__ConsoleWatchdogGetActions.apr__ConsoleWatchdogGetActions = apr__ConsoleWatchdogGetActions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apr__ConsoleWatchdogGetActions(soap, &soap_tmp___apr__ConsoleWatchdogGetActions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogGetActions(soap, &soap_tmp___apr__ConsoleWatchdogGetActions, "-apr:ConsoleWatchdogGetActions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogGetActions(soap, &soap_tmp___apr__ConsoleWatchdogGetActions, "-apr:ConsoleWatchdogGetActions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apr__ConsoleWatchdogGetActionsResponse) + return soap_closesock(soap); + apr__ConsoleWatchdogGetActionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apr__ConsoleWatchdogGetActionsResponse->soap_get(soap, "apr:ConsoleWatchdogGetActionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogSetCbPolicy(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogSetCbPolicy *apr__ConsoleWatchdogSetCbPolicy, _apr__ConsoleWatchdogSetCbPolicyResponse *apr__ConsoleWatchdogSetCbPolicyResponse) +{ struct __apr__ConsoleWatchdogSetCbPolicy soap_tmp___apr__ConsoleWatchdogSetCbPolicy; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogRemoteService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote/ConsoleWatchdogSetCbPolicy"; + soap->encodingStyle = NULL; + soap_tmp___apr__ConsoleWatchdogSetCbPolicy.apr__ConsoleWatchdogSetCbPolicy = apr__ConsoleWatchdogSetCbPolicy; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apr__ConsoleWatchdogSetCbPolicy(soap, &soap_tmp___apr__ConsoleWatchdogSetCbPolicy); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogSetCbPolicy(soap, &soap_tmp___apr__ConsoleWatchdogSetCbPolicy, "-apr:ConsoleWatchdogSetCbPolicy", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogSetCbPolicy(soap, &soap_tmp___apr__ConsoleWatchdogSetCbPolicy, "-apr:ConsoleWatchdogSetCbPolicy", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apr__ConsoleWatchdogSetCbPolicyResponse) + return soap_closesock(soap); + apr__ConsoleWatchdogSetCbPolicyResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apr__ConsoleWatchdogSetCbPolicyResponse->soap_get(soap, "apr:ConsoleWatchdogSetCbPolicyResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogGetCbPolicy(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogGetCbPolicy *apr__ConsoleWatchdogGetCbPolicy, _apr__ConsoleWatchdogGetCbPolicyResponse *apr__ConsoleWatchdogGetCbPolicyResponse) +{ struct __apr__ConsoleWatchdogGetCbPolicy soap_tmp___apr__ConsoleWatchdogGetCbPolicy; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogRemoteService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote/ConsoleWatchdogGetCbPolicy"; + soap->encodingStyle = NULL; + soap_tmp___apr__ConsoleWatchdogGetCbPolicy.apr__ConsoleWatchdogGetCbPolicy = apr__ConsoleWatchdogGetCbPolicy; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apr__ConsoleWatchdogGetCbPolicy(soap, &soap_tmp___apr__ConsoleWatchdogGetCbPolicy); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogGetCbPolicy(soap, &soap_tmp___apr__ConsoleWatchdogGetCbPolicy, "-apr:ConsoleWatchdogGetCbPolicy", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogGetCbPolicy(soap, &soap_tmp___apr__ConsoleWatchdogGetCbPolicy, "-apr:ConsoleWatchdogGetCbPolicy", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apr__ConsoleWatchdogGetCbPolicyResponse) + return soap_closesock(soap); + apr__ConsoleWatchdogGetCbPolicyResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apr__ConsoleWatchdogGetCbPolicyResponse->soap_get(soap, "apr:ConsoleWatchdogGetCbPolicyResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___apr__ConsoleWatchdogQueryCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _apr__ConsoleWatchdogQueryCapabilities *apr__ConsoleWatchdogQueryCapabilities, _apr__ConsoleWatchdogQueryCapabilitiesResponse *apr__ConsoleWatchdogQueryCapabilitiesResponse) +{ struct __apr__ConsoleWatchdogQueryCapabilities soap_tmp___apr__ConsoleWatchdogQueryCapabilities; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/AgentWatchdogRemoteService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/AgentWatchdogRemote/ConsoleWatchdogQueryCapabilities"; + soap->encodingStyle = NULL; + soap_tmp___apr__ConsoleWatchdogQueryCapabilities.apr__ConsoleWatchdogQueryCapabilities = apr__ConsoleWatchdogQueryCapabilities; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___apr__ConsoleWatchdogQueryCapabilities(soap, &soap_tmp___apr__ConsoleWatchdogQueryCapabilities); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogQueryCapabilities(soap, &soap_tmp___apr__ConsoleWatchdogQueryCapabilities, "-apr:ConsoleWatchdogQueryCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___apr__ConsoleWatchdogQueryCapabilities(soap, &soap_tmp___apr__ConsoleWatchdogQueryCapabilities, "-apr:ConsoleWatchdogQueryCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!apr__ConsoleWatchdogQueryCapabilitiesResponse) + return soap_closesock(soap); + apr__ConsoleWatchdogQueryCapabilitiesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + apr__ConsoleWatchdogQueryCapabilitiesResponse->soap_get(soap, "apr:ConsoleWatchdogQueryCapabilitiesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyCreate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyCreate *cb__CbPolicyCreate, _cb__CbPolicyCreateResponse *cb__CbPolicyCreateResponse) +{ struct __cb__CbPolicyCreate soap_tmp___cb__CbPolicyCreate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbPolicyCreate"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbPolicyCreate.cb__CbPolicyCreate = cb__CbPolicyCreate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbPolicyCreate(soap, &soap_tmp___cb__CbPolicyCreate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyCreate(soap, &soap_tmp___cb__CbPolicyCreate, "-cb:CbPolicyCreate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyCreate(soap, &soap_tmp___cb__CbPolicyCreate, "-cb:CbPolicyCreate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbPolicyCreateResponse) + return soap_closesock(soap); + cb__CbPolicyCreateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbPolicyCreateResponse->soap_get(soap, "cb:CbPolicyCreateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyGet(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyGet *cb__CbPolicyGet, _cb__CbPolicyGetResponse *cb__CbPolicyGetResponse) +{ struct __cb__CbPolicyGet soap_tmp___cb__CbPolicyGet; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbPolicyGet"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbPolicyGet.cb__CbPolicyGet = cb__CbPolicyGet; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbPolicyGet(soap, &soap_tmp___cb__CbPolicyGet); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyGet(soap, &soap_tmp___cb__CbPolicyGet, "-cb:CbPolicyGet", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyGet(soap, &soap_tmp___cb__CbPolicyGet, "-cb:CbPolicyGet", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbPolicyGetResponse) + return soap_closesock(soap); + cb__CbPolicyGetResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbPolicyGetResponse->soap_get(soap, "cb:CbPolicyGetResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyDelete(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyDelete *cb__CbPolicyDelete, _cb__CbPolicyDeleteResponse *cb__CbPolicyDeleteResponse) +{ struct __cb__CbPolicyDelete soap_tmp___cb__CbPolicyDelete; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbPolicyDelete"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbPolicyDelete.cb__CbPolicyDelete = cb__CbPolicyDelete; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbPolicyDelete(soap, &soap_tmp___cb__CbPolicyDelete); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyDelete(soap, &soap_tmp___cb__CbPolicyDelete, "-cb:CbPolicyDelete", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyDelete(soap, &soap_tmp___cb__CbPolicyDelete, "-cb:CbPolicyDelete", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbPolicyDeleteResponse) + return soap_closesock(soap); + cb__CbPolicyDeleteResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbPolicyDeleteResponse->soap_get(soap, "cb:CbPolicyDeleteResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyEnumerate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyEnumerate *cb__CbPolicyEnumerate, _cb__CbPolicyEnumerateResponse *cb__CbPolicyEnumerateResponse) +{ struct __cb__CbPolicyEnumerate soap_tmp___cb__CbPolicyEnumerate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbPolicyEnumerate"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbPolicyEnumerate.cb__CbPolicyEnumerate = cb__CbPolicyEnumerate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbPolicyEnumerate(soap, &soap_tmp___cb__CbPolicyEnumerate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyEnumerate(soap, &soap_tmp___cb__CbPolicyEnumerate, "-cb:CbPolicyEnumerate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyEnumerate(soap, &soap_tmp___cb__CbPolicyEnumerate, "-cb:CbPolicyEnumerate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbPolicyEnumerateResponse) + return soap_closesock(soap); + cb__CbPolicyEnumerateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbPolicyEnumerateResponse->soap_get(soap, "cb:CbPolicyEnumerateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyEnable(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyEnable *cb__CbPolicyEnable, _cb__CbPolicyEnableResponse *cb__CbPolicyEnableResponse) +{ struct __cb__CbPolicyEnable soap_tmp___cb__CbPolicyEnable; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbPolicyEnable"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbPolicyEnable.cb__CbPolicyEnable = cb__CbPolicyEnable; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbPolicyEnable(soap, &soap_tmp___cb__CbPolicyEnable); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyEnable(soap, &soap_tmp___cb__CbPolicyEnable, "-cb:CbPolicyEnable", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyEnable(soap, &soap_tmp___cb__CbPolicyEnable, "-cb:CbPolicyEnable", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbPolicyEnableResponse) + return soap_closesock(soap); + cb__CbPolicyEnableResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbPolicyEnableResponse->soap_get(soap, "cb:CbPolicyEnableResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyDisable(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyDisable *cb__CbPolicyDisable, _cb__CbPolicyDisableResponse *cb__CbPolicyDisableResponse) +{ struct __cb__CbPolicyDisable soap_tmp___cb__CbPolicyDisable; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbPolicyDisable"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbPolicyDisable.cb__CbPolicyDisable = cb__CbPolicyDisable; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbPolicyDisable(soap, &soap_tmp___cb__CbPolicyDisable); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyDisable(soap, &soap_tmp___cb__CbPolicyDisable, "-cb:CbPolicyDisable", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyDisable(soap, &soap_tmp___cb__CbPolicyDisable, "-cb:CbPolicyDisable", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbPolicyDisableResponse) + return soap_closesock(soap); + cb__CbPolicyDisableResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbPolicyDisableResponse->soap_get(soap, "cb:CbPolicyDisableResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyGetEnabled(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyGetEnabled *cb__CbPolicyGetEnabled, _cb__CbPolicyGetEnabledResponse *cb__CbPolicyGetEnabledResponse) +{ struct __cb__CbPolicyGetEnabled soap_tmp___cb__CbPolicyGetEnabled; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbPolicyGetEnabled"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbPolicyGetEnabled.cb__CbPolicyGetEnabled = cb__CbPolicyGetEnabled; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbPolicyGetEnabled(soap, &soap_tmp___cb__CbPolicyGetEnabled); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyGetEnabled(soap, &soap_tmp___cb__CbPolicyGetEnabled, "-cb:CbPolicyGetEnabled", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyGetEnabled(soap, &soap_tmp___cb__CbPolicyGetEnabled, "-cb:CbPolicyGetEnabled", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbPolicyGetEnabledResponse) + return soap_closesock(soap); + cb__CbPolicyGetEnabledResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbPolicyGetEnabledResponse->soap_get(soap, "cb:CbPolicyGetEnabledResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbPolicyGetActiveStatistics(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbPolicyGetActiveStatistics *cb__CbPolicyGetActiveStatistics, _cb__CbPolicyGetActiveStatisticsResponse *cb__CbPolicyGetActiveStatisticsResponse) +{ struct __cb__CbPolicyGetActiveStatistics soap_tmp___cb__CbPolicyGetActiveStatistics; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbPolicyGetActiveStatistics"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbPolicyGetActiveStatistics.cb__CbPolicyGetActiveStatistics = cb__CbPolicyGetActiveStatistics; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbPolicyGetActiveStatistics(soap, &soap_tmp___cb__CbPolicyGetActiveStatistics); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyGetActiveStatistics(soap, &soap_tmp___cb__CbPolicyGetActiveStatistics, "-cb:CbPolicyGetActiveStatistics", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbPolicyGetActiveStatistics(soap, &soap_tmp___cb__CbPolicyGetActiveStatistics, "-cb:CbPolicyGetActiveStatistics", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbPolicyGetActiveStatisticsResponse) + return soap_closesock(soap); + cb__CbPolicyGetActiveStatisticsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbPolicyGetActiveStatisticsResponse->soap_get(soap, "cb:CbPolicyGetActiveStatisticsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbFilterCreate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbFilterCreate *cb__CbFilterCreate, _cb__CbFilterCreateResponse *cb__CbFilterCreateResponse) +{ struct __cb__CbFilterCreate soap_tmp___cb__CbFilterCreate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbFilterCreate"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbFilterCreate.cb__CbFilterCreate = cb__CbFilterCreate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbFilterCreate(soap, &soap_tmp___cb__CbFilterCreate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbFilterCreate(soap, &soap_tmp___cb__CbFilterCreate, "-cb:CbFilterCreate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbFilterCreate(soap, &soap_tmp___cb__CbFilterCreate, "-cb:CbFilterCreate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbFilterCreateResponse) + return soap_closesock(soap); + cb__CbFilterCreateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbFilterCreateResponse->soap_get(soap, "cb:CbFilterCreateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbFilterGet(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbFilterGet *cb__CbFilterGet, _cb__CbFilterGetResponse *cb__CbFilterGetResponse) +{ struct __cb__CbFilterGet soap_tmp___cb__CbFilterGet; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbFilterGet"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbFilterGet.cb__CbFilterGet = cb__CbFilterGet; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbFilterGet(soap, &soap_tmp___cb__CbFilterGet); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbFilterGet(soap, &soap_tmp___cb__CbFilterGet, "-cb:CbFilterGet", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbFilterGet(soap, &soap_tmp___cb__CbFilterGet, "-cb:CbFilterGet", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbFilterGetResponse) + return soap_closesock(soap); + cb__CbFilterGetResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbFilterGetResponse->soap_get(soap, "cb:CbFilterGetResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbFilterDelete(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbFilterDelete *cb__CbFilterDelete, _cb__CbFilterDeleteResponse *cb__CbFilterDeleteResponse) +{ struct __cb__CbFilterDelete soap_tmp___cb__CbFilterDelete; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbFilterDelete"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbFilterDelete.cb__CbFilterDelete = cb__CbFilterDelete; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbFilterDelete(soap, &soap_tmp___cb__CbFilterDelete); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbFilterDelete(soap, &soap_tmp___cb__CbFilterDelete, "-cb:CbFilterDelete", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbFilterDelete(soap, &soap_tmp___cb__CbFilterDelete, "-cb:CbFilterDelete", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbFilterDeleteResponse) + return soap_closesock(soap); + cb__CbFilterDeleteResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbFilterDeleteResponse->soap_get(soap, "cb:CbFilterDeleteResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbFilterEnumerate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbFilterEnumerate *cb__CbFilterEnumerate, _cb__CbFilterEnumerateResponse *cb__CbFilterEnumerateResponse) +{ struct __cb__CbFilterEnumerate soap_tmp___cb__CbFilterEnumerate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbFilterEnumerate"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbFilterEnumerate.cb__CbFilterEnumerate = cb__CbFilterEnumerate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbFilterEnumerate(soap, &soap_tmp___cb__CbFilterEnumerate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbFilterEnumerate(soap, &soap_tmp___cb__CbFilterEnumerate, "-cb:CbFilterEnumerate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbFilterEnumerate(soap, &soap_tmp___cb__CbFilterEnumerate, "-cb:CbFilterEnumerate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbFilterEnumerateResponse) + return soap_closesock(soap); + cb__CbFilterEnumerateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbFilterEnumerateResponse->soap_get(soap, "cb:CbFilterEnumerateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__CbQueryCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__CbQueryCapabilities *cb__CbQueryCapabilities, _cb__CbQueryCapabilitiesResponse *cb__CbQueryCapabilitiesResponse) +{ struct __cb__CbQueryCapabilities soap_tmp___cb__CbQueryCapabilities; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2004/12/management/PC/CircuitBreaker/CbQueryCapabilities"; + soap->encodingStyle = NULL; + soap_tmp___cb__CbQueryCapabilities.cb__CbQueryCapabilities = cb__CbQueryCapabilities; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__CbQueryCapabilities(soap, &soap_tmp___cb__CbQueryCapabilities); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbQueryCapabilities(soap, &soap_tmp___cb__CbQueryCapabilities, "-cb:CbQueryCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__CbQueryCapabilities(soap, &soap_tmp___cb__CbQueryCapabilities, "-cb:CbQueryCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__CbQueryCapabilitiesResponse) + return soap_closesock(soap); + cb__CbQueryCapabilitiesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__CbQueryCapabilitiesResponse->soap_get(soap, "cb:CbQueryCapabilitiesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__SetHcbOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__SetHcbOptions *cb__SetHcbOptions, _cb__SetHcbOptionsResponse *cb__SetHcbOptionsResponse) +{ struct __cb__SetHcbOptions soap_tmp___cb__SetHcbOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2006/01/management/PC/CircuitBreaker/SetHcbOptions"; + soap->encodingStyle = NULL; + soap_tmp___cb__SetHcbOptions.cb__SetHcbOptions = cb__SetHcbOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__SetHcbOptions(soap, &soap_tmp___cb__SetHcbOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__SetHcbOptions(soap, &soap_tmp___cb__SetHcbOptions, "-cb:SetHcbOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__SetHcbOptions(soap, &soap_tmp___cb__SetHcbOptions, "-cb:SetHcbOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__SetHcbOptionsResponse) + return soap_closesock(soap); + cb__SetHcbOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__SetHcbOptionsResponse->soap_get(soap, "cb:SetHcbOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__GetHcbOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__GetHcbOptions *cb__GetHcbOptions, _cb__GetHcbOptionsResponse *cb__GetHcbOptionsResponse) +{ struct __cb__GetHcbOptions soap_tmp___cb__GetHcbOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2006/01/management/PC/CircuitBreaker/GetHcbOptions"; + soap->encodingStyle = NULL; + soap_tmp___cb__GetHcbOptions.cb__GetHcbOptions = cb__GetHcbOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__GetHcbOptions(soap, &soap_tmp___cb__GetHcbOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__GetHcbOptions(soap, &soap_tmp___cb__GetHcbOptions, "-cb:GetHcbOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__GetHcbOptions(soap, &soap_tmp___cb__GetHcbOptions, "-cb:GetHcbOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__GetHcbOptionsResponse) + return soap_closesock(soap); + cb__GetHcbOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__GetHcbOptionsResponse->soap_get(soap, "cb:GetHcbOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__ClearHcbState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__ClearHcbState *cb__ClearHcbState, _cb__ClearHcbStateResponse *cb__ClearHcbStateResponse) +{ struct __cb__ClearHcbState soap_tmp___cb__ClearHcbState; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2006/01/management/PC/CircuitBreaker/ClearHcbState"; + soap->encodingStyle = NULL; + soap_tmp___cb__ClearHcbState.cb__ClearHcbState = cb__ClearHcbState; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__ClearHcbState(soap, &soap_tmp___cb__ClearHcbState); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__ClearHcbState(soap, &soap_tmp___cb__ClearHcbState, "-cb:ClearHcbState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__ClearHcbState(soap, &soap_tmp___cb__ClearHcbState, "-cb:ClearHcbState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__ClearHcbStateResponse) + return soap_closesock(soap); + cb__ClearHcbStateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__ClearHcbStateResponse->soap_get(soap, "cb:ClearHcbStateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___cb__GetHcbState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _cb__GetHcbState *cb__GetHcbState, _cb__GetHcbStateResponse *cb__GetHcbStateResponse) +{ struct __cb__GetHcbState soap_tmp___cb__GetHcbState; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/CircuitBreakerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/2006/01/management/PC/CircuitBreaker/GetHcbState"; + soap->encodingStyle = NULL; + soap_tmp___cb__GetHcbState.cb__GetHcbState = cb__GetHcbState; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___cb__GetHcbState(soap, &soap_tmp___cb__GetHcbState); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__GetHcbState(soap, &soap_tmp___cb__GetHcbState, "-cb:GetHcbState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___cb__GetHcbState(soap, &soap_tmp___cb__GetHcbState, "-cb:GetHcbState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!cb__GetHcbStateResponse) + return soap_closesock(soap); + cb__GetHcbStateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + cb__GetHcbStateResponse->soap_get(soap, "cb:GetHcbStateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateEventFilters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateEventFilters *emi__EnumerateEventFilters, _emi__EnumerateEventFiltersResponse *emi__EnumerateEventFiltersResponse) +{ struct __emi__EnumerateEventFilters soap_tmp___emi__EnumerateEventFilters; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/EnumerateEventFilters"; + soap->encodingStyle = NULL; + soap_tmp___emi__EnumerateEventFilters.emi__EnumerateEventFilters = emi__EnumerateEventFilters; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__EnumerateEventFilters(soap, &soap_tmp___emi__EnumerateEventFilters); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateEventFilters(soap, &soap_tmp___emi__EnumerateEventFilters, "-emi:EnumerateEventFilters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateEventFilters(soap, &soap_tmp___emi__EnumerateEventFilters, "-emi:EnumerateEventFilters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__EnumerateEventFiltersResponse) + return soap_closesock(soap); + emi__EnumerateEventFiltersResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__EnumerateEventFiltersResponse->soap_get(soap, "emi:EnumerateEventFiltersResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetAlertSubscription(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetAlertSubscription *emi__GetAlertSubscription, _emi__GetAlertSubscriptionResponse *emi__GetAlertSubscriptionResponse) +{ struct __emi__GetAlertSubscription soap_tmp___emi__GetAlertSubscription; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/GetAlertSubscription"; + soap->encodingStyle = NULL; + soap_tmp___emi__GetAlertSubscription.emi__GetAlertSubscription = emi__GetAlertSubscription; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__GetAlertSubscription(soap, &soap_tmp___emi__GetAlertSubscription); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetAlertSubscription(soap, &soap_tmp___emi__GetAlertSubscription, "-emi:GetAlertSubscription", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetAlertSubscription(soap, &soap_tmp___emi__GetAlertSubscription, "-emi:GetAlertSubscription", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__GetAlertSubscriptionResponse) + return soap_closesock(soap); + emi__GetAlertSubscriptionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__GetAlertSubscriptionResponse->soap_get(soap, "emi:GetAlertSubscriptionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__SetAlertCommunityString(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__SetAlertCommunityString *emi__SetAlertCommunityString, _emi__SetAlertCommunityStringResponse *emi__SetAlertCommunityStringResponse) +{ struct __emi__SetAlertCommunityString soap_tmp___emi__SetAlertCommunityString; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/SetAlertCommunityString"; + soap->encodingStyle = NULL; + soap_tmp___emi__SetAlertCommunityString.emi__SetAlertCommunityString = emi__SetAlertCommunityString; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__SetAlertCommunityString(soap, &soap_tmp___emi__SetAlertCommunityString); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__SetAlertCommunityString(soap, &soap_tmp___emi__SetAlertCommunityString, "-emi:SetAlertCommunityString", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__SetAlertCommunityString(soap, &soap_tmp___emi__SetAlertCommunityString, "-emi:SetAlertCommunityString", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__SetAlertCommunityStringResponse) + return soap_closesock(soap); + emi__SetAlertCommunityStringResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__SetAlertCommunityStringResponse->soap_get(soap, "emi:SetAlertCommunityStringResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetAlertCommunityString(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetAlertCommunityString *emi__GetAlertCommunityString, _emi__GetAlertCommunityStringResponse *emi__GetAlertCommunityStringResponse) +{ struct __emi__GetAlertCommunityString soap_tmp___emi__GetAlertCommunityString; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/GetAlertCommunityString"; + soap->encodingStyle = NULL; + soap_tmp___emi__GetAlertCommunityString.emi__GetAlertCommunityString = emi__GetAlertCommunityString; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__GetAlertCommunityString(soap, &soap_tmp___emi__GetAlertCommunityString); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetAlertCommunityString(soap, &soap_tmp___emi__GetAlertCommunityString, "-emi:GetAlertCommunityString", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetAlertCommunityString(soap, &soap_tmp___emi__GetAlertCommunityString, "-emi:GetAlertCommunityString", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__GetAlertCommunityStringResponse) + return soap_closesock(soap); + emi__GetAlertCommunityStringResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__GetAlertCommunityStringResponse->soap_get(soap, "emi:GetAlertCommunityStringResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__AddEventFilter(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__AddEventFilter *emi__AddEventFilter, _emi__AddEventFilterResponse *emi__AddEventFilterResponse) +{ struct __emi__AddEventFilter soap_tmp___emi__AddEventFilter; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/AddEventFilter"; + soap->encodingStyle = NULL; + soap_tmp___emi__AddEventFilter.emi__AddEventFilter = emi__AddEventFilter; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__AddEventFilter(soap, &soap_tmp___emi__AddEventFilter); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__AddEventFilter(soap, &soap_tmp___emi__AddEventFilter, "-emi:AddEventFilter", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__AddEventFilter(soap, &soap_tmp___emi__AddEventFilter, "-emi:AddEventFilter", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__AddEventFilterResponse) + return soap_closesock(soap); + emi__AddEventFilterResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__AddEventFilterResponse->soap_get(soap, "emi:AddEventFilterResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__SubscribeForAlert(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__SubscribeForAlert *emi__SubscribeForAlert, _emi__SubscribeForAlertResponse *emi__SubscribeForAlertResponse) +{ struct __emi__SubscribeForAlert soap_tmp___emi__SubscribeForAlert; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/SubscribeForAlert"; + soap->encodingStyle = NULL; + soap_tmp___emi__SubscribeForAlert.emi__SubscribeForAlert = emi__SubscribeForAlert; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__SubscribeForAlert(soap, &soap_tmp___emi__SubscribeForAlert); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__SubscribeForAlert(soap, &soap_tmp___emi__SubscribeForAlert, "-emi:SubscribeForAlert", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__SubscribeForAlert(soap, &soap_tmp___emi__SubscribeForAlert, "-emi:SubscribeForAlert", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__SubscribeForAlertResponse) + return soap_closesock(soap); + emi__SubscribeForAlertResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__SubscribeForAlertResponse->soap_get(soap, "emi:SubscribeForAlertResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateAlertSubscriptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateAlertSubscriptions *emi__EnumerateAlertSubscriptions, _emi__EnumerateAlertSubscriptionsResponse *emi__EnumerateAlertSubscriptionsResponse) +{ struct __emi__EnumerateAlertSubscriptions soap_tmp___emi__EnumerateAlertSubscriptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/EnumerateAlertSubscriptions"; + soap->encodingStyle = NULL; + soap_tmp___emi__EnumerateAlertSubscriptions.emi__EnumerateAlertSubscriptions = emi__EnumerateAlertSubscriptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__EnumerateAlertSubscriptions(soap, &soap_tmp___emi__EnumerateAlertSubscriptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateAlertSubscriptions(soap, &soap_tmp___emi__EnumerateAlertSubscriptions, "-emi:EnumerateAlertSubscriptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateAlertSubscriptions(soap, &soap_tmp___emi__EnumerateAlertSubscriptions, "-emi:EnumerateAlertSubscriptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__EnumerateAlertSubscriptionsResponse) + return soap_closesock(soap); + emi__EnumerateAlertSubscriptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__EnumerateAlertSubscriptionsResponse->soap_get(soap, "emi:EnumerateAlertSubscriptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateAlertPolicies(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateAlertPolicies *emi__EnumerateAlertPolicies, _emi__EnumerateAlertPoliciesResponse *emi__EnumerateAlertPoliciesResponse) +{ struct __emi__EnumerateAlertPolicies soap_tmp___emi__EnumerateAlertPolicies; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/EnumerateAlertPolicies"; + soap->encodingStyle = NULL; + soap_tmp___emi__EnumerateAlertPolicies.emi__EnumerateAlertPolicies = emi__EnumerateAlertPolicies; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__EnumerateAlertPolicies(soap, &soap_tmp___emi__EnumerateAlertPolicies); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateAlertPolicies(soap, &soap_tmp___emi__EnumerateAlertPolicies, "-emi:EnumerateAlertPolicies", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateAlertPolicies(soap, &soap_tmp___emi__EnumerateAlertPolicies, "-emi:EnumerateAlertPolicies", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__EnumerateAlertPoliciesResponse) + return soap_closesock(soap); + emi__EnumerateAlertPoliciesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__EnumerateAlertPoliciesResponse->soap_get(soap, "emi:EnumerateAlertPoliciesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__CancelAlertSubscription(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__CancelAlertSubscription *emi__CancelAlertSubscription, _emi__CancelAlertSubscriptionResponse *emi__CancelAlertSubscriptionResponse) +{ struct __emi__CancelAlertSubscription soap_tmp___emi__CancelAlertSubscription; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/CancelAlertSubscription"; + soap->encodingStyle = NULL; + soap_tmp___emi__CancelAlertSubscription.emi__CancelAlertSubscription = emi__CancelAlertSubscription; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__CancelAlertSubscription(soap, &soap_tmp___emi__CancelAlertSubscription); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__CancelAlertSubscription(soap, &soap_tmp___emi__CancelAlertSubscription, "-emi:CancelAlertSubscription", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__CancelAlertSubscription(soap, &soap_tmp___emi__CancelAlertSubscription, "-emi:CancelAlertSubscription", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__CancelAlertSubscriptionResponse) + return soap_closesock(soap); + emi__CancelAlertSubscriptionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__CancelAlertSubscriptionResponse->soap_get(soap, "emi:CancelAlertSubscriptionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetEventFilter(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetEventFilter *emi__GetEventFilter, _emi__GetEventFilterResponse *emi__GetEventFilterResponse) +{ struct __emi__GetEventFilter soap_tmp___emi__GetEventFilter; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/GetEventFilter"; + soap->encodingStyle = NULL; + soap_tmp___emi__GetEventFilter.emi__GetEventFilter = emi__GetEventFilter; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__GetEventFilter(soap, &soap_tmp___emi__GetEventFilter); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetEventFilter(soap, &soap_tmp___emi__GetEventFilter, "-emi:GetEventFilter", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetEventFilter(soap, &soap_tmp___emi__GetEventFilter, "-emi:GetEventFilter", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__GetEventFilterResponse) + return soap_closesock(soap); + emi__GetEventFilterResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__GetEventFilterResponse->soap_get(soap, "emi:GetEventFilterResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__UpdateEventFilter(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__UpdateEventFilter *emi__UpdateEventFilter, _emi__UpdateEventFilterResponse *emi__UpdateEventFilterResponse) +{ struct __emi__UpdateEventFilter soap_tmp___emi__UpdateEventFilter; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/UpdateEventFilter"; + soap->encodingStyle = NULL; + soap_tmp___emi__UpdateEventFilter.emi__UpdateEventFilter = emi__UpdateEventFilter; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__UpdateEventFilter(soap, &soap_tmp___emi__UpdateEventFilter); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__UpdateEventFilter(soap, &soap_tmp___emi__UpdateEventFilter, "-emi:UpdateEventFilter", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__UpdateEventFilter(soap, &soap_tmp___emi__UpdateEventFilter, "-emi:UpdateEventFilter", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__UpdateEventFilterResponse) + return soap_closesock(soap); + emi__UpdateEventFilterResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__UpdateEventFilterResponse->soap_get(soap, "emi:UpdateEventFilterResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__RemoveEventFilter(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__RemoveEventFilter *emi__RemoveEventFilter, _emi__RemoveEventFilterResponse *emi__RemoveEventFilterResponse) +{ struct __emi__RemoveEventFilter soap_tmp___emi__RemoveEventFilter; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/RemoveEventFilter"; + soap->encodingStyle = NULL; + soap_tmp___emi__RemoveEventFilter.emi__RemoveEventFilter = emi__RemoveEventFilter; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__RemoveEventFilter(soap, &soap_tmp___emi__RemoveEventFilter); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__RemoveEventFilter(soap, &soap_tmp___emi__RemoveEventFilter, "-emi:RemoveEventFilter", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__RemoveEventFilter(soap, &soap_tmp___emi__RemoveEventFilter, "-emi:RemoveEventFilter", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__RemoveEventFilterResponse) + return soap_closesock(soap); + emi__RemoveEventFilterResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__RemoveEventFilterResponse->soap_get(soap, "emi:RemoveEventFilterResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetEventLogStatus(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetEventLogStatus *emi__GetEventLogStatus, _emi__GetEventLogStatusResponse *emi__GetEventLogStatusResponse) +{ struct __emi__GetEventLogStatus soap_tmp___emi__GetEventLogStatus; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/GetEventLogStatus"; + soap->encodingStyle = NULL; + soap_tmp___emi__GetEventLogStatus.emi__GetEventLogStatus = emi__GetEventLogStatus; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__GetEventLogStatus(soap, &soap_tmp___emi__GetEventLogStatus); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetEventLogStatus(soap, &soap_tmp___emi__GetEventLogStatus, "-emi:GetEventLogStatus", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetEventLogStatus(soap, &soap_tmp___emi__GetEventLogStatus, "-emi:GetEventLogStatus", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__GetEventLogStatusResponse) + return soap_closesock(soap); + emi__GetEventLogStatusResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__GetEventLogStatusResponse->soap_get(soap, "emi:GetEventLogStatusResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__ReadEventLogRecords(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__ReadEventLogRecords *emi__ReadEventLogRecords, _emi__ReadEventLogRecordsResponse *emi__ReadEventLogRecordsResponse) +{ struct __emi__ReadEventLogRecords soap_tmp___emi__ReadEventLogRecords; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/ReadEventLogRecords"; + soap->encodingStyle = NULL; + soap_tmp___emi__ReadEventLogRecords.emi__ReadEventLogRecords = emi__ReadEventLogRecords; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__ReadEventLogRecords(soap, &soap_tmp___emi__ReadEventLogRecords); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__ReadEventLogRecords(soap, &soap_tmp___emi__ReadEventLogRecords, "-emi:ReadEventLogRecords", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__ReadEventLogRecords(soap, &soap_tmp___emi__ReadEventLogRecords, "-emi:ReadEventLogRecords", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__ReadEventLogRecordsResponse) + return soap_closesock(soap); + emi__ReadEventLogRecordsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__ReadEventLogRecordsResponse->soap_get(soap, "emi:ReadEventLogRecordsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__ClearEventLog(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__ClearEventLog *emi__ClearEventLog, _emi__ClearEventLogResponse *emi__ClearEventLogResponse) +{ struct __emi__ClearEventLog soap_tmp___emi__ClearEventLog; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/ClearEventLog"; + soap->encodingStyle = NULL; + soap_tmp___emi__ClearEventLog.emi__ClearEventLog = emi__ClearEventLog; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__ClearEventLog(soap, &soap_tmp___emi__ClearEventLog); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__ClearEventLog(soap, &soap_tmp___emi__ClearEventLog, "-emi:ClearEventLog", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__ClearEventLog(soap, &soap_tmp___emi__ClearEventLog, "-emi:ClearEventLog", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__ClearEventLogResponse) + return soap_closesock(soap); + emi__ClearEventLogResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__ClearEventLogResponse->soap_get(soap, "emi:ClearEventLogResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__FreezeEventLog(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__FreezeEventLog *emi__FreezeEventLog, _emi__FreezeEventLogResponse *emi__FreezeEventLogResponse) +{ struct __emi__FreezeEventLog soap_tmp___emi__FreezeEventLog; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2004/01/FreezeEventLog"; + soap->encodingStyle = NULL; + soap_tmp___emi__FreezeEventLog.emi__FreezeEventLog = emi__FreezeEventLog; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__FreezeEventLog(soap, &soap_tmp___emi__FreezeEventLog); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__FreezeEventLog(soap, &soap_tmp___emi__FreezeEventLog, "-emi:FreezeEventLog", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__FreezeEventLog(soap, &soap_tmp___emi__FreezeEventLog, "-emi:FreezeEventLog", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__FreezeEventLogResponse) + return soap_closesock(soap); + emi__FreezeEventLogResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__FreezeEventLogResponse->soap_get(soap, "emi:FreezeEventLogResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__SetEventLogTimestampClock(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__SetEventLogTimestampClock *emi__SetEventLogTimestampClock, _emi__SetEventLogTimestampClockResponse *emi__SetEventLogTimestampClockResponse) +{ struct __emi__SetEventLogTimestampClock soap_tmp___emi__SetEventLogTimestampClock; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/ptai/2004/01/SetEventLogTimestampClock"; + soap->encodingStyle = NULL; + soap_tmp___emi__SetEventLogTimestampClock.emi__SetEventLogTimestampClock = emi__SetEventLogTimestampClock; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__SetEventLogTimestampClock(soap, &soap_tmp___emi__SetEventLogTimestampClock); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__SetEventLogTimestampClock(soap, &soap_tmp___emi__SetEventLogTimestampClock, "-emi:SetEventLogTimestampClock", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__SetEventLogTimestampClock(soap, &soap_tmp___emi__SetEventLogTimestampClock, "-emi:SetEventLogTimestampClock", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__SetEventLogTimestampClockResponse) + return soap_closesock(soap); + emi__SetEventLogTimestampClockResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__SetEventLogTimestampClockResponse->soap_get(soap, "emi:SetEventLogTimestampClockResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetEventLogTimestampClock(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetEventLogTimestampClock *emi__GetEventLogTimestampClock, _emi__GetEventLogTimestampClockResponse *emi__GetEventLogTimestampClockResponse) +{ struct __emi__GetEventLogTimestampClock soap_tmp___emi__GetEventLogTimestampClock; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/ptai/2004/01/GetEventLogTimestampClock"; + soap->encodingStyle = NULL; + soap_tmp___emi__GetEventLogTimestampClock.emi__GetEventLogTimestampClock = emi__GetEventLogTimestampClock; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__GetEventLogTimestampClock(soap, &soap_tmp___emi__GetEventLogTimestampClock); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetEventLogTimestampClock(soap, &soap_tmp___emi__GetEventLogTimestampClock, "-emi:GetEventLogTimestampClock", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetEventLogTimestampClock(soap, &soap_tmp___emi__GetEventLogTimestampClock, "-emi:GetEventLogTimestampClock", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__GetEventLogTimestampClockResponse) + return soap_closesock(soap); + emi__GetEventLogTimestampClockResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__GetEventLogTimestampClockResponse->soap_get(soap, "emi:GetEventLogTimestampClockResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateSensors(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateSensors *emi__EnumerateSensors, _emi__EnumerateSensorsResponse *emi__EnumerateSensorsResponse) +{ struct __emi__EnumerateSensors soap_tmp___emi__EnumerateSensors; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/ptai/2004/01/EnumerateSensors"; + soap->encodingStyle = NULL; + soap_tmp___emi__EnumerateSensors.emi__EnumerateSensors = emi__EnumerateSensors; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__EnumerateSensors(soap, &soap_tmp___emi__EnumerateSensors); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateSensors(soap, &soap_tmp___emi__EnumerateSensors, "-emi:EnumerateSensors", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateSensors(soap, &soap_tmp___emi__EnumerateSensors, "-emi:EnumerateSensors", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__EnumerateSensorsResponse) + return soap_closesock(soap); + emi__EnumerateSensorsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__EnumerateSensorsResponse->soap_get(soap, "emi:EnumerateSensorsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetSensorAttributes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetSensorAttributes *emi__GetSensorAttributes, _emi__GetSensorAttributesResponse *emi__GetSensorAttributesResponse) +{ struct __emi__GetSensorAttributes soap_tmp___emi__GetSensorAttributes; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/ptai/2004/01/GetSensorAttributes"; + soap->encodingStyle = NULL; + soap_tmp___emi__GetSensorAttributes.emi__GetSensorAttributes = emi__GetSensorAttributes; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__GetSensorAttributes(soap, &soap_tmp___emi__GetSensorAttributes); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetSensorAttributes(soap, &soap_tmp___emi__GetSensorAttributes, "-emi:GetSensorAttributes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetSensorAttributes(soap, &soap_tmp___emi__GetSensorAttributes, "-emi:GetSensorAttributes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__GetSensorAttributesResponse) + return soap_closesock(soap); + emi__GetSensorAttributesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__GetSensorAttributesResponse->soap_get(soap, "emi:GetSensorAttributesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__SubscribeForGeneralAlert(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__SubscribeForGeneralAlert *emi__SubscribeForGeneralAlert, _emi__SubscribeForGeneralAlertResponse *emi__SubscribeForGeneralAlertResponse) +{ struct __emi__SubscribeForGeneralAlert soap_tmp___emi__SubscribeForGeneralAlert; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2006/01/SubscribeForGeneralAlert"; + soap->encodingStyle = NULL; + soap_tmp___emi__SubscribeForGeneralAlert.emi__SubscribeForGeneralAlert = emi__SubscribeForGeneralAlert; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__SubscribeForGeneralAlert(soap, &soap_tmp___emi__SubscribeForGeneralAlert); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__SubscribeForGeneralAlert(soap, &soap_tmp___emi__SubscribeForGeneralAlert, "-emi:SubscribeForGeneralAlert", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__SubscribeForGeneralAlert(soap, &soap_tmp___emi__SubscribeForGeneralAlert, "-emi:SubscribeForGeneralAlert", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__SubscribeForGeneralAlertResponse) + return soap_closesock(soap); + emi__SubscribeForGeneralAlertResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__SubscribeForGeneralAlertResponse->soap_get(soap, "emi:SubscribeForGeneralAlertResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__EnumerateGeneralAlertSubscriptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__EnumerateGeneralAlertSubscriptions *emi__EnumerateGeneralAlertSubscriptions, _emi__EnumerateGeneralAlertSubscriptionsResponse *emi__EnumerateGeneralAlertSubscriptionsResponse) +{ struct __emi__EnumerateGeneralAlertSubscriptions soap_tmp___emi__EnumerateGeneralAlertSubscriptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2006/01/EnumerateGeneralAlertSubscriptions"; + soap->encodingStyle = NULL; + soap_tmp___emi__EnumerateGeneralAlertSubscriptions.emi__EnumerateGeneralAlertSubscriptions = emi__EnumerateGeneralAlertSubscriptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__EnumerateGeneralAlertSubscriptions(soap, &soap_tmp___emi__EnumerateGeneralAlertSubscriptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateGeneralAlertSubscriptions(soap, &soap_tmp___emi__EnumerateGeneralAlertSubscriptions, "-emi:EnumerateGeneralAlertSubscriptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__EnumerateGeneralAlertSubscriptions(soap, &soap_tmp___emi__EnumerateGeneralAlertSubscriptions, "-emi:EnumerateGeneralAlertSubscriptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__EnumerateGeneralAlertSubscriptionsResponse) + return soap_closesock(soap); + emi__EnumerateGeneralAlertSubscriptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__EnumerateGeneralAlertSubscriptionsResponse->soap_get(soap, "emi:EnumerateGeneralAlertSubscriptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___emi__GetGeneralAlertSubscription(struct soap *soap, const char *soap_endpoint, const char *soap_action, _emi__GetGeneralAlertSubscription *emi__GetGeneralAlertSubscription, _emi__GetGeneralAlertSubscriptionResponse *emi__GetGeneralAlertSubscriptionResponse) +{ struct __emi__GetGeneralAlertSubscription soap_tmp___emi__GetGeneralAlertSubscription; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/EventManagerService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/EventManager/2006/01/GetGeneralAlertSubscription"; + soap->encodingStyle = NULL; + soap_tmp___emi__GetGeneralAlertSubscription.emi__GetGeneralAlertSubscription = emi__GetGeneralAlertSubscription; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___emi__GetGeneralAlertSubscription(soap, &soap_tmp___emi__GetGeneralAlertSubscription); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetGeneralAlertSubscription(soap, &soap_tmp___emi__GetGeneralAlertSubscription, "-emi:GetGeneralAlertSubscription", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___emi__GetGeneralAlertSubscription(soap, &soap_tmp___emi__GetGeneralAlertSubscription, "-emi:GetGeneralAlertSubscription", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!emi__GetGeneralAlertSubscriptionResponse) + return soap_closesock(soap); + emi__GetGeneralAlertSubscriptionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + emi__GetGeneralAlertSubscriptionResponse->soap_get(soap, "emi:GetGeneralAlertSubscriptionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___hwa__EnumerateAssetTypes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _hwa__EnumerateAssetTypes *hwa__EnumerateAssetTypes, _hwa__EnumerateAssetTypesResponse *hwa__EnumerateAssetTypesResponse) +{ struct __hwa__EnumerateAssetTypes soap_tmp___hwa__EnumerateAssetTypes; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/HardwareAssetService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/HardwareAsset/2004/01/EnumerateAssetTypes"; + soap->encodingStyle = NULL; + soap_tmp___hwa__EnumerateAssetTypes.hwa__EnumerateAssetTypes = hwa__EnumerateAssetTypes; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___hwa__EnumerateAssetTypes(soap, &soap_tmp___hwa__EnumerateAssetTypes); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___hwa__EnumerateAssetTypes(soap, &soap_tmp___hwa__EnumerateAssetTypes, "-hwa:EnumerateAssetTypes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___hwa__EnumerateAssetTypes(soap, &soap_tmp___hwa__EnumerateAssetTypes, "-hwa:EnumerateAssetTypes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!hwa__EnumerateAssetTypesResponse) + return soap_closesock(soap); + hwa__EnumerateAssetTypesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + hwa__EnumerateAssetTypesResponse->soap_get(soap, "hwa:EnumerateAssetTypesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___hwa__GetAssetData(struct soap *soap, const char *soap_endpoint, const char *soap_action, _hwa__GetAssetData *hwa__GetAssetData, _hwa__GetAssetDataResponse *hwa__GetAssetDataResponse) +{ struct __hwa__GetAssetData soap_tmp___hwa__GetAssetData; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/HardwareAssetService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/HardwareAsset/2004/01/GetAssetData"; + soap->encodingStyle = NULL; + soap_tmp___hwa__GetAssetData.hwa__GetAssetData = hwa__GetAssetData; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___hwa__GetAssetData(soap, &soap_tmp___hwa__GetAssetData); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___hwa__GetAssetData(soap, &soap_tmp___hwa__GetAssetData, "-hwa:GetAssetData", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___hwa__GetAssetData(soap, &soap_tmp___hwa__GetAssetData, "-hwa:GetAssetData", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!hwa__GetAssetDataResponse) + return soap_closesock(soap); + hwa__GetAssetDataResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + hwa__GetAssetDataResponse->soap_get(soap, "hwa:GetAssetDataResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___idr__SetRedirectionListenerState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _idr__SetRedirectionListenerState *idr__SetRedirectionListenerState, _idr__SetRedirectionListenerStateResponse *idr__SetRedirectionListenerStateResponse) +{ struct __idr__SetRedirectionListenerState soap_tmp___idr__SetRedirectionListenerState; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/RedirectionService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/Redirection/2004/01/SetRedirectionListenerState"; + soap->encodingStyle = NULL; + soap_tmp___idr__SetRedirectionListenerState.idr__SetRedirectionListenerState = idr__SetRedirectionListenerState; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___idr__SetRedirectionListenerState(soap, &soap_tmp___idr__SetRedirectionListenerState); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___idr__SetRedirectionListenerState(soap, &soap_tmp___idr__SetRedirectionListenerState, "-idr:SetRedirectionListenerState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___idr__SetRedirectionListenerState(soap, &soap_tmp___idr__SetRedirectionListenerState, "-idr:SetRedirectionListenerState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!idr__SetRedirectionListenerStateResponse) + return soap_closesock(soap); + idr__SetRedirectionListenerStateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + idr__SetRedirectionListenerStateResponse->soap_get(soap, "idr:SetRedirectionListenerStateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___idr__GetRedirectionListenerState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _idr__GetRedirectionListenerState *idr__GetRedirectionListenerState, _idr__GetRedirectionListenerStateResponse *idr__GetRedirectionListenerStateResponse) +{ struct __idr__GetRedirectionListenerState soap_tmp___idr__GetRedirectionListenerState; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/RedirectionService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/Redirection/2004/01/GetRedirectionListenerState"; + soap->encodingStyle = NULL; + soap_tmp___idr__GetRedirectionListenerState.idr__GetRedirectionListenerState = idr__GetRedirectionListenerState; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___idr__GetRedirectionListenerState(soap, &soap_tmp___idr__GetRedirectionListenerState); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___idr__GetRedirectionListenerState(soap, &soap_tmp___idr__GetRedirectionListenerState, "-idr:GetRedirectionListenerState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___idr__GetRedirectionListenerState(soap, &soap_tmp___idr__GetRedirectionListenerState, "-idr:GetRedirectionListenerState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!idr__GetRedirectionListenerStateResponse) + return soap_closesock(soap); + idr__GetRedirectionListenerStateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + idr__GetRedirectionListenerStateResponse->soap_get(soap, "idr:GetRedirectionListenerStateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___idr__GetIderSessionLog(struct soap *soap, const char *soap_endpoint, const char *soap_action, _idr__GetIderSessionLog *idr__GetIderSessionLog, _idr__GetIderSessionLogResponse *idr__GetIderSessionLogResponse) +{ struct __idr__GetIderSessionLog soap_tmp___idr__GetIderSessionLog; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/RedirectionService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/Redirection/2004/01/GetIderSessionLog"; + soap->encodingStyle = NULL; + soap_tmp___idr__GetIderSessionLog.idr__GetIderSessionLog = idr__GetIderSessionLog; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___idr__GetIderSessionLog(soap, &soap_tmp___idr__GetIderSessionLog); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___idr__GetIderSessionLog(soap, &soap_tmp___idr__GetIderSessionLog, "-idr:GetIderSessionLog", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___idr__GetIderSessionLog(soap, &soap_tmp___idr__GetIderSessionLog, "-idr:GetIderSessionLog", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!idr__GetIderSessionLogResponse) + return soap_closesock(soap); + idr__GetIderSessionLogResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + idr__GetIderSessionLogResponse->soap_get(soap, "idr:GetIderSessionLogResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetCoreVersion(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetCoreVersion *inf__GetCoreVersion, _inf__GetCoreVersionResponse *inf__GetCoreVersionResponse) +{ struct __inf__GetCoreVersion soap_tmp___inf__GetCoreVersion; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetCoreVersion"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetCoreVersion.inf__GetCoreVersion = inf__GetCoreVersion; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetCoreVersion(soap, &soap_tmp___inf__GetCoreVersion); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetCoreVersion(soap, &soap_tmp___inf__GetCoreVersion, "-inf:GetCoreVersion", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetCoreVersion(soap, &soap_tmp___inf__GetCoreVersion, "-inf:GetCoreVersion", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetCoreVersionResponse) + return soap_closesock(soap); + inf__GetCoreVersionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetCoreVersionResponse->soap_get(soap, "inf:GetCoreVersionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetCodeVersions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetCodeVersions *inf__GetCodeVersions, _inf__GetCodeVersionsResponse *inf__GetCodeVersionsResponse) +{ struct __inf__GetCodeVersions soap_tmp___inf__GetCodeVersions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetCodeVersions"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetCodeVersions.inf__GetCodeVersions = inf__GetCodeVersions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetCodeVersions(soap, &soap_tmp___inf__GetCodeVersions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetCodeVersions(soap, &soap_tmp___inf__GetCodeVersions, "-inf:GetCodeVersions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetCodeVersions(soap, &soap_tmp___inf__GetCodeVersions, "-inf:GetCodeVersions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetCodeVersionsResponse) + return soap_closesock(soap); + inf__GetCodeVersionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetCodeVersionsResponse->soap_get(soap, "inf:GetCodeVersionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetProvisioningMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetProvisioningMode *inf__GetProvisioningMode, _inf__GetProvisioningModeResponse *inf__GetProvisioningModeResponse) +{ struct __inf__GetProvisioningMode soap_tmp___inf__GetProvisioningMode; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetProvisioningMode"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetProvisioningMode.inf__GetProvisioningMode = inf__GetProvisioningMode; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetProvisioningMode(soap, &soap_tmp___inf__GetProvisioningMode); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetProvisioningMode(soap, &soap_tmp___inf__GetProvisioningMode, "-inf:GetProvisioningMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetProvisioningMode(soap, &soap_tmp___inf__GetProvisioningMode, "-inf:GetProvisioningMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetProvisioningModeResponse) + return soap_closesock(soap); + inf__GetProvisioningModeResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetProvisioningModeResponse->soap_get(soap, "inf:GetProvisioningModeResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetProvisioningState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetProvisioningState *inf__GetProvisioningState, _inf__GetProvisioningStateResponse *inf__GetProvisioningStateResponse) +{ struct __inf__GetProvisioningState soap_tmp___inf__GetProvisioningState; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetProvisioningState"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetProvisioningState.inf__GetProvisioningState = inf__GetProvisioningState; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetProvisioningState(soap, &soap_tmp___inf__GetProvisioningState); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetProvisioningState(soap, &soap_tmp___inf__GetProvisioningState, "-inf:GetProvisioningState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetProvisioningState(soap, &soap_tmp___inf__GetProvisioningState, "-inf:GetProvisioningState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetProvisioningStateResponse) + return soap_closesock(soap); + inf__GetProvisioningStateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetProvisioningStateResponse->soap_get(soap, "inf:GetProvisioningStateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetVlanParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetVlanParameters *inf__GetVlanParameters, _inf__GetVlanParametersResponse *inf__GetVlanParametersResponse) +{ struct __inf__GetVlanParameters soap_tmp___inf__GetVlanParameters; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetVlanParameters"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetVlanParameters.inf__GetVlanParameters = inf__GetVlanParameters; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetVlanParameters(soap, &soap_tmp___inf__GetVlanParameters); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetVlanParameters(soap, &soap_tmp___inf__GetVlanParameters, "-inf:GetVlanParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetVlanParameters(soap, &soap_tmp___inf__GetVlanParameters, "-inf:GetVlanParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetVlanParametersResponse) + return soap_closesock(soap); + inf__GetVlanParametersResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetVlanParametersResponse->soap_get(soap, "inf:GetVlanParametersResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetHostName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetHostName *inf__GetHostName, _inf__GetHostNameResponse *inf__GetHostNameResponse) +{ struct __inf__GetHostName soap_tmp___inf__GetHostName; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetHostName"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetHostName.inf__GetHostName = inf__GetHostName; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetHostName(soap, &soap_tmp___inf__GetHostName); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetHostName(soap, &soap_tmp___inf__GetHostName, "-inf:GetHostName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetHostName(soap, &soap_tmp___inf__GetHostName, "-inf:GetHostName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetHostNameResponse) + return soap_closesock(soap); + inf__GetHostNameResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetHostNameResponse->soap_get(soap, "inf:GetHostNameResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetConfigServerInfo(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetConfigServerInfo *inf__GetConfigServerInfo, _inf__GetConfigServerInfoResponse *inf__GetConfigServerInfoResponse) +{ struct __inf__GetConfigServerInfo soap_tmp___inf__GetConfigServerInfo; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetConfigServerInfo"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetConfigServerInfo.inf__GetConfigServerInfo = inf__GetConfigServerInfo; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetConfigServerInfo(soap, &soap_tmp___inf__GetConfigServerInfo); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetConfigServerInfo(soap, &soap_tmp___inf__GetConfigServerInfo, "-inf:GetConfigServerInfo", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetConfigServerInfo(soap, &soap_tmp___inf__GetConfigServerInfo, "-inf:GetConfigServerInfo", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetConfigServerInfoResponse) + return soap_closesock(soap); + inf__GetConfigServerInfoResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetConfigServerInfoResponse->soap_get(soap, "inf:GetConfigServerInfoResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetAdminAclEntryStatus(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetAdminAclEntryStatus *inf__GetAdminAclEntryStatus, _inf__GetAdminAclEntryStatusResponse *inf__GetAdminAclEntryStatusResponse) +{ struct __inf__GetAdminAclEntryStatus soap_tmp___inf__GetAdminAclEntryStatus; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetAdminAclEntryStatus"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetAdminAclEntryStatus.inf__GetAdminAclEntryStatus = inf__GetAdminAclEntryStatus; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetAdminAclEntryStatus(soap, &soap_tmp___inf__GetAdminAclEntryStatus); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetAdminAclEntryStatus(soap, &soap_tmp___inf__GetAdminAclEntryStatus, "-inf:GetAdminAclEntryStatus", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetAdminAclEntryStatus(soap, &soap_tmp___inf__GetAdminAclEntryStatus, "-inf:GetAdminAclEntryStatus", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetAdminAclEntryStatusResponse) + return soap_closesock(soap); + inf__GetAdminAclEntryStatusResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetAdminAclEntryStatusResponse->soap_get(soap, "inf:GetAdminAclEntryStatusResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetAdminNetAclEntryStatus(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetAdminNetAclEntryStatus *inf__GetAdminNetAclEntryStatus, _inf__GetAdminNetAclEntryStatusResponse *inf__GetAdminNetAclEntryStatusResponse) +{ struct __inf__GetAdminNetAclEntryStatus soap_tmp___inf__GetAdminNetAclEntryStatus; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetAdminNetAclEntryStatus"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetAdminNetAclEntryStatus.inf__GetAdminNetAclEntryStatus = inf__GetAdminNetAclEntryStatus; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetAdminNetAclEntryStatus(soap, &soap_tmp___inf__GetAdminNetAclEntryStatus); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetAdminNetAclEntryStatus(soap, &soap_tmp___inf__GetAdminNetAclEntryStatus, "-inf:GetAdminNetAclEntryStatus", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetAdminNetAclEntryStatus(soap, &soap_tmp___inf__GetAdminNetAclEntryStatus, "-inf:GetAdminNetAclEntryStatus", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetAdminNetAclEntryStatusResponse) + return soap_closesock(soap); + inf__GetAdminNetAclEntryStatusResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetAdminNetAclEntryStatusResponse->soap_get(soap, "inf:GetAdminNetAclEntryStatusResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetPasswordModel(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetPasswordModel *inf__GetPasswordModel, _inf__GetPasswordModelResponse *inf__GetPasswordModelResponse) +{ struct __inf__GetPasswordModel soap_tmp___inf__GetPasswordModel; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetPasswordModel"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetPasswordModel.inf__GetPasswordModel = inf__GetPasswordModel; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetPasswordModel(soap, &soap_tmp___inf__GetPasswordModel); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetPasswordModel(soap, &soap_tmp___inf__GetPasswordModel, "-inf:GetPasswordModel", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetPasswordModel(soap, &soap_tmp___inf__GetPasswordModel, "-inf:GetPasswordModel", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetPasswordModelResponse) + return soap_closesock(soap); + inf__GetPasswordModelResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetPasswordModelResponse->soap_get(soap, "inf:GetPasswordModelResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetEnabledInterfaces(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetEnabledInterfaces *inf__GetEnabledInterfaces, _inf__GetEnabledInterfacesResponse *inf__GetEnabledInterfacesResponse) +{ struct __inf__GetEnabledInterfaces soap_tmp___inf__GetEnabledInterfaces; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetEnabledInterfaces"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetEnabledInterfaces.inf__GetEnabledInterfaces = inf__GetEnabledInterfaces; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetEnabledInterfaces(soap, &soap_tmp___inf__GetEnabledInterfaces); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetEnabledInterfaces(soap, &soap_tmp___inf__GetEnabledInterfaces, "-inf:GetEnabledInterfaces", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetEnabledInterfaces(soap, &soap_tmp___inf__GetEnabledInterfaces, "-inf:GetEnabledInterfaces", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetEnabledInterfacesResponse) + return soap_closesock(soap); + inf__GetEnabledInterfacesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetEnabledInterfacesResponse->soap_get(soap, "inf:GetEnabledInterfacesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetNetworkState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetNetworkState *inf__GetNetworkState, _inf__GetNetworkStateResponse *inf__GetNetworkStateResponse) +{ struct __inf__GetNetworkState soap_tmp___inf__GetNetworkState; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetNetworkState"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetNetworkState.inf__GetNetworkState = inf__GetNetworkState; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetNetworkState(soap, &soap_tmp___inf__GetNetworkState); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetNetworkState(soap, &soap_tmp___inf__GetNetworkState, "-inf:GetNetworkState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetNetworkState(soap, &soap_tmp___inf__GetNetworkState, "-inf:GetNetworkState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetNetworkStateResponse) + return soap_closesock(soap); + inf__GetNetworkStateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetNetworkStateResponse->soap_get(soap, "inf:GetNetworkStateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetSecurityParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetSecurityParameters *inf__GetSecurityParameters, _inf__GetSecurityParametersResponse *inf__GetSecurityParametersResponse) +{ struct __inf__GetSecurityParameters soap_tmp___inf__GetSecurityParameters; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetSecurityParameters"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetSecurityParameters.inf__GetSecurityParameters = inf__GetSecurityParameters; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetSecurityParameters(soap, &soap_tmp___inf__GetSecurityParameters); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetSecurityParameters(soap, &soap_tmp___inf__GetSecurityParameters, "-inf:GetSecurityParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetSecurityParameters(soap, &soap_tmp___inf__GetSecurityParameters, "-inf:GetSecurityParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetSecurityParametersResponse) + return soap_closesock(soap); + inf__GetSecurityParametersResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetSecurityParametersResponse->soap_get(soap, "inf:GetSecurityParametersResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___inf__GetIderSessionLog(struct soap *soap, const char *soap_endpoint, const char *soap_action, _inf__GetIderSessionLog *inf__GetIderSessionLog, _inf__GetIderSessionLogResponse *inf__GetIderSessionLogResponse) +{ struct __inf__GetIderSessionLog soap_tmp___inf__GetIderSessionLog; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/GeneralInfoService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/GeneralInfo/2004/01/GetIderSessionLog"; + soap->encodingStyle = NULL; + soap_tmp___inf__GetIderSessionLog.inf__GetIderSessionLog = inf__GetIderSessionLog; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___inf__GetIderSessionLog(soap, &soap_tmp___inf__GetIderSessionLog); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetIderSessionLog(soap, &soap_tmp___inf__GetIderSessionLog, "-inf:GetIderSessionLog", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___inf__GetIderSessionLog(soap, &soap_tmp___inf__GetIderSessionLog, "-inf:GetIderSessionLog", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!inf__GetIderSessionLogResponse) + return soap_closesock(soap); + inf__GetIderSessionLogResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + inf__GetIderSessionLogResponse->soap_get(soap, "inf:GetIderSessionLogResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetHostName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetHostName *net__SetHostName, _net__SetHostNameResponse *net__SetHostNameResponse) +{ struct __net__SetHostName soap_tmp___net__SetHostName; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/SetHostName"; + soap->encodingStyle = NULL; + soap_tmp___net__SetHostName.net__SetHostName = net__SetHostName; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__SetHostName(soap, &soap_tmp___net__SetHostName); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetHostName(soap, &soap_tmp___net__SetHostName, "-net:SetHostName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetHostName(soap, &soap_tmp___net__SetHostName, "-net:SetHostName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__SetHostNameResponse) + return soap_closesock(soap); + net__SetHostNameResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__SetHostNameResponse->soap_get(soap, "net:SetHostNameResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetHostName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetHostName *net__GetHostName, _net__GetHostNameResponse *net__GetHostNameResponse) +{ struct __net__GetHostName soap_tmp___net__GetHostName; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/GetHostName"; + soap->encodingStyle = NULL; + soap_tmp___net__GetHostName.net__GetHostName = net__GetHostName; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__GetHostName(soap, &soap_tmp___net__GetHostName); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetHostName(soap, &soap_tmp___net__GetHostName, "-net:GetHostName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetHostName(soap, &soap_tmp___net__GetHostName, "-net:GetHostName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__GetHostNameResponse) + return soap_closesock(soap); + net__GetHostNameResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__GetHostNameResponse->soap_get(soap, "net:GetHostNameResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetDomainName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetDomainName *net__SetDomainName, _net__SetDomainNameResponse *net__SetDomainNameResponse) +{ struct __net__SetDomainName soap_tmp___net__SetDomainName; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/SetDomainName"; + soap->encodingStyle = NULL; + soap_tmp___net__SetDomainName.net__SetDomainName = net__SetDomainName; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__SetDomainName(soap, &soap_tmp___net__SetDomainName); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetDomainName(soap, &soap_tmp___net__SetDomainName, "-net:SetDomainName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetDomainName(soap, &soap_tmp___net__SetDomainName, "-net:SetDomainName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__SetDomainNameResponse) + return soap_closesock(soap); + net__SetDomainNameResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__SetDomainNameResponse->soap_get(soap, "net:SetDomainNameResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetDomainName(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetDomainName *net__GetDomainName, _net__GetDomainNameResponse *net__GetDomainNameResponse) +{ struct __net__GetDomainName soap_tmp___net__GetDomainName; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/GetDomainName"; + soap->encodingStyle = NULL; + soap_tmp___net__GetDomainName.net__GetDomainName = net__GetDomainName; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__GetDomainName(soap, &soap_tmp___net__GetDomainName); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetDomainName(soap, &soap_tmp___net__GetDomainName, "-net:GetDomainName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetDomainName(soap, &soap_tmp___net__GetDomainName, "-net:GetDomainName", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__GetDomainNameResponse) + return soap_closesock(soap); + net__GetDomainNameResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__GetDomainNameResponse->soap_get(soap, "net:GetDomainNameResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetTcpIpParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetTcpIpParameters *net__SetTcpIpParameters, _net__SetTcpIpParametersResponse *net__SetTcpIpParametersResponse) +{ struct __net__SetTcpIpParameters soap_tmp___net__SetTcpIpParameters; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/SetTcpIpParameters"; + soap->encodingStyle = NULL; + soap_tmp___net__SetTcpIpParameters.net__SetTcpIpParameters = net__SetTcpIpParameters; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__SetTcpIpParameters(soap, &soap_tmp___net__SetTcpIpParameters); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetTcpIpParameters(soap, &soap_tmp___net__SetTcpIpParameters, "-net:SetTcpIpParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetTcpIpParameters(soap, &soap_tmp___net__SetTcpIpParameters, "-net:SetTcpIpParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__SetTcpIpParametersResponse) + return soap_closesock(soap); + net__SetTcpIpParametersResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__SetTcpIpParametersResponse->soap_get(soap, "net:SetTcpIpParametersResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetTcpIpParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetTcpIpParameters *net__GetTcpIpParameters, _net__GetTcpIpParametersResponse *net__GetTcpIpParametersResponse) +{ struct __net__GetTcpIpParameters soap_tmp___net__GetTcpIpParameters; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/GetTcpIpParameters"; + soap->encodingStyle = NULL; + soap_tmp___net__GetTcpIpParameters.net__GetTcpIpParameters = net__GetTcpIpParameters; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__GetTcpIpParameters(soap, &soap_tmp___net__GetTcpIpParameters); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetTcpIpParameters(soap, &soap_tmp___net__GetTcpIpParameters, "-net:GetTcpIpParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetTcpIpParameters(soap, &soap_tmp___net__GetTcpIpParameters, "-net:GetTcpIpParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__GetTcpIpParametersResponse) + return soap_closesock(soap); + net__GetTcpIpParametersResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__GetTcpIpParametersResponse->soap_get(soap, "net:GetTcpIpParametersResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetVlanParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetVlanParameters *net__SetVlanParameters, _net__SetVlanParametersResponse *net__SetVlanParametersResponse) +{ struct __net__SetVlanParameters soap_tmp___net__SetVlanParameters; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/SetVlanParameters"; + soap->encodingStyle = NULL; + soap_tmp___net__SetVlanParameters.net__SetVlanParameters = net__SetVlanParameters; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__SetVlanParameters(soap, &soap_tmp___net__SetVlanParameters); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetVlanParameters(soap, &soap_tmp___net__SetVlanParameters, "-net:SetVlanParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetVlanParameters(soap, &soap_tmp___net__SetVlanParameters, "-net:SetVlanParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__SetVlanParametersResponse) + return soap_closesock(soap); + net__SetVlanParametersResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__SetVlanParametersResponse->soap_get(soap, "net:SetVlanParametersResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetVlanParameters(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetVlanParameters *net__GetVlanParameters, _net__GetVlanParametersResponse *net__GetVlanParametersResponse) +{ struct __net__GetVlanParameters soap_tmp___net__GetVlanParameters; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/GetVlanParameters"; + soap->encodingStyle = NULL; + soap_tmp___net__GetVlanParameters.net__GetVlanParameters = net__GetVlanParameters; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__GetVlanParameters(soap, &soap_tmp___net__GetVlanParameters); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetVlanParameters(soap, &soap_tmp___net__GetVlanParameters, "-net:GetVlanParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetVlanParameters(soap, &soap_tmp___net__GetVlanParameters, "-net:GetVlanParameters", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__GetVlanParametersResponse) + return soap_closesock(soap); + net__GetVlanParametersResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__GetVlanParametersResponse->soap_get(soap, "net:GetVlanParametersResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetPingResponse(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetPingResponse *net__SetPingResponse, _net__SetPingResponseResponse *net__SetPingResponseResponse) +{ struct __net__SetPingResponse soap_tmp___net__SetPingResponse; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/SetPingResponse"; + soap->encodingStyle = NULL; + soap_tmp___net__SetPingResponse.net__SetPingResponse = net__SetPingResponse; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__SetPingResponse(soap, &soap_tmp___net__SetPingResponse); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetPingResponse(soap, &soap_tmp___net__SetPingResponse, "-net:SetPingResponse", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetPingResponse(soap, &soap_tmp___net__SetPingResponse, "-net:SetPingResponse", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__SetPingResponseResponse) + return soap_closesock(soap); + net__SetPingResponseResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__SetPingResponseResponse->soap_get(soap, "net:SetPingResponseResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetPingResponse(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetPingResponse *net__GetPingResponse, _net__GetPingResponseResponse *net__GetPingResponseResponse) +{ struct __net__GetPingResponse soap_tmp___net__GetPingResponse; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2004/01/GetPingResponse"; + soap->encodingStyle = NULL; + soap_tmp___net__GetPingResponse.net__GetPingResponse = net__GetPingResponse; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__GetPingResponse(soap, &soap_tmp___net__GetPingResponse); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetPingResponse(soap, &soap_tmp___net__GetPingResponse, "-net:GetPingResponse", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetPingResponse(soap, &soap_tmp___net__GetPingResponse, "-net:GetPingResponse", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__GetPingResponseResponse) + return soap_closesock(soap); + net__GetPingResponseResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__GetPingResponseResponse->soap_get(soap, "net:GetPingResponseResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__EnumerateInterfaces(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__EnumerateInterfaces *net__EnumerateInterfaces, _net__EnumerateInterfacesResponse *net__EnumerateInterfacesResponse) +{ struct __net__EnumerateInterfaces soap_tmp___net__EnumerateInterfaces; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2006/01/EnumerateInterfaces"; + soap->encodingStyle = NULL; + soap_tmp___net__EnumerateInterfaces.net__EnumerateInterfaces = net__EnumerateInterfaces; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__EnumerateInterfaces(soap, &soap_tmp___net__EnumerateInterfaces); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__EnumerateInterfaces(soap, &soap_tmp___net__EnumerateInterfaces, "-net:EnumerateInterfaces", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__EnumerateInterfaces(soap, &soap_tmp___net__EnumerateInterfaces, "-net:EnumerateInterfaces", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__EnumerateInterfacesResponse) + return soap_closesock(soap); + net__EnumerateInterfacesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__EnumerateInterfacesResponse->soap_get(soap, "net:EnumerateInterfacesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__GetInterfaceSettings(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__GetInterfaceSettings *net__GetInterfaceSettings, _net__GetInterfaceSettingsResponse *net__GetInterfaceSettingsResponse) +{ struct __net__GetInterfaceSettings soap_tmp___net__GetInterfaceSettings; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2006/01/GetInterfaceSettings"; + soap->encodingStyle = NULL; + soap_tmp___net__GetInterfaceSettings.net__GetInterfaceSettings = net__GetInterfaceSettings; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__GetInterfaceSettings(soap, &soap_tmp___net__GetInterfaceSettings); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetInterfaceSettings(soap, &soap_tmp___net__GetInterfaceSettings, "-net:GetInterfaceSettings", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__GetInterfaceSettings(soap, &soap_tmp___net__GetInterfaceSettings, "-net:GetInterfaceSettings", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__GetInterfaceSettingsResponse) + return soap_closesock(soap); + net__GetInterfaceSettingsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__GetInterfaceSettingsResponse->soap_get(soap, "net:GetInterfaceSettingsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__SetInterfaceSettings(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__SetInterfaceSettings *net__SetInterfaceSettings, _net__SetInterfaceSettingsResponse *net__SetInterfaceSettingsResponse) +{ struct __net__SetInterfaceSettings soap_tmp___net__SetInterfaceSettings; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2006/01/SetInterfaceSettings"; + soap->encodingStyle = NULL; + soap_tmp___net__SetInterfaceSettings.net__SetInterfaceSettings = net__SetInterfaceSettings; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__SetInterfaceSettings(soap, &soap_tmp___net__SetInterfaceSettings); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetInterfaceSettings(soap, &soap_tmp___net__SetInterfaceSettings, "-net:SetInterfaceSettings", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__SetInterfaceSettings(soap, &soap_tmp___net__SetInterfaceSettings, "-net:SetInterfaceSettings", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__SetInterfaceSettingsResponse) + return soap_closesock(soap); + net__SetInterfaceSettingsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__SetInterfaceSettingsResponse->soap_get(soap, "net:SetInterfaceSettingsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Set8021XWiredProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Set8021XWiredProfile *net__Set8021XWiredProfile, _net__Set8021XWiredProfileResponse *net__Set8021XWiredProfileResponse) +{ struct __net__Set8021XWiredProfile soap_tmp___net__Set8021XWiredProfile; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2006/01/Set8021XWiredProfile"; + soap->encodingStyle = NULL; + soap_tmp___net__Set8021XWiredProfile.net__Set8021XWiredProfile = net__Set8021XWiredProfile; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__Set8021XWiredProfile(soap, &soap_tmp___net__Set8021XWiredProfile); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Set8021XWiredProfile(soap, &soap_tmp___net__Set8021XWiredProfile, "-net:Set8021XWiredProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Set8021XWiredProfile(soap, &soap_tmp___net__Set8021XWiredProfile, "-net:Set8021XWiredProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__Set8021XWiredProfileResponse) + return soap_closesock(soap); + net__Set8021XWiredProfileResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__Set8021XWiredProfileResponse->soap_get(soap, "net:Set8021XWiredProfileResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Get8021XWiredProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Get8021XWiredProfile *net__Get8021XWiredProfile, _net__Get8021XWiredProfileResponse *net__Get8021XWiredProfileResponse) +{ struct __net__Get8021XWiredProfile soap_tmp___net__Get8021XWiredProfile; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2006/01/Get8021XWiredProfile"; + soap->encodingStyle = NULL; + soap_tmp___net__Get8021XWiredProfile.net__Get8021XWiredProfile = net__Get8021XWiredProfile; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__Get8021XWiredProfile(soap, &soap_tmp___net__Get8021XWiredProfile); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Get8021XWiredProfile(soap, &soap_tmp___net__Get8021XWiredProfile, "-net:Get8021XWiredProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Get8021XWiredProfile(soap, &soap_tmp___net__Get8021XWiredProfile, "-net:Get8021XWiredProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__Get8021XWiredProfileResponse) + return soap_closesock(soap); + net__Get8021XWiredProfileResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__Get8021XWiredProfileResponse->soap_get(soap, "net:Get8021XWiredProfileResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Set8021XActiveS0(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Set8021XActiveS0 *net__Set8021XActiveS0, _net__Set8021XActiveS0Response *net__Set8021XActiveS0Response) +{ struct __net__Set8021XActiveS0 soap_tmp___net__Set8021XActiveS0; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2006/01/Set8021XActiveS0"; + soap->encodingStyle = NULL; + soap_tmp___net__Set8021XActiveS0.net__Set8021XActiveS0 = net__Set8021XActiveS0; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__Set8021XActiveS0(soap, &soap_tmp___net__Set8021XActiveS0); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Set8021XActiveS0(soap, &soap_tmp___net__Set8021XActiveS0, "-net:Set8021XActiveS0", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Set8021XActiveS0(soap, &soap_tmp___net__Set8021XActiveS0, "-net:Set8021XActiveS0", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__Set8021XActiveS0Response) + return soap_closesock(soap); + net__Set8021XActiveS0Response->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__Set8021XActiveS0Response->soap_get(soap, "net:Set8021XActiveS0Response", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Get8021XActiveS0(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Get8021XActiveS0 *net__Get8021XActiveS0, _net__Get8021XActiveS0Response *net__Get8021XActiveS0Response) +{ struct __net__Get8021XActiveS0 soap_tmp___net__Get8021XActiveS0; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2006/01/Get8021XActiveS0"; + soap->encodingStyle = NULL; + soap_tmp___net__Get8021XActiveS0.net__Get8021XActiveS0 = net__Get8021XActiveS0; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__Get8021XActiveS0(soap, &soap_tmp___net__Get8021XActiveS0); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Get8021XActiveS0(soap, &soap_tmp___net__Get8021XActiveS0, "-net:Get8021XActiveS0", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Get8021XActiveS0(soap, &soap_tmp___net__Get8021XActiveS0, "-net:Get8021XActiveS0", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__Get8021XActiveS0Response) + return soap_closesock(soap); + net__Get8021XActiveS0Response->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__Get8021XActiveS0Response->soap_get(soap, "net:Get8021XActiveS0Response", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Set8021XPxeTimeout(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Set8021XPxeTimeout *net__Set8021XPxeTimeout, _net__Set8021XPxeTimeoutResponse *net__Set8021XPxeTimeoutResponse) +{ struct __net__Set8021XPxeTimeout soap_tmp___net__Set8021XPxeTimeout; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2006/01/Set8021XPxeTimeout"; + soap->encodingStyle = NULL; + soap_tmp___net__Set8021XPxeTimeout.net__Set8021XPxeTimeout = net__Set8021XPxeTimeout; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__Set8021XPxeTimeout(soap, &soap_tmp___net__Set8021XPxeTimeout); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Set8021XPxeTimeout(soap, &soap_tmp___net__Set8021XPxeTimeout, "-net:Set8021XPxeTimeout", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Set8021XPxeTimeout(soap, &soap_tmp___net__Set8021XPxeTimeout, "-net:Set8021XPxeTimeout", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__Set8021XPxeTimeoutResponse) + return soap_closesock(soap); + net__Set8021XPxeTimeoutResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__Set8021XPxeTimeoutResponse->soap_get(soap, "net:Set8021XPxeTimeoutResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___net__Get8021XPxeTimeout(struct soap *soap, const char *soap_endpoint, const char *soap_action, _net__Get8021XPxeTimeout *net__Get8021XPxeTimeout, _net__Get8021XPxeTimeoutResponse *net__Get8021XPxeTimeoutResponse) +{ struct __net__Get8021XPxeTimeout soap_tmp___net__Get8021XPxeTimeout; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkAdministration/2006/01/Get8021XPxeTimeout"; + soap->encodingStyle = NULL; + soap_tmp___net__Get8021XPxeTimeout.net__Get8021XPxeTimeout = net__Get8021XPxeTimeout; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___net__Get8021XPxeTimeout(soap, &soap_tmp___net__Get8021XPxeTimeout); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Get8021XPxeTimeout(soap, &soap_tmp___net__Get8021XPxeTimeout, "-net:Get8021XPxeTimeout", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___net__Get8021XPxeTimeout(soap, &soap_tmp___net__Get8021XPxeTimeout, "-net:Get8021XPxeTimeout", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!net__Get8021XPxeTimeoutResponse) + return soap_closesock(soap); + net__Get8021XPxeTimeoutResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + net__Get8021XPxeTimeoutResponse->soap_get(soap, "net:Get8021XPxeTimeoutResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___rci__GetRemoteControlCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _rci__GetRemoteControlCapabilities *rci__GetRemoteControlCapabilities, _rci__GetRemoteControlCapabilitiesResponse *rci__GetRemoteControlCapabilitiesResponse) +{ struct __rci__GetRemoteControlCapabilities soap_tmp___rci__GetRemoteControlCapabilities; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/RemoteControlService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/RemoteControl/2004/01/GetRemoteControlCapabilities"; + soap->encodingStyle = NULL; + soap_tmp___rci__GetRemoteControlCapabilities.rci__GetRemoteControlCapabilities = rci__GetRemoteControlCapabilities; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___rci__GetRemoteControlCapabilities(soap, &soap_tmp___rci__GetRemoteControlCapabilities); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___rci__GetRemoteControlCapabilities(soap, &soap_tmp___rci__GetRemoteControlCapabilities, "-rci:GetRemoteControlCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___rci__GetRemoteControlCapabilities(soap, &soap_tmp___rci__GetRemoteControlCapabilities, "-rci:GetRemoteControlCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!rci__GetRemoteControlCapabilitiesResponse) + return soap_closesock(soap); + rci__GetRemoteControlCapabilitiesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + rci__GetRemoteControlCapabilitiesResponse->soap_get(soap, "rci:GetRemoteControlCapabilitiesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___rci__RemoteControl(struct soap *soap, const char *soap_endpoint, const char *soap_action, _rci__RemoteControl *rci__RemoteControl, _rci__RemoteControlResponse *rci__RemoteControlResponse) +{ struct __rci__RemoteControl soap_tmp___rci__RemoteControl; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/RemoteControlService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/RemoteControl/2004/01/RemoteControl"; + soap->encodingStyle = NULL; + soap_tmp___rci__RemoteControl.rci__RemoteControl = rci__RemoteControl; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___rci__RemoteControl(soap, &soap_tmp___rci__RemoteControl); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___rci__RemoteControl(soap, &soap_tmp___rci__RemoteControl, "-rci:RemoteControl", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___rci__RemoteControl(soap, &soap_tmp___rci__RemoteControl, "-rci:RemoteControl", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!rci__RemoteControlResponse) + return soap_closesock(soap); + rci__RemoteControlResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + rci__RemoteControlResponse->soap_get(soap, "rci:RemoteControlResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___rci__GetSystemPowerState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _rci__GetSystemPowerState *rci__GetSystemPowerState, _rci__GetSystemPowerStateResponse *rci__GetSystemPowerStateResponse) +{ struct __rci__GetSystemPowerState soap_tmp___rci__GetSystemPowerState; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/RemoteControlService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/RemoteControl/2004/01/GetSystemPowerState"; + soap->encodingStyle = NULL; + soap_tmp___rci__GetSystemPowerState.rci__GetSystemPowerState = rci__GetSystemPowerState; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___rci__GetSystemPowerState(soap, &soap_tmp___rci__GetSystemPowerState); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___rci__GetSystemPowerState(soap, &soap_tmp___rci__GetSystemPowerState, "-rci:GetSystemPowerState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___rci__GetSystemPowerState(soap, &soap_tmp___rci__GetSystemPowerState, "-rci:GetSystemPowerState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!rci__GetSystemPowerStateResponse) + return soap_closesock(soap); + rci__GetSystemPowerStateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + rci__GetSystemPowerStateResponse->soap_get(soap, "rci:GetSystemPowerStateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__ResetFlashWearOutProtection(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__ResetFlashWearOutProtection *sai__ResetFlashWearOutProtection, _sai__ResetFlashWearOutProtectionResponse *sai__ResetFlashWearOutProtectionResponse) +{ struct __sai__ResetFlashWearOutProtection soap_tmp___sai__ResetFlashWearOutProtection; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/ResetFlashWearOutProtection"; + soap->encodingStyle = NULL; + soap_tmp___sai__ResetFlashWearOutProtection.sai__ResetFlashWearOutProtection = sai__ResetFlashWearOutProtection; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__ResetFlashWearOutProtection(soap, &soap_tmp___sai__ResetFlashWearOutProtection); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__ResetFlashWearOutProtection(soap, &soap_tmp___sai__ResetFlashWearOutProtection, "-sai:ResetFlashWearOutProtection", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__ResetFlashWearOutProtection(soap, &soap_tmp___sai__ResetFlashWearOutProtection, "-sai:ResetFlashWearOutProtection", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__ResetFlashWearOutProtectionResponse) + return soap_closesock(soap); + sai__ResetFlashWearOutProtectionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__ResetFlashWearOutProtectionResponse->soap_get(soap, "sai:ResetFlashWearOutProtectionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetAdminAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetAdminAclEntry *sai__GetAdminAclEntry, _sai__GetAdminAclEntryResponse *sai__GetAdminAclEntryResponse) +{ struct __sai__GetAdminAclEntry soap_tmp___sai__GetAdminAclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetAdminAclEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetAdminAclEntry.sai__GetAdminAclEntry = sai__GetAdminAclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetAdminAclEntry(soap, &soap_tmp___sai__GetAdminAclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetAdminAclEntry(soap, &soap_tmp___sai__GetAdminAclEntry, "-sai:GetAdminAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetAdminAclEntry(soap, &soap_tmp___sai__GetAdminAclEntry, "-sai:GetAdminAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetAdminAclEntryResponse) + return soap_closesock(soap); + sai__GetAdminAclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetAdminAclEntryResponse->soap_get(soap, "sai:GetAdminAclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetAdminAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetAdminAclEntry *sai__SetAdminAclEntry, _sai__SetAdminAclEntryResponse *sai__SetAdminAclEntryResponse) +{ struct __sai__SetAdminAclEntry soap_tmp___sai__SetAdminAclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetAdminAclEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetAdminAclEntry.sai__SetAdminAclEntry = sai__SetAdminAclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetAdminAclEntry(soap, &soap_tmp___sai__SetAdminAclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetAdminAclEntry(soap, &soap_tmp___sai__SetAdminAclEntry, "-sai:SetAdminAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetAdminAclEntry(soap, &soap_tmp___sai__SetAdminAclEntry, "-sai:SetAdminAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetAdminAclEntryResponse) + return soap_closesock(soap); + sai__SetAdminAclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetAdminAclEntryResponse->soap_get(soap, "sai:SetAdminAclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__AddUserAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__AddUserAclEntry *sai__AddUserAclEntry, _sai__AddUserAclEntryResponse *sai__AddUserAclEntryResponse) +{ struct __sai__AddUserAclEntry soap_tmp___sai__AddUserAclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/AddUserAclEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__AddUserAclEntry.sai__AddUserAclEntry = sai__AddUserAclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__AddUserAclEntry(soap, &soap_tmp___sai__AddUserAclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__AddUserAclEntry(soap, &soap_tmp___sai__AddUserAclEntry, "-sai:AddUserAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__AddUserAclEntry(soap, &soap_tmp___sai__AddUserAclEntry, "-sai:AddUserAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__AddUserAclEntryResponse) + return soap_closesock(soap); + sai__AddUserAclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__AddUserAclEntryResponse->soap_get(soap, "sai:AddUserAclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnumerateUserAclEntries(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnumerateUserAclEntries *sai__EnumerateUserAclEntries, _sai__EnumerateUserAclEntriesResponse *sai__EnumerateUserAclEntriesResponse) +{ struct __sai__EnumerateUserAclEntries soap_tmp___sai__EnumerateUserAclEntries; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/EnumerateUserAclEntries"; + soap->encodingStyle = NULL; + soap_tmp___sai__EnumerateUserAclEntries.sai__EnumerateUserAclEntries = sai__EnumerateUserAclEntries; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__EnumerateUserAclEntries(soap, &soap_tmp___sai__EnumerateUserAclEntries); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnumerateUserAclEntries(soap, &soap_tmp___sai__EnumerateUserAclEntries, "-sai:EnumerateUserAclEntries", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnumerateUserAclEntries(soap, &soap_tmp___sai__EnumerateUserAclEntries, "-sai:EnumerateUserAclEntries", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__EnumerateUserAclEntriesResponse) + return soap_closesock(soap); + sai__EnumerateUserAclEntriesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__EnumerateUserAclEntriesResponse->soap_get(soap, "sai:EnumerateUserAclEntriesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetUserAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetUserAclEntry *sai__GetUserAclEntry, _sai__GetUserAclEntryResponse *sai__GetUserAclEntryResponse) +{ struct __sai__GetUserAclEntry soap_tmp___sai__GetUserAclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetUserAclEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetUserAclEntry.sai__GetUserAclEntry = sai__GetUserAclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetUserAclEntry(soap, &soap_tmp___sai__GetUserAclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetUserAclEntry(soap, &soap_tmp___sai__GetUserAclEntry, "-sai:GetUserAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetUserAclEntry(soap, &soap_tmp___sai__GetUserAclEntry, "-sai:GetUserAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetUserAclEntryResponse) + return soap_closesock(soap); + sai__GetUserAclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetUserAclEntryResponse->soap_get(soap, "sai:GetUserAclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__UpdateUserAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__UpdateUserAclEntry *sai__UpdateUserAclEntry, _sai__UpdateUserAclEntryResponse *sai__UpdateUserAclEntryResponse) +{ struct __sai__UpdateUserAclEntry soap_tmp___sai__UpdateUserAclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/UpdateUserAclEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__UpdateUserAclEntry.sai__UpdateUserAclEntry = sai__UpdateUserAclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__UpdateUserAclEntry(soap, &soap_tmp___sai__UpdateUserAclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__UpdateUserAclEntry(soap, &soap_tmp___sai__UpdateUserAclEntry, "-sai:UpdateUserAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__UpdateUserAclEntry(soap, &soap_tmp___sai__UpdateUserAclEntry, "-sai:UpdateUserAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__UpdateUserAclEntryResponse) + return soap_closesock(soap); + sai__UpdateUserAclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__UpdateUserAclEntryResponse->soap_get(soap, "sai:UpdateUserAclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__RemoveUserAclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__RemoveUserAclEntry *sai__RemoveUserAclEntry, _sai__RemoveUserAclEntryResponse *sai__RemoveUserAclEntryResponse) +{ struct __sai__RemoveUserAclEntry soap_tmp___sai__RemoveUserAclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/RemoveUserAclEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__RemoveUserAclEntry.sai__RemoveUserAclEntry = sai__RemoveUserAclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__RemoveUserAclEntry(soap, &soap_tmp___sai__RemoveUserAclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__RemoveUserAclEntry(soap, &soap_tmp___sai__RemoveUserAclEntry, "-sai:RemoveUserAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__RemoveUserAclEntry(soap, &soap_tmp___sai__RemoveUserAclEntry, "-sai:RemoveUserAclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__RemoveUserAclEntryResponse) + return soap_closesock(soap); + sai__RemoveUserAclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__RemoveUserAclEntryResponse->soap_get(soap, "sai:RemoveUserAclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTlsEnabled(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTlsEnabled *sai__SetTlsEnabled, _sai__SetTlsEnabledResponse *sai__SetTlsEnabledResponse) +{ struct __sai__SetTlsEnabled soap_tmp___sai__SetTlsEnabled; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetTlsEnabled"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetTlsEnabled.sai__SetTlsEnabled = sai__SetTlsEnabled; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetTlsEnabled(soap, &soap_tmp___sai__SetTlsEnabled); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTlsEnabled(soap, &soap_tmp___sai__SetTlsEnabled, "-sai:SetTlsEnabled", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTlsEnabled(soap, &soap_tmp___sai__SetTlsEnabled, "-sai:SetTlsEnabled", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetTlsEnabledResponse) + return soap_closesock(soap); + sai__SetTlsEnabledResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetTlsEnabledResponse->soap_get(soap, "sai:SetTlsEnabledResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetRngKey(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetRngKey *sai__SetRngKey, _sai__SetRngKeyResponse *sai__SetRngKeyResponse) +{ struct __sai__SetRngKey soap_tmp___sai__SetRngKey; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetRngKey"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetRngKey.sai__SetRngKey = sai__SetRngKey; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetRngKey(soap, &soap_tmp___sai__SetRngKey); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetRngKey(soap, &soap_tmp___sai__SetRngKey, "-sai:SetRngKey", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetRngKey(soap, &soap_tmp___sai__SetRngKey, "-sai:SetRngKey", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetRngKeyResponse) + return soap_closesock(soap); + sai__SetRngKeyResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetRngKeyResponse->soap_get(soap, "sai:SetRngKeyResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTLSKeyAndCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTLSKeyAndCertificate *sai__SetTLSKeyAndCertificate, _sai__SetTLSKeyAndCertificateResponse *sai__SetTLSKeyAndCertificateResponse) +{ struct __sai__SetTLSKeyAndCertificate soap_tmp___sai__SetTLSKeyAndCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetTLSKeyAndCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetTLSKeyAndCertificate.sai__SetTLSKeyAndCertificate = sai__SetTLSKeyAndCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetTLSKeyAndCertificate(soap, &soap_tmp___sai__SetTLSKeyAndCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTLSKeyAndCertificate(soap, &soap_tmp___sai__SetTLSKeyAndCertificate, "-sai:SetTLSKeyAndCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTLSKeyAndCertificate(soap, &soap_tmp___sai__SetTLSKeyAndCertificate, "-sai:SetTLSKeyAndCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetTLSKeyAndCertificateResponse) + return soap_closesock(soap); + sai__SetTLSKeyAndCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetTLSKeyAndCertificateResponse->soap_get(soap, "sai:SetTLSKeyAndCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTLSCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTLSCertificate *sai__SetTLSCertificate, _sai__SetTLSCertificateResponse *sai__SetTLSCertificateResponse) +{ struct __sai__SetTLSCertificate soap_tmp___sai__SetTLSCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetTLSCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetTLSCertificate.sai__SetTLSCertificate = sai__SetTLSCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetTLSCertificate(soap, &soap_tmp___sai__SetTLSCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTLSCertificate(soap, &soap_tmp___sai__SetTLSCertificate, "-sai:SetTLSCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTLSCertificate(soap, &soap_tmp___sai__SetTLSCertificate, "-sai:SetTLSCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetTLSCertificateResponse) + return soap_closesock(soap); + sai__SetTLSCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetTLSCertificateResponse->soap_get(soap, "sai:SetTLSCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTLSCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTLSCertificate *sai__GetTLSCertificate, _sai__GetTLSCertificateResponse *sai__GetTLSCertificateResponse) +{ struct __sai__GetTLSCertificate soap_tmp___sai__GetTLSCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetTLSCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetTLSCertificate.sai__GetTLSCertificate = sai__GetTLSCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetTLSCertificate(soap, &soap_tmp___sai__GetTLSCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTLSCertificate(soap, &soap_tmp___sai__GetTLSCertificate, "-sai:GetTLSCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTLSCertificate(soap, &soap_tmp___sai__GetTLSCertificate, "-sai:GetTLSCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetTLSCertificateResponse) + return soap_closesock(soap); + sai__GetTLSCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetTLSCertificateResponse->soap_get(soap, "sai:GetTLSCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__UpdateCoreFromUrl(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__UpdateCoreFromUrl *sai__UpdateCoreFromUrl, _sai__UpdateCoreFromUrlResponse *sai__UpdateCoreFromUrlResponse) +{ struct __sai__UpdateCoreFromUrl soap_tmp___sai__UpdateCoreFromUrl; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/UpdateCoreFromUrl"; + soap->encodingStyle = NULL; + soap_tmp___sai__UpdateCoreFromUrl.sai__UpdateCoreFromUrl = sai__UpdateCoreFromUrl; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__UpdateCoreFromUrl(soap, &soap_tmp___sai__UpdateCoreFromUrl); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__UpdateCoreFromUrl(soap, &soap_tmp___sai__UpdateCoreFromUrl, "-sai:UpdateCoreFromUrl", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__UpdateCoreFromUrl(soap, &soap_tmp___sai__UpdateCoreFromUrl, "-sai:UpdateCoreFromUrl", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__UpdateCoreFromUrlResponse) + return soap_closesock(soap); + sai__UpdateCoreFromUrlResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__UpdateCoreFromUrlResponse->soap_get(soap, "sai:UpdateCoreFromUrlResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetProvisioningMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetProvisioningMode *sai__GetProvisioningMode, _sai__GetProvisioningModeResponse *sai__GetProvisioningModeResponse) +{ struct __sai__GetProvisioningMode soap_tmp___sai__GetProvisioningMode; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetProvisioningMode"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetProvisioningMode.sai__GetProvisioningMode = sai__GetProvisioningMode; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetProvisioningMode(soap, &soap_tmp___sai__GetProvisioningMode); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetProvisioningMode(soap, &soap_tmp___sai__GetProvisioningMode, "-sai:GetProvisioningMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetProvisioningMode(soap, &soap_tmp___sai__GetProvisioningMode, "-sai:GetProvisioningMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetProvisioningModeResponse) + return soap_closesock(soap); + sai__GetProvisioningModeResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetProvisioningModeResponse->soap_get(soap, "sai:GetProvisioningModeResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetProvisioningMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetProvisioningMode *sai__SetProvisioningMode, _sai__SetProvisioningModeResponse *sai__SetProvisioningModeResponse) +{ struct __sai__SetProvisioningMode soap_tmp___sai__SetProvisioningMode; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetProvisioningMode"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetProvisioningMode.sai__SetProvisioningMode = sai__SetProvisioningMode; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetProvisioningMode(soap, &soap_tmp___sai__SetProvisioningMode); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetProvisioningMode(soap, &soap_tmp___sai__SetProvisioningMode, "-sai:SetProvisioningMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetProvisioningMode(soap, &soap_tmp___sai__SetProvisioningMode, "-sai:SetProvisioningMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetProvisioningModeResponse) + return soap_closesock(soap); + sai__SetProvisioningModeResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetProvisioningModeResponse->soap_get(soap, "sai:SetProvisioningModeResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__Unprovision(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__Unprovision *sai__Unprovision, _sai__UnprovisionResponse *sai__UnprovisionResponse) +{ struct __sai__Unprovision soap_tmp___sai__Unprovision; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/Unprovision"; + soap->encodingStyle = NULL; + soap_tmp___sai__Unprovision.sai__Unprovision = sai__Unprovision; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__Unprovision(soap, &soap_tmp___sai__Unprovision); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__Unprovision(soap, &soap_tmp___sai__Unprovision, "-sai:Unprovision", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__Unprovision(soap, &soap_tmp___sai__Unprovision, "-sai:Unprovision", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__UnprovisionResponse) + return soap_closesock(soap); + sai__UnprovisionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__UnprovisionResponse->soap_get(soap, "sai:UnprovisionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CommitChanges(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CommitChanges *sai__CommitChanges, _sai__CommitChangesResponse *sai__CommitChangesResponse) +{ struct __sai__CommitChanges soap_tmp___sai__CommitChanges; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/CommitChanges"; + soap->encodingStyle = NULL; + soap_tmp___sai__CommitChanges.sai__CommitChanges = sai__CommitChanges; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CommitChanges(soap, &soap_tmp___sai__CommitChanges); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CommitChanges(soap, &soap_tmp___sai__CommitChanges, "-sai:CommitChanges", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CommitChanges(soap, &soap_tmp___sai__CommitChanges, "-sai:CommitChanges", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CommitChangesResponse) + return soap_closesock(soap); + sai__CommitChangesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CommitChangesResponse->soap_get(soap, "sai:CommitChangesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetCoreVersion(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetCoreVersion *sai__GetCoreVersion, _sai__GetCoreVersionResponse *sai__GetCoreVersionResponse) +{ struct __sai__GetCoreVersion soap_tmp___sai__GetCoreVersion; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetCoreVersion"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetCoreVersion.sai__GetCoreVersion = sai__GetCoreVersion; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetCoreVersion(soap, &soap_tmp___sai__GetCoreVersion); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetCoreVersion(soap, &soap_tmp___sai__GetCoreVersion, "-sai:GetCoreVersion", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetCoreVersion(soap, &soap_tmp___sai__GetCoreVersion, "-sai:GetCoreVersion", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetCoreVersionResponse) + return soap_closesock(soap); + sai__GetCoreVersionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetCoreVersionResponse->soap_get(soap, "sai:GetCoreVersionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__AddUserAclEntryEx(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__AddUserAclEntryEx *sai__AddUserAclEntryEx, _sai__AddUserAclEntryExResponse *sai__AddUserAclEntryExResponse) +{ struct __sai__AddUserAclEntryEx soap_tmp___sai__AddUserAclEntryEx; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/AddUserAclEntryEx"; + soap->encodingStyle = NULL; + soap_tmp___sai__AddUserAclEntryEx.sai__AddUserAclEntryEx = sai__AddUserAclEntryEx; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__AddUserAclEntryEx(soap, &soap_tmp___sai__AddUserAclEntryEx); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__AddUserAclEntryEx(soap, &soap_tmp___sai__AddUserAclEntryEx, "-sai:AddUserAclEntryEx", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__AddUserAclEntryEx(soap, &soap_tmp___sai__AddUserAclEntryEx, "-sai:AddUserAclEntryEx", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__AddUserAclEntryExResponse) + return soap_closesock(soap); + sai__AddUserAclEntryExResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__AddUserAclEntryExResponse->soap_get(soap, "sai:AddUserAclEntryExResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetUserAclEntryEx(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetUserAclEntryEx *sai__GetUserAclEntryEx, _sai__GetUserAclEntryExResponse *sai__GetUserAclEntryExResponse) +{ struct __sai__GetUserAclEntryEx soap_tmp___sai__GetUserAclEntryEx; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetUserAclEntryEx"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetUserAclEntryEx.sai__GetUserAclEntryEx = sai__GetUserAclEntryEx; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetUserAclEntryEx(soap, &soap_tmp___sai__GetUserAclEntryEx); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetUserAclEntryEx(soap, &soap_tmp___sai__GetUserAclEntryEx, "-sai:GetUserAclEntryEx", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetUserAclEntryEx(soap, &soap_tmp___sai__GetUserAclEntryEx, "-sai:GetUserAclEntryEx", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetUserAclEntryExResponse) + return soap_closesock(soap); + sai__GetUserAclEntryExResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetUserAclEntryExResponse->soap_get(soap, "sai:GetUserAclEntryExResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__UpdateUserAclEntryEx(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__UpdateUserAclEntryEx *sai__UpdateUserAclEntryEx, _sai__UpdateUserAclEntryExResponse *sai__UpdateUserAclEntryExResponse) +{ struct __sai__UpdateUserAclEntryEx soap_tmp___sai__UpdateUserAclEntryEx; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/UpdateUserAclEntryEx"; + soap->encodingStyle = NULL; + soap_tmp___sai__UpdateUserAclEntryEx.sai__UpdateUserAclEntryEx = sai__UpdateUserAclEntryEx; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__UpdateUserAclEntryEx(soap, &soap_tmp___sai__UpdateUserAclEntryEx); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__UpdateUserAclEntryEx(soap, &soap_tmp___sai__UpdateUserAclEntryEx, "-sai:UpdateUserAclEntryEx", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__UpdateUserAclEntryEx(soap, &soap_tmp___sai__UpdateUserAclEntryEx, "-sai:UpdateUserAclEntryEx", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__UpdateUserAclEntryExResponse) + return soap_closesock(soap); + sai__UpdateUserAclEntryExResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__UpdateUserAclEntryExResponse->soap_get(soap, "sai:UpdateUserAclEntryExResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetAdminAclEntryEx(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetAdminAclEntryEx *sai__SetAdminAclEntryEx, _sai__SetAdminAclEntryExResponse *sai__SetAdminAclEntryExResponse) +{ struct __sai__SetAdminAclEntryEx soap_tmp___sai__SetAdminAclEntryEx; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetAdminAclEntryEx"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetAdminAclEntryEx.sai__SetAdminAclEntryEx = sai__SetAdminAclEntryEx; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetAdminAclEntryEx(soap, &soap_tmp___sai__SetAdminAclEntryEx); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetAdminAclEntryEx(soap, &soap_tmp___sai__SetAdminAclEntryEx, "-sai:SetAdminAclEntryEx", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetAdminAclEntryEx(soap, &soap_tmp___sai__SetAdminAclEntryEx, "-sai:SetAdminAclEntryEx", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetAdminAclEntryExResponse) + return soap_closesock(soap); + sai__SetAdminAclEntryExResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetAdminAclEntryExResponse->soap_get(soap, "sai:SetAdminAclEntryExResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetDigestRealm(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetDigestRealm *sai__GetDigestRealm, _sai__GetDigestRealmResponse *sai__GetDigestRealmResponse) +{ struct __sai__GetDigestRealm soap_tmp___sai__GetDigestRealm; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetDigestRealm"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetDigestRealm.sai__GetDigestRealm = sai__GetDigestRealm; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetDigestRealm(soap, &soap_tmp___sai__GetDigestRealm); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetDigestRealm(soap, &soap_tmp___sai__GetDigestRealm, "-sai:GetDigestRealm", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetDigestRealm(soap, &soap_tmp___sai__GetDigestRealm, "-sai:GetDigestRealm", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetDigestRealmResponse) + return soap_closesock(soap); + sai__GetDigestRealmResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetDigestRealmResponse->soap_get(soap, "sai:GetDigestRealmResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetKerberosOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetKerberosOptions *sai__SetKerberosOptions, _sai__SetKerberosOptionsResponse *sai__SetKerberosOptionsResponse) +{ struct __sai__SetKerberosOptions soap_tmp___sai__SetKerberosOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetKerberosOptions"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetKerberosOptions.sai__SetKerberosOptions = sai__SetKerberosOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetKerberosOptions(soap, &soap_tmp___sai__SetKerberosOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetKerberosOptions(soap, &soap_tmp___sai__SetKerberosOptions, "-sai:SetKerberosOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetKerberosOptions(soap, &soap_tmp___sai__SetKerberosOptions, "-sai:SetKerberosOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetKerberosOptionsResponse) + return soap_closesock(soap); + sai__SetKerberosOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetKerberosOptionsResponse->soap_get(soap, "sai:SetKerberosOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetKerberosOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetKerberosOptions *sai__GetKerberosOptions, _sai__GetKerberosOptionsResponse *sai__GetKerberosOptionsResponse) +{ struct __sai__GetKerberosOptions soap_tmp___sai__GetKerberosOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetKerberosOptions"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetKerberosOptions.sai__GetKerberosOptions = sai__GetKerberosOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetKerberosOptions(soap, &soap_tmp___sai__GetKerberosOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetKerberosOptions(soap, &soap_tmp___sai__GetKerberosOptions, "-sai:GetKerberosOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetKerberosOptions(soap, &soap_tmp___sai__GetKerberosOptions, "-sai:GetKerberosOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetKerberosOptionsResponse) + return soap_closesock(soap); + sai__GetKerberosOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetKerberosOptionsResponse->soap_get(soap, "sai:GetKerberosOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetEnabledInterfaces(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetEnabledInterfaces *sai__SetEnabledInterfaces, _sai__SetEnabledInterfacesResponse *sai__SetEnabledInterfacesResponse) +{ struct __sai__SetEnabledInterfaces soap_tmp___sai__SetEnabledInterfaces; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetEnabledInterfaces"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetEnabledInterfaces.sai__SetEnabledInterfaces = sai__SetEnabledInterfaces; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetEnabledInterfaces(soap, &soap_tmp___sai__SetEnabledInterfaces); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetEnabledInterfaces(soap, &soap_tmp___sai__SetEnabledInterfaces, "-sai:SetEnabledInterfaces", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetEnabledInterfaces(soap, &soap_tmp___sai__SetEnabledInterfaces, "-sai:SetEnabledInterfaces", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetEnabledInterfacesResponse) + return soap_closesock(soap); + sai__SetEnabledInterfacesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetEnabledInterfacesResponse->soap_get(soap, "sai:SetEnabledInterfacesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetEnabledInterfaces(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetEnabledInterfaces *sai__GetEnabledInterfaces, _sai__GetEnabledInterfacesResponse *sai__GetEnabledInterfacesResponse) +{ struct __sai__GetEnabledInterfaces soap_tmp___sai__GetEnabledInterfaces; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetEnabledInterfaces"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetEnabledInterfaces.sai__GetEnabledInterfaces = sai__GetEnabledInterfaces; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetEnabledInterfaces(soap, &soap_tmp___sai__GetEnabledInterfaces); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetEnabledInterfaces(soap, &soap_tmp___sai__GetEnabledInterfaces, "-sai:GetEnabledInterfaces", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetEnabledInterfaces(soap, &soap_tmp___sai__GetEnabledInterfaces, "-sai:GetEnabledInterfaces", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetEnabledInterfacesResponse) + return soap_closesock(soap); + sai__GetEnabledInterfacesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetEnabledInterfacesResponse->soap_get(soap, "sai:GetEnabledInterfacesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTlsOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTlsOptions *sai__SetTlsOptions, _sai__SetTlsOptionsResponse *sai__SetTlsOptionsResponse) +{ struct __sai__SetTlsOptions soap_tmp___sai__SetTlsOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetTlsOptions"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetTlsOptions.sai__SetTlsOptions = sai__SetTlsOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetTlsOptions(soap, &soap_tmp___sai__SetTlsOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTlsOptions(soap, &soap_tmp___sai__SetTlsOptions, "-sai:SetTlsOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTlsOptions(soap, &soap_tmp___sai__SetTlsOptions, "-sai:SetTlsOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetTlsOptionsResponse) + return soap_closesock(soap); + sai__SetTlsOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetTlsOptionsResponse->soap_get(soap, "sai:SetTlsOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTlsOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTlsOptions *sai__GetTlsOptions, _sai__GetTlsOptionsResponse *sai__GetTlsOptionsResponse) +{ struct __sai__GetTlsOptions soap_tmp___sai__GetTlsOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetTlsOptions"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetTlsOptions.sai__GetTlsOptions = sai__GetTlsOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetTlsOptions(soap, &soap_tmp___sai__GetTlsOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTlsOptions(soap, &soap_tmp___sai__GetTlsOptions, "-sai:GetTlsOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTlsOptions(soap, &soap_tmp___sai__GetTlsOptions, "-sai:GetTlsOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetTlsOptionsResponse) + return soap_closesock(soap); + sai__GetTlsOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetTlsOptionsResponse->soap_get(soap, "sai:GetTlsOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__AddTrustedRootCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__AddTrustedRootCertificate *sai__AddTrustedRootCertificate, _sai__AddTrustedRootCertificateResponse *sai__AddTrustedRootCertificateResponse) +{ struct __sai__AddTrustedRootCertificate soap_tmp___sai__AddTrustedRootCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/AddTrustedRootCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__AddTrustedRootCertificate.sai__AddTrustedRootCertificate = sai__AddTrustedRootCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__AddTrustedRootCertificate(soap, &soap_tmp___sai__AddTrustedRootCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__AddTrustedRootCertificate(soap, &soap_tmp___sai__AddTrustedRootCertificate, "-sai:AddTrustedRootCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__AddTrustedRootCertificate(soap, &soap_tmp___sai__AddTrustedRootCertificate, "-sai:AddTrustedRootCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__AddTrustedRootCertificateResponse) + return soap_closesock(soap); + sai__AddTrustedRootCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__AddTrustedRootCertificateResponse->soap_get(soap, "sai:AddTrustedRootCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTrustedRootCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTrustedRootCertificate *sai__GetTrustedRootCertificate, _sai__GetTrustedRootCertificateResponse *sai__GetTrustedRootCertificateResponse) +{ struct __sai__GetTrustedRootCertificate soap_tmp___sai__GetTrustedRootCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetTrustedRootCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetTrustedRootCertificate.sai__GetTrustedRootCertificate = sai__GetTrustedRootCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetTrustedRootCertificate(soap, &soap_tmp___sai__GetTrustedRootCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTrustedRootCertificate(soap, &soap_tmp___sai__GetTrustedRootCertificate, "-sai:GetTrustedRootCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTrustedRootCertificate(soap, &soap_tmp___sai__GetTrustedRootCertificate, "-sai:GetTrustedRootCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetTrustedRootCertificateResponse) + return soap_closesock(soap); + sai__GetTrustedRootCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetTrustedRootCertificateResponse->soap_get(soap, "sai:GetTrustedRootCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__DeleteTrustedRootCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__DeleteTrustedRootCertificate *sai__DeleteTrustedRootCertificate, _sai__DeleteTrustedRootCertificateResponse *sai__DeleteTrustedRootCertificateResponse) +{ struct __sai__DeleteTrustedRootCertificate soap_tmp___sai__DeleteTrustedRootCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/DeleteTrustedRootCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__DeleteTrustedRootCertificate.sai__DeleteTrustedRootCertificate = sai__DeleteTrustedRootCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__DeleteTrustedRootCertificate(soap, &soap_tmp___sai__DeleteTrustedRootCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__DeleteTrustedRootCertificate(soap, &soap_tmp___sai__DeleteTrustedRootCertificate, "-sai:DeleteTrustedRootCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__DeleteTrustedRootCertificate(soap, &soap_tmp___sai__DeleteTrustedRootCertificate, "-sai:DeleteTrustedRootCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__DeleteTrustedRootCertificateResponse) + return soap_closesock(soap); + sai__DeleteTrustedRootCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__DeleteTrustedRootCertificateResponse->soap_get(soap, "sai:DeleteTrustedRootCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnumerateTrustedRootCertificates(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnumerateTrustedRootCertificates *sai__EnumerateTrustedRootCertificates, _sai__EnumerateTrustedRootCertificatesResponse *sai__EnumerateTrustedRootCertificatesResponse) +{ struct __sai__EnumerateTrustedRootCertificates soap_tmp___sai__EnumerateTrustedRootCertificates; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/EnumerateTrustedRootCertificates"; + soap->encodingStyle = NULL; + soap_tmp___sai__EnumerateTrustedRootCertificates.sai__EnumerateTrustedRootCertificates = sai__EnumerateTrustedRootCertificates; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__EnumerateTrustedRootCertificates(soap, &soap_tmp___sai__EnumerateTrustedRootCertificates); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnumerateTrustedRootCertificates(soap, &soap_tmp___sai__EnumerateTrustedRootCertificates, "-sai:EnumerateTrustedRootCertificates", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnumerateTrustedRootCertificates(soap, &soap_tmp___sai__EnumerateTrustedRootCertificates, "-sai:EnumerateTrustedRootCertificates", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__EnumerateTrustedRootCertificatesResponse) + return soap_closesock(soap); + sai__EnumerateTrustedRootCertificatesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__EnumerateTrustedRootCertificatesResponse->soap_get(soap, "sai:EnumerateTrustedRootCertificatesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTrustedFqdnCN(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTrustedFqdnCN *sai__SetTrustedFqdnCN, _sai__SetTrustedFqdnCNResponse *sai__SetTrustedFqdnCNResponse) +{ struct __sai__SetTrustedFqdnCN soap_tmp___sai__SetTrustedFqdnCN; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetTrustedFqdnCN"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetTrustedFqdnCN.sai__SetTrustedFqdnCN = sai__SetTrustedFqdnCN; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetTrustedFqdnCN(soap, &soap_tmp___sai__SetTrustedFqdnCN); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTrustedFqdnCN(soap, &soap_tmp___sai__SetTrustedFqdnCN, "-sai:SetTrustedFqdnCN", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTrustedFqdnCN(soap, &soap_tmp___sai__SetTrustedFqdnCN, "-sai:SetTrustedFqdnCN", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetTrustedFqdnCNResponse) + return soap_closesock(soap); + sai__SetTrustedFqdnCNResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetTrustedFqdnCNResponse->soap_get(soap, "sai:SetTrustedFqdnCNResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTrustedFqdnCN(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTrustedFqdnCN *sai__GetTrustedFqdnCN, _sai__GetTrustedFqdnCNResponse *sai__GetTrustedFqdnCNResponse) +{ struct __sai__GetTrustedFqdnCN soap_tmp___sai__GetTrustedFqdnCN; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetTrustedFqdnCN"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetTrustedFqdnCN.sai__GetTrustedFqdnCN = sai__GetTrustedFqdnCN; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetTrustedFqdnCN(soap, &soap_tmp___sai__GetTrustedFqdnCN); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTrustedFqdnCN(soap, &soap_tmp___sai__GetTrustedFqdnCN, "-sai:GetTrustedFqdnCN", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTrustedFqdnCN(soap, &soap_tmp___sai__GetTrustedFqdnCN, "-sai:GetTrustedFqdnCN", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetTrustedFqdnCNResponse) + return soap_closesock(soap); + sai__GetTrustedFqdnCNResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetTrustedFqdnCNResponse->soap_get(soap, "sai:GetTrustedFqdnCNResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetCRL(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetCRL *sai__SetCRL, _sai__SetCRLResponse *sai__SetCRLResponse) +{ struct __sai__SetCRL soap_tmp___sai__SetCRL; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetCRL"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetCRL.sai__SetCRL = sai__SetCRL; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetCRL(soap, &soap_tmp___sai__SetCRL); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetCRL(soap, &soap_tmp___sai__SetCRL, "-sai:SetCRL", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetCRL(soap, &soap_tmp___sai__SetCRL, "-sai:SetCRL", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetCRLResponse) + return soap_closesock(soap); + sai__SetCRLResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetCRLResponse->soap_get(soap, "sai:SetCRLResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetCRL(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetCRL *sai__GetCRL, _sai__GetCRLResponse *sai__GetCRLResponse) +{ struct __sai__GetCRL soap_tmp___sai__GetCRL; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetCRL"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetCRL.sai__GetCRL = sai__GetCRL; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetCRL(soap, &soap_tmp___sai__GetCRL); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetCRL(soap, &soap_tmp___sai__GetCRL, "-sai:GetCRL", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetCRL(soap, &soap_tmp___sai__GetCRL, "-sai:GetCRL", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetCRLResponse) + return soap_closesock(soap); + sai__GetCRLResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetCRLResponse->soap_get(soap, "sai:GetCRLResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetServerCertificateReq(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetServerCertificateReq *sai__GetServerCertificateReq, _sai__GetServerCertificateReqResponse *sai__GetServerCertificateReqResponse) +{ struct __sai__GetServerCertificateReq soap_tmp___sai__GetServerCertificateReq; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetServerCertificateReq"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetServerCertificateReq.sai__GetServerCertificateReq = sai__GetServerCertificateReq; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetServerCertificateReq(soap, &soap_tmp___sai__GetServerCertificateReq); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetServerCertificateReq(soap, &soap_tmp___sai__GetServerCertificateReq, "-sai:GetServerCertificateReq", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetServerCertificateReq(soap, &soap_tmp___sai__GetServerCertificateReq, "-sai:GetServerCertificateReq", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetServerCertificateReqResponse) + return soap_closesock(soap); + sai__GetServerCertificateReqResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetServerCertificateReqResponse->soap_get(soap, "sai:GetServerCertificateReqResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetPkiCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetPkiCapabilities *sai__GetPkiCapabilities, _sai__GetPkiCapabilitiesResponse *sai__GetPkiCapabilitiesResponse) +{ struct __sai__GetPkiCapabilities soap_tmp___sai__GetPkiCapabilities; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetPkiCapabilities"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetPkiCapabilities.sai__GetPkiCapabilities = sai__GetPkiCapabilities; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetPkiCapabilities(soap, &soap_tmp___sai__GetPkiCapabilities); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetPkiCapabilities(soap, &soap_tmp___sai__GetPkiCapabilities, "-sai:GetPkiCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetPkiCapabilities(soap, &soap_tmp___sai__GetPkiCapabilities, "-sai:GetPkiCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetPkiCapabilitiesResponse) + return soap_closesock(soap); + sai__GetPkiCapabilitiesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetPkiCapabilitiesResponse->soap_get(soap, "sai:GetPkiCapabilitiesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetPowerSavingOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetPowerSavingOptions *sai__SetPowerSavingOptions, _sai__SetPowerSavingOptionsResponse *sai__SetPowerSavingOptionsResponse) +{ struct __sai__SetPowerSavingOptions soap_tmp___sai__SetPowerSavingOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetPowerSavingOptions"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetPowerSavingOptions.sai__SetPowerSavingOptions = sai__SetPowerSavingOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetPowerSavingOptions(soap, &soap_tmp___sai__SetPowerSavingOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetPowerSavingOptions(soap, &soap_tmp___sai__SetPowerSavingOptions, "-sai:SetPowerSavingOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetPowerSavingOptions(soap, &soap_tmp___sai__SetPowerSavingOptions, "-sai:SetPowerSavingOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetPowerSavingOptionsResponse) + return soap_closesock(soap); + sai__SetPowerSavingOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetPowerSavingOptionsResponse->soap_get(soap, "sai:SetPowerSavingOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetPowerSavingOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetPowerSavingOptions *sai__GetPowerSavingOptions, _sai__GetPowerSavingOptionsResponse *sai__GetPowerSavingOptionsResponse) +{ struct __sai__GetPowerSavingOptions soap_tmp___sai__GetPowerSavingOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/GetPowerSavingOptions"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetPowerSavingOptions.sai__GetPowerSavingOptions = sai__GetPowerSavingOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetPowerSavingOptions(soap, &soap_tmp___sai__GetPowerSavingOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetPowerSavingOptions(soap, &soap_tmp___sai__GetPowerSavingOptions, "-sai:GetPowerSavingOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetPowerSavingOptions(soap, &soap_tmp___sai__GetPowerSavingOptions, "-sai:GetPowerSavingOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetPowerSavingOptionsResponse) + return soap_closesock(soap); + sai__GetPowerSavingOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetPowerSavingOptionsResponse->soap_get(soap, "sai:GetPowerSavingOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTLSPSK(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTLSPSK *sai__SetTLSPSK, _sai__SetTLSPSKResponse *sai__SetTLSPSKResponse) +{ struct __sai__SetTLSPSK soap_tmp___sai__SetTLSPSK; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/SetTLSPSK"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetTLSPSK.sai__SetTLSPSK = sai__SetTLSPSK; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetTLSPSK(soap, &soap_tmp___sai__SetTLSPSK); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTLSPSK(soap, &soap_tmp___sai__SetTLSPSK, "-sai:SetTLSPSK", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTLSPSK(soap, &soap_tmp___sai__SetTLSPSK, "-sai:SetTLSPSK", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetTLSPSKResponse) + return soap_closesock(soap); + sai__SetTLSPSKResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetTLSPSKResponse->soap_get(soap, "sai:SetTLSPSKResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__PartialUnprovision(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__PartialUnprovision *sai__PartialUnprovision, _sai__PartialUnprovisionResponse *sai__PartialUnprovisionResponse) +{ struct __sai__PartialUnprovision soap_tmp___sai__PartialUnprovision; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2004/01/PartialUnprovision"; + soap->encodingStyle = NULL; + soap_tmp___sai__PartialUnprovision.sai__PartialUnprovision = sai__PartialUnprovision; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__PartialUnprovision(soap, &soap_tmp___sai__PartialUnprovision); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__PartialUnprovision(soap, &soap_tmp___sai__PartialUnprovision, "-sai:PartialUnprovision", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__PartialUnprovision(soap, &soap_tmp___sai__PartialUnprovision, "-sai:PartialUnprovision", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__PartialUnprovisionResponse) + return soap_closesock(soap); + sai__PartialUnprovisionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__PartialUnprovisionResponse->soap_get(soap, "sai:PartialUnprovisionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetMEBxPassword(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetMEBxPassword *sai__SetMEBxPassword, _sai__SetMEBxPasswordResponse *sai__SetMEBxPasswordResponse) +{ struct __sai__SetMEBxPassword soap_tmp___sai__SetMEBxPassword; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetMEBxPassword"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetMEBxPassword.sai__SetMEBxPassword = sai__SetMEBxPassword; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetMEBxPassword(soap, &soap_tmp___sai__SetMEBxPassword); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetMEBxPassword(soap, &soap_tmp___sai__SetMEBxPassword, "-sai:SetMEBxPassword", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetMEBxPassword(soap, &soap_tmp___sai__SetMEBxPassword, "-sai:SetMEBxPassword", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetMEBxPasswordResponse) + return soap_closesock(soap); + sai__SetMEBxPasswordResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetMEBxPasswordResponse->soap_get(soap, "sai:SetMEBxPasswordResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetProvisioningServerOTP(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetProvisioningServerOTP *sai__SetProvisioningServerOTP, _sai__SetProvisioningServerOTPResponse *sai__SetProvisioningServerOTPResponse) +{ struct __sai__SetProvisioningServerOTP soap_tmp___sai__SetProvisioningServerOTP; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetProvisioningServerOTP"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetProvisioningServerOTP.sai__SetProvisioningServerOTP = sai__SetProvisioningServerOTP; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetProvisioningServerOTP(soap, &soap_tmp___sai__SetProvisioningServerOTP); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetProvisioningServerOTP(soap, &soap_tmp___sai__SetProvisioningServerOTP, "-sai:SetProvisioningServerOTP", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetProvisioningServerOTP(soap, &soap_tmp___sai__SetProvisioningServerOTP, "-sai:SetProvisioningServerOTP", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetProvisioningServerOTPResponse) + return soap_closesock(soap); + sai__SetProvisioningServerOTPResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetProvisioningServerOTPResponse->soap_get(soap, "sai:SetProvisioningServerOTPResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetProvisioningServerOTP(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetProvisioningServerOTP *sai__GetProvisioningServerOTP, _sai__GetProvisioningServerOTPResponse *sai__GetProvisioningServerOTPResponse) +{ struct __sai__GetProvisioningServerOTP soap_tmp___sai__GetProvisioningServerOTP; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetProvisioningServerOTP"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetProvisioningServerOTP.sai__GetProvisioningServerOTP = sai__GetProvisioningServerOTP; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetProvisioningServerOTP(soap, &soap_tmp___sai__GetProvisioningServerOTP); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetProvisioningServerOTP(soap, &soap_tmp___sai__GetProvisioningServerOTP, "-sai:GetProvisioningServerOTP", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetProvisioningServerOTP(soap, &soap_tmp___sai__GetProvisioningServerOTP, "-sai:GetProvisioningServerOTP", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetProvisioningServerOTPResponse) + return soap_closesock(soap); + sai__GetProvisioningServerOTPResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetProvisioningServerOTPResponse->soap_get(soap, "sai:GetProvisioningServerOTPResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnumerateCertificateHashEntries(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnumerateCertificateHashEntries *sai__EnumerateCertificateHashEntries, _sai__EnumerateCertificateHashEntriesResponse *sai__EnumerateCertificateHashEntriesResponse) +{ struct __sai__EnumerateCertificateHashEntries soap_tmp___sai__EnumerateCertificateHashEntries; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/EnumerateCertificateHashEntries"; + soap->encodingStyle = NULL; + soap_tmp___sai__EnumerateCertificateHashEntries.sai__EnumerateCertificateHashEntries = sai__EnumerateCertificateHashEntries; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__EnumerateCertificateHashEntries(soap, &soap_tmp___sai__EnumerateCertificateHashEntries); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnumerateCertificateHashEntries(soap, &soap_tmp___sai__EnumerateCertificateHashEntries, "-sai:EnumerateCertificateHashEntries", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnumerateCertificateHashEntries(soap, &soap_tmp___sai__EnumerateCertificateHashEntries, "-sai:EnumerateCertificateHashEntries", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__EnumerateCertificateHashEntriesResponse) + return soap_closesock(soap); + sai__EnumerateCertificateHashEntriesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__EnumerateCertificateHashEntriesResponse->soap_get(soap, "sai:EnumerateCertificateHashEntriesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetCertificateHashEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetCertificateHashEntry *sai__GetCertificateHashEntry, _sai__GetCertificateHashEntryResponse *sai__GetCertificateHashEntryResponse) +{ struct __sai__GetCertificateHashEntry soap_tmp___sai__GetCertificateHashEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetCertificateHashEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetCertificateHashEntry.sai__GetCertificateHashEntry = sai__GetCertificateHashEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetCertificateHashEntry(soap, &soap_tmp___sai__GetCertificateHashEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetCertificateHashEntry(soap, &soap_tmp___sai__GetCertificateHashEntry, "-sai:GetCertificateHashEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetCertificateHashEntry(soap, &soap_tmp___sai__GetCertificateHashEntry, "-sai:GetCertificateHashEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetCertificateHashEntryResponse) + return soap_closesock(soap); + sai__GetCertificateHashEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetCertificateHashEntryResponse->soap_get(soap, "sai:GetCertificateHashEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__AddCertificateHashEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__AddCertificateHashEntry *sai__AddCertificateHashEntry, _sai__AddCertificateHashEntryResponse *sai__AddCertificateHashEntryResponse) +{ struct __sai__AddCertificateHashEntry soap_tmp___sai__AddCertificateHashEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/AddCertificateHashEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__AddCertificateHashEntry.sai__AddCertificateHashEntry = sai__AddCertificateHashEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__AddCertificateHashEntry(soap, &soap_tmp___sai__AddCertificateHashEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__AddCertificateHashEntry(soap, &soap_tmp___sai__AddCertificateHashEntry, "-sai:AddCertificateHashEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__AddCertificateHashEntry(soap, &soap_tmp___sai__AddCertificateHashEntry, "-sai:AddCertificateHashEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__AddCertificateHashEntryResponse) + return soap_closesock(soap); + sai__AddCertificateHashEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__AddCertificateHashEntryResponse->soap_get(soap, "sai:AddCertificateHashEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__DeleteCertificateHashEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__DeleteCertificateHashEntry *sai__DeleteCertificateHashEntry, _sai__DeleteCertificateHashEntryResponse *sai__DeleteCertificateHashEntryResponse) +{ struct __sai__DeleteCertificateHashEntry soap_tmp___sai__DeleteCertificateHashEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/DeleteCertificateHashEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__DeleteCertificateHashEntry.sai__DeleteCertificateHashEntry = sai__DeleteCertificateHashEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__DeleteCertificateHashEntry(soap, &soap_tmp___sai__DeleteCertificateHashEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__DeleteCertificateHashEntry(soap, &soap_tmp___sai__DeleteCertificateHashEntry, "-sai:DeleteCertificateHashEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__DeleteCertificateHashEntry(soap, &soap_tmp___sai__DeleteCertificateHashEntry, "-sai:DeleteCertificateHashEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__DeleteCertificateHashEntryResponse) + return soap_closesock(soap); + sai__DeleteCertificateHashEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__DeleteCertificateHashEntryResponse->soap_get(soap, "sai:DeleteCertificateHashEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnableCertificateHashEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnableCertificateHashEntry *sai__EnableCertificateHashEntry, _sai__EnableCertificateHashEntryResponse *sai__EnableCertificateHashEntryResponse) +{ struct __sai__EnableCertificateHashEntry soap_tmp___sai__EnableCertificateHashEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/EnableCertificateHashEntry"; + soap->encodingStyle = NULL; + soap_tmp___sai__EnableCertificateHashEntry.sai__EnableCertificateHashEntry = sai__EnableCertificateHashEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__EnableCertificateHashEntry(soap, &soap_tmp___sai__EnableCertificateHashEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnableCertificateHashEntry(soap, &soap_tmp___sai__EnableCertificateHashEntry, "-sai:EnableCertificateHashEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnableCertificateHashEntry(soap, &soap_tmp___sai__EnableCertificateHashEntry, "-sai:EnableCertificateHashEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__EnableCertificateHashEntryResponse) + return soap_closesock(soap); + sai__EnableCertificateHashEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__EnableCertificateHashEntryResponse->soap_get(soap, "sai:EnableCertificateHashEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetZeroTouchConfigurationMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetZeroTouchConfigurationMode *sai__GetZeroTouchConfigurationMode, _sai__GetZeroTouchConfigurationModeResponse *sai__GetZeroTouchConfigurationModeResponse) +{ struct __sai__GetZeroTouchConfigurationMode soap_tmp___sai__GetZeroTouchConfigurationMode; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetZeroTouchConfigurationMode"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetZeroTouchConfigurationMode.sai__GetZeroTouchConfigurationMode = sai__GetZeroTouchConfigurationMode; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetZeroTouchConfigurationMode(soap, &soap_tmp___sai__GetZeroTouchConfigurationMode); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetZeroTouchConfigurationMode(soap, &soap_tmp___sai__GetZeroTouchConfigurationMode, "-sai:GetZeroTouchConfigurationMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetZeroTouchConfigurationMode(soap, &soap_tmp___sai__GetZeroTouchConfigurationMode, "-sai:GetZeroTouchConfigurationMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetZeroTouchConfigurationModeResponse) + return soap_closesock(soap); + sai__GetZeroTouchConfigurationModeResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetZeroTouchConfigurationModeResponse->soap_get(soap, "sai:GetZeroTouchConfigurationModeResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetZeroTouchConfigurationMode(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetZeroTouchConfigurationMode *sai__SetZeroTouchConfigurationMode, _sai__SetZeroTouchConfigurationModeResponse *sai__SetZeroTouchConfigurationModeResponse) +{ struct __sai__SetZeroTouchConfigurationMode soap_tmp___sai__SetZeroTouchConfigurationMode; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetZeroTouchConfigurationMode"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetZeroTouchConfigurationMode.sai__SetZeroTouchConfigurationMode = sai__SetZeroTouchConfigurationMode; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetZeroTouchConfigurationMode(soap, &soap_tmp___sai__SetZeroTouchConfigurationMode); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetZeroTouchConfigurationMode(soap, &soap_tmp___sai__SetZeroTouchConfigurationMode, "-sai:SetZeroTouchConfigurationMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetZeroTouchConfigurationMode(soap, &soap_tmp___sai__SetZeroTouchConfigurationMode, "-sai:SetZeroTouchConfigurationMode", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetZeroTouchConfigurationModeResponse) + return soap_closesock(soap); + sai__SetZeroTouchConfigurationModeResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetZeroTouchConfigurationModeResponse->soap_get(soap, "sai:SetZeroTouchConfigurationModeResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetProvisioningAuditRecord(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetProvisioningAuditRecord *sai__GetProvisioningAuditRecord, _sai__GetProvisioningAuditRecordResponse *sai__GetProvisioningAuditRecordResponse) +{ struct __sai__GetProvisioningAuditRecord soap_tmp___sai__GetProvisioningAuditRecord; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetProvisioningAuditRecord"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetProvisioningAuditRecord.sai__GetProvisioningAuditRecord = sai__GetProvisioningAuditRecord; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetProvisioningAuditRecord(soap, &soap_tmp___sai__GetProvisioningAuditRecord); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetProvisioningAuditRecord(soap, &soap_tmp___sai__GetProvisioningAuditRecord, "-sai:GetProvisioningAuditRecord", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetProvisioningAuditRecord(soap, &soap_tmp___sai__GetProvisioningAuditRecord, "-sai:GetProvisioningAuditRecord", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetProvisioningAuditRecordResponse) + return soap_closesock(soap); + sai__GetProvisioningAuditRecordResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetProvisioningAuditRecordResponse->soap_get(soap, "sai:GetProvisioningAuditRecordResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetProvisioningPID(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetProvisioningPID *sai__GetProvisioningPID, _sai__GetProvisioningPIDResponse *sai__GetProvisioningPIDResponse) +{ struct __sai__GetProvisioningPID soap_tmp___sai__GetProvisioningPID; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetProvisioningPID"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetProvisioningPID.sai__GetProvisioningPID = sai__GetProvisioningPID; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetProvisioningPID(soap, &soap_tmp___sai__GetProvisioningPID); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetProvisioningPID(soap, &soap_tmp___sai__GetProvisioningPID, "-sai:GetProvisioningPID", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetProvisioningPID(soap, &soap_tmp___sai__GetProvisioningPID, "-sai:GetProvisioningPID", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetProvisioningPIDResponse) + return soap_closesock(soap); + sai__GetProvisioningPIDResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetProvisioningPIDResponse->soap_get(soap, "sai:GetProvisioningPIDResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__ExtendProvisioningPeriod(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__ExtendProvisioningPeriod *sai__ExtendProvisioningPeriod, _sai__ExtendProvisioningPeriodResponse *sai__ExtendProvisioningPeriodResponse) +{ struct __sai__ExtendProvisioningPeriod soap_tmp___sai__ExtendProvisioningPeriod; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/ExtendProvisioningPeriod"; + soap->encodingStyle = NULL; + soap_tmp___sai__ExtendProvisioningPeriod.sai__ExtendProvisioningPeriod = sai__ExtendProvisioningPeriod; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__ExtendProvisioningPeriod(soap, &soap_tmp___sai__ExtendProvisioningPeriod); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__ExtendProvisioningPeriod(soap, &soap_tmp___sai__ExtendProvisioningPeriod, "-sai:ExtendProvisioningPeriod", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__ExtendProvisioningPeriod(soap, &soap_tmp___sai__ExtendProvisioningPeriod, "-sai:ExtendProvisioningPeriod", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__ExtendProvisioningPeriodResponse) + return soap_closesock(soap); + sai__ExtendProvisioningPeriodResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__ExtendProvisioningPeriodResponse->soap_get(soap, "sai:ExtendProvisioningPeriodResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetRealmAuthOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetRealmAuthOptions *sai__GetRealmAuthOptions, _sai__GetRealmAuthOptionsResponse *sai__GetRealmAuthOptionsResponse) +{ struct __sai__GetRealmAuthOptions soap_tmp___sai__GetRealmAuthOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetRealmAuthOptions"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetRealmAuthOptions.sai__GetRealmAuthOptions = sai__GetRealmAuthOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetRealmAuthOptions(soap, &soap_tmp___sai__GetRealmAuthOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetRealmAuthOptions(soap, &soap_tmp___sai__GetRealmAuthOptions, "-sai:GetRealmAuthOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetRealmAuthOptions(soap, &soap_tmp___sai__GetRealmAuthOptions, "-sai:GetRealmAuthOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetRealmAuthOptionsResponse) + return soap_closesock(soap); + sai__GetRealmAuthOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetRealmAuthOptionsResponse->soap_get(soap, "sai:GetRealmAuthOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetRealmAuthOptions(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetRealmAuthOptions *sai__SetRealmAuthOptions, _sai__SetRealmAuthOptionsResponse *sai__SetRealmAuthOptionsResponse) +{ struct __sai__SetRealmAuthOptions soap_tmp___sai__SetRealmAuthOptions; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetRealmAuthOptions"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetRealmAuthOptions.sai__SetRealmAuthOptions = sai__SetRealmAuthOptions; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetRealmAuthOptions(soap, &soap_tmp___sai__SetRealmAuthOptions); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetRealmAuthOptions(soap, &soap_tmp___sai__SetRealmAuthOptions, "-sai:SetRealmAuthOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetRealmAuthOptions(soap, &soap_tmp___sai__SetRealmAuthOptions, "-sai:SetRealmAuthOptions", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetRealmAuthOptionsResponse) + return soap_closesock(soap); + sai__SetRealmAuthOptionsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetRealmAuthOptionsResponse->soap_get(soap, "sai:SetRealmAuthOptionsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetEnvironmentDetection(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetEnvironmentDetection *sai__SetEnvironmentDetection, _sai__SetEnvironmentDetectionResponse *sai__SetEnvironmentDetectionResponse) +{ struct __sai__SetEnvironmentDetection soap_tmp___sai__SetEnvironmentDetection; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetEnvironmentDetection"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetEnvironmentDetection.sai__SetEnvironmentDetection = sai__SetEnvironmentDetection; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetEnvironmentDetection(soap, &soap_tmp___sai__SetEnvironmentDetection); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetEnvironmentDetection(soap, &soap_tmp___sai__SetEnvironmentDetection, "-sai:SetEnvironmentDetection", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetEnvironmentDetection(soap, &soap_tmp___sai__SetEnvironmentDetection, "-sai:SetEnvironmentDetection", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetEnvironmentDetectionResponse) + return soap_closesock(soap); + sai__SetEnvironmentDetectionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetEnvironmentDetectionResponse->soap_get(soap, "sai:SetEnvironmentDetectionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetEnvironmentDetection(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetEnvironmentDetection *sai__GetEnvironmentDetection, _sai__GetEnvironmentDetectionResponse *sai__GetEnvironmentDetectionResponse) +{ struct __sai__GetEnvironmentDetection soap_tmp___sai__GetEnvironmentDetection; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetEnvironmentDetection"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetEnvironmentDetection.sai__GetEnvironmentDetection = sai__GetEnvironmentDetection; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetEnvironmentDetection(soap, &soap_tmp___sai__GetEnvironmentDetection); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetEnvironmentDetection(soap, &soap_tmp___sai__GetEnvironmentDetection, "-sai:GetEnvironmentDetection", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetEnvironmentDetection(soap, &soap_tmp___sai__GetEnvironmentDetection, "-sai:GetEnvironmentDetection", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetEnvironmentDetectionResponse) + return soap_closesock(soap); + sai__GetEnvironmentDetectionResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetEnvironmentDetectionResponse->soap_get(soap, "sai:GetEnvironmentDetectionResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnumeratePowerPackages(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnumeratePowerPackages *sai__EnumeratePowerPackages, _sai__EnumeratePowerPackagesResponse *sai__EnumeratePowerPackagesResponse) +{ struct __sai__EnumeratePowerPackages soap_tmp___sai__EnumeratePowerPackages; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/EnumeratePowerPackages"; + soap->encodingStyle = NULL; + soap_tmp___sai__EnumeratePowerPackages.sai__EnumeratePowerPackages = sai__EnumeratePowerPackages; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__EnumeratePowerPackages(soap, &soap_tmp___sai__EnumeratePowerPackages); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnumeratePowerPackages(soap, &soap_tmp___sai__EnumeratePowerPackages, "-sai:EnumeratePowerPackages", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnumeratePowerPackages(soap, &soap_tmp___sai__EnumeratePowerPackages, "-sai:EnumeratePowerPackages", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__EnumeratePowerPackagesResponse) + return soap_closesock(soap); + sai__EnumeratePowerPackagesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__EnumeratePowerPackagesResponse->soap_get(soap, "sai:EnumeratePowerPackagesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetPowerPackage(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetPowerPackage *sai__GetPowerPackage, _sai__GetPowerPackageResponse *sai__GetPowerPackageResponse) +{ struct __sai__GetPowerPackage soap_tmp___sai__GetPowerPackage; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetPowerPackage"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetPowerPackage.sai__GetPowerPackage = sai__GetPowerPackage; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetPowerPackage(soap, &soap_tmp___sai__GetPowerPackage); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetPowerPackage(soap, &soap_tmp___sai__GetPowerPackage, "-sai:GetPowerPackage", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetPowerPackage(soap, &soap_tmp___sai__GetPowerPackage, "-sai:GetPowerPackage", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetPowerPackageResponse) + return soap_closesock(soap); + sai__GetPowerPackageResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetPowerPackageResponse->soap_get(soap, "sai:GetPowerPackageResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetActivePowerPackage(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetActivePowerPackage *sai__GetActivePowerPackage, _sai__GetActivePowerPackageResponse *sai__GetActivePowerPackageResponse) +{ struct __sai__GetActivePowerPackage soap_tmp___sai__GetActivePowerPackage; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetActivePowerPackage"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetActivePowerPackage.sai__GetActivePowerPackage = sai__GetActivePowerPackage; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetActivePowerPackage(soap, &soap_tmp___sai__GetActivePowerPackage); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetActivePowerPackage(soap, &soap_tmp___sai__GetActivePowerPackage, "-sai:GetActivePowerPackage", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetActivePowerPackage(soap, &soap_tmp___sai__GetActivePowerPackage, "-sai:GetActivePowerPackage", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetActivePowerPackageResponse) + return soap_closesock(soap); + sai__GetActivePowerPackageResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetActivePowerPackageResponse->soap_get(soap, "sai:GetActivePowerPackageResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetActivePowerPackage(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetActivePowerPackage *sai__SetActivePowerPackage, _sai__SetActivePowerPackageResponse *sai__SetActivePowerPackageResponse) +{ struct __sai__SetActivePowerPackage soap_tmp___sai__SetActivePowerPackage; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetActivePowerPackage"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetActivePowerPackage.sai__SetActivePowerPackage = sai__SetActivePowerPackage; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetActivePowerPackage(soap, &soap_tmp___sai__SetActivePowerPackage); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetActivePowerPackage(soap, &soap_tmp___sai__SetActivePowerPackage, "-sai:SetActivePowerPackage", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetActivePowerPackage(soap, &soap_tmp___sai__SetActivePowerPackage, "-sai:SetActivePowerPackage", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetActivePowerPackageResponse) + return soap_closesock(soap); + sai__SetActivePowerPackageResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetActivePowerPackageResponse->soap_get(soap, "sai:SetActivePowerPackageResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetGlobalPowerPolicy(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetGlobalPowerPolicy *sai__SetGlobalPowerPolicy, _sai__SetGlobalPowerPolicyResponse *sai__SetGlobalPowerPolicyResponse) +{ struct __sai__SetGlobalPowerPolicy soap_tmp___sai__SetGlobalPowerPolicy; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetGlobalPowerPolicy"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetGlobalPowerPolicy.sai__SetGlobalPowerPolicy = sai__SetGlobalPowerPolicy; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetGlobalPowerPolicy(soap, &soap_tmp___sai__SetGlobalPowerPolicy); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetGlobalPowerPolicy(soap, &soap_tmp___sai__SetGlobalPowerPolicy, "-sai:SetGlobalPowerPolicy", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetGlobalPowerPolicy(soap, &soap_tmp___sai__SetGlobalPowerPolicy, "-sai:SetGlobalPowerPolicy", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetGlobalPowerPolicyResponse) + return soap_closesock(soap); + sai__SetGlobalPowerPolicyResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetGlobalPowerPolicyResponse->soap_get(soap, "sai:SetGlobalPowerPolicyResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetGlobalPowerPolicy(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetGlobalPowerPolicy *sai__GetGlobalPowerPolicy, _sai__GetGlobalPowerPolicyResponse *sai__GetGlobalPowerPolicyResponse) +{ struct __sai__GetGlobalPowerPolicy soap_tmp___sai__GetGlobalPowerPolicy; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetGlobalPowerPolicy"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetGlobalPowerPolicy.sai__GetGlobalPowerPolicy = sai__GetGlobalPowerPolicy; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetGlobalPowerPolicy(soap, &soap_tmp___sai__GetGlobalPowerPolicy); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetGlobalPowerPolicy(soap, &soap_tmp___sai__GetGlobalPowerPolicy, "-sai:GetGlobalPowerPolicy", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetGlobalPowerPolicy(soap, &soap_tmp___sai__GetGlobalPowerPolicy, "-sai:GetGlobalPowerPolicy", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetGlobalPowerPolicyResponse) + return soap_closesock(soap); + sai__GetGlobalPowerPolicyResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetGlobalPowerPolicyResponse->soap_get(soap, "sai:GetGlobalPowerPolicyResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreAddKey(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreAddKey *sai__CertStoreAddKey, _sai__CertStoreAddKeyResponse *sai__CertStoreAddKeyResponse) +{ struct __sai__CertStoreAddKey soap_tmp___sai__CertStoreAddKey; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreAddKey"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreAddKey.sai__CertStoreAddKey = sai__CertStoreAddKey; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreAddKey(soap, &soap_tmp___sai__CertStoreAddKey); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreAddKey(soap, &soap_tmp___sai__CertStoreAddKey, "-sai:CertStoreAddKey", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreAddKey(soap, &soap_tmp___sai__CertStoreAddKey, "-sai:CertStoreAddKey", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreAddKeyResponse) + return soap_closesock(soap); + sai__CertStoreAddKeyResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreAddKeyResponse->soap_get(soap, "sai:CertStoreAddKeyResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreEnumerateKeys(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreEnumerateKeys *sai__CertStoreEnumerateKeys, _sai__CertStoreEnumerateKeysResponse *sai__CertStoreEnumerateKeysResponse) +{ struct __sai__CertStoreEnumerateKeys soap_tmp___sai__CertStoreEnumerateKeys; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreEnumerateKeys"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreEnumerateKeys.sai__CertStoreEnumerateKeys = sai__CertStoreEnumerateKeys; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreEnumerateKeys(soap, &soap_tmp___sai__CertStoreEnumerateKeys); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreEnumerateKeys(soap, &soap_tmp___sai__CertStoreEnumerateKeys, "-sai:CertStoreEnumerateKeys", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreEnumerateKeys(soap, &soap_tmp___sai__CertStoreEnumerateKeys, "-sai:CertStoreEnumerateKeys", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreEnumerateKeysResponse) + return soap_closesock(soap); + sai__CertStoreEnumerateKeysResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreEnumerateKeysResponse->soap_get(soap, "sai:CertStoreEnumerateKeysResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreGetKey(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreGetKey *sai__CertStoreGetKey, _sai__CertStoreGetKeyResponse *sai__CertStoreGetKeyResponse) +{ struct __sai__CertStoreGetKey soap_tmp___sai__CertStoreGetKey; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreGetKey"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreGetKey.sai__CertStoreGetKey = sai__CertStoreGetKey; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreGetKey(soap, &soap_tmp___sai__CertStoreGetKey); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreGetKey(soap, &soap_tmp___sai__CertStoreGetKey, "-sai:CertStoreGetKey", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreGetKey(soap, &soap_tmp___sai__CertStoreGetKey, "-sai:CertStoreGetKey", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreGetKeyResponse) + return soap_closesock(soap); + sai__CertStoreGetKeyResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreGetKeyResponse->soap_get(soap, "sai:CertStoreGetKeyResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreRemoveKey(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreRemoveKey *sai__CertStoreRemoveKey, _sai__CertStoreRemoveKeyResponse *sai__CertStoreRemoveKeyResponse) +{ struct __sai__CertStoreRemoveKey soap_tmp___sai__CertStoreRemoveKey; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreRemoveKey"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreRemoveKey.sai__CertStoreRemoveKey = sai__CertStoreRemoveKey; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreRemoveKey(soap, &soap_tmp___sai__CertStoreRemoveKey); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreRemoveKey(soap, &soap_tmp___sai__CertStoreRemoveKey, "-sai:CertStoreRemoveKey", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreRemoveKey(soap, &soap_tmp___sai__CertStoreRemoveKey, "-sai:CertStoreRemoveKey", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreRemoveKeyResponse) + return soap_closesock(soap); + sai__CertStoreRemoveKeyResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreRemoveKeyResponse->soap_get(soap, "sai:CertStoreRemoveKeyResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreAddCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreAddCertificate *sai__CertStoreAddCertificate, _sai__CertStoreAddCertificateResponse *sai__CertStoreAddCertificateResponse) +{ struct __sai__CertStoreAddCertificate soap_tmp___sai__CertStoreAddCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreAddCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreAddCertificate.sai__CertStoreAddCertificate = sai__CertStoreAddCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreAddCertificate(soap, &soap_tmp___sai__CertStoreAddCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreAddCertificate(soap, &soap_tmp___sai__CertStoreAddCertificate, "-sai:CertStoreAddCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreAddCertificate(soap, &soap_tmp___sai__CertStoreAddCertificate, "-sai:CertStoreAddCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreAddCertificateResponse) + return soap_closesock(soap); + sai__CertStoreAddCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreAddCertificateResponse->soap_get(soap, "sai:CertStoreAddCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreGetCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreGetCertificate *sai__CertStoreGetCertificate, _sai__CertStoreGetCertificateResponse *sai__CertStoreGetCertificateResponse) +{ struct __sai__CertStoreGetCertificate soap_tmp___sai__CertStoreGetCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreGetCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreGetCertificate.sai__CertStoreGetCertificate = sai__CertStoreGetCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreGetCertificate(soap, &soap_tmp___sai__CertStoreGetCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreGetCertificate(soap, &soap_tmp___sai__CertStoreGetCertificate, "-sai:CertStoreGetCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreGetCertificate(soap, &soap_tmp___sai__CertStoreGetCertificate, "-sai:CertStoreGetCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreGetCertificateResponse) + return soap_closesock(soap); + sai__CertStoreGetCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreGetCertificateResponse->soap_get(soap, "sai:CertStoreGetCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreEnumerateCertificates(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreEnumerateCertificates *sai__CertStoreEnumerateCertificates, _sai__CertStoreEnumerateCertificatesResponse *sai__CertStoreEnumerateCertificatesResponse) +{ struct __sai__CertStoreEnumerateCertificates soap_tmp___sai__CertStoreEnumerateCertificates; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreEnumerateCertificates"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreEnumerateCertificates.sai__CertStoreEnumerateCertificates = sai__CertStoreEnumerateCertificates; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreEnumerateCertificates(soap, &soap_tmp___sai__CertStoreEnumerateCertificates); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreEnumerateCertificates(soap, &soap_tmp___sai__CertStoreEnumerateCertificates, "-sai:CertStoreEnumerateCertificates", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreEnumerateCertificates(soap, &soap_tmp___sai__CertStoreEnumerateCertificates, "-sai:CertStoreEnumerateCertificates", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreEnumerateCertificatesResponse) + return soap_closesock(soap); + sai__CertStoreEnumerateCertificatesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreEnumerateCertificatesResponse->soap_get(soap, "sai:CertStoreEnumerateCertificatesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreRemoveCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreRemoveCertificate *sai__CertStoreRemoveCertificate, _sai__CertStoreRemoveCertificateResponse *sai__CertStoreRemoveCertificateResponse) +{ struct __sai__CertStoreRemoveCertificate soap_tmp___sai__CertStoreRemoveCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreRemoveCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreRemoveCertificate.sai__CertStoreRemoveCertificate = sai__CertStoreRemoveCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreRemoveCertificate(soap, &soap_tmp___sai__CertStoreRemoveCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreRemoveCertificate(soap, &soap_tmp___sai__CertStoreRemoveCertificate, "-sai:CertStoreRemoveCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreRemoveCertificate(soap, &soap_tmp___sai__CertStoreRemoveCertificate, "-sai:CertStoreRemoveCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreRemoveCertificateResponse) + return soap_closesock(soap); + sai__CertStoreRemoveCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreRemoveCertificateResponse->soap_get(soap, "sai:CertStoreRemoveCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreGetPKCS10Request(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreGetPKCS10Request *sai__CertStoreGetPKCS10Request, _sai__CertStoreGetPKCS10RequestResponse *sai__CertStoreGetPKCS10RequestResponse) +{ struct __sai__CertStoreGetPKCS10Request soap_tmp___sai__CertStoreGetPKCS10Request; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreGetPKCS10Request"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreGetPKCS10Request.sai__CertStoreGetPKCS10Request = sai__CertStoreGetPKCS10Request; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreGetPKCS10Request(soap, &soap_tmp___sai__CertStoreGetPKCS10Request); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreGetPKCS10Request(soap, &soap_tmp___sai__CertStoreGetPKCS10Request, "-sai:CertStoreGetPKCS10Request", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreGetPKCS10Request(soap, &soap_tmp___sai__CertStoreGetPKCS10Request, "-sai:CertStoreGetPKCS10Request", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreGetPKCS10RequestResponse) + return soap_closesock(soap); + sai__CertStoreGetPKCS10RequestResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreGetPKCS10RequestResponse->soap_get(soap, "sai:CertStoreGetPKCS10RequestResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__CertStoreUpdateCertificate(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__CertStoreUpdateCertificate *sai__CertStoreUpdateCertificate, _sai__CertStoreUpdateCertificateResponse *sai__CertStoreUpdateCertificateResponse) +{ struct __sai__CertStoreUpdateCertificate soap_tmp___sai__CertStoreUpdateCertificate; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/CertStoreUpdateCertificate"; + soap->encodingStyle = NULL; + soap_tmp___sai__CertStoreUpdateCertificate.sai__CertStoreUpdateCertificate = sai__CertStoreUpdateCertificate; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__CertStoreUpdateCertificate(soap, &soap_tmp___sai__CertStoreUpdateCertificate); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreUpdateCertificate(soap, &soap_tmp___sai__CertStoreUpdateCertificate, "-sai:CertStoreUpdateCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__CertStoreUpdateCertificate(soap, &soap_tmp___sai__CertStoreUpdateCertificate, "-sai:CertStoreUpdateCertificate", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__CertStoreUpdateCertificateResponse) + return soap_closesock(soap); + sai__CertStoreUpdateCertificateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__CertStoreUpdateCertificateResponse->soap_get(soap, "sai:CertStoreUpdateCertificateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetTLSCredentials(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetTLSCredentials *sai__SetTLSCredentials, _sai__SetTLSCredentialsResponse *sai__SetTLSCredentialsResponse) +{ struct __sai__SetTLSCredentials soap_tmp___sai__SetTLSCredentials; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetTLSCredentials"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetTLSCredentials.sai__SetTLSCredentials = sai__SetTLSCredentials; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetTLSCredentials(soap, &soap_tmp___sai__SetTLSCredentials); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTLSCredentials(soap, &soap_tmp___sai__SetTLSCredentials, "-sai:SetTLSCredentials", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetTLSCredentials(soap, &soap_tmp___sai__SetTLSCredentials, "-sai:SetTLSCredentials", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetTLSCredentialsResponse) + return soap_closesock(soap); + sai__SetTLSCredentialsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetTLSCredentialsResponse->soap_get(soap, "sai:SetTLSCredentialsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetTLSCredentials(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetTLSCredentials *sai__GetTLSCredentials, _sai__GetTLSCredentialsResponse *sai__GetTLSCredentialsResponse) +{ struct __sai__GetTLSCredentials soap_tmp___sai__GetTLSCredentials; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetTLSCredentials"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetTLSCredentials.sai__GetTLSCredentials = sai__GetTLSCredentials; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetTLSCredentials(soap, &soap_tmp___sai__GetTLSCredentials); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTLSCredentials(soap, &soap_tmp___sai__GetTLSCredentials, "-sai:GetTLSCredentials", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetTLSCredentials(soap, &soap_tmp___sai__GetTLSCredentials, "-sai:GetTLSCredentials", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetTLSCredentialsResponse) + return soap_closesock(soap); + sai__GetTLSCredentialsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetTLSCredentialsResponse->soap_get(soap, "sai:GetTLSCredentialsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__EnableVpnRouting(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__EnableVpnRouting *sai__EnableVpnRouting, _sai__EnableVpnRoutingResponse *sai__EnableVpnRoutingResponse) +{ struct __sai__EnableVpnRouting soap_tmp___sai__EnableVpnRouting; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/EnableVpnRouting"; + soap->encodingStyle = NULL; + soap_tmp___sai__EnableVpnRouting.sai__EnableVpnRouting = sai__EnableVpnRouting; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__EnableVpnRouting(soap, &soap_tmp___sai__EnableVpnRouting); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnableVpnRouting(soap, &soap_tmp___sai__EnableVpnRouting, "-sai:EnableVpnRouting", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__EnableVpnRouting(soap, &soap_tmp___sai__EnableVpnRouting, "-sai:EnableVpnRouting", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__EnableVpnRoutingResponse) + return soap_closesock(soap); + sai__EnableVpnRoutingResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__EnableVpnRoutingResponse->soap_get(soap, "sai:EnableVpnRoutingResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetConfigurationServerFQDN(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetConfigurationServerFQDN *sai__GetConfigurationServerFQDN, _sai__GetConfigurationServerFQDNResponse *sai__GetConfigurationServerFQDNResponse) +{ struct __sai__GetConfigurationServerFQDN soap_tmp___sai__GetConfigurationServerFQDN; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetConfigurationServerFQDN"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetConfigurationServerFQDN.sai__GetConfigurationServerFQDN = sai__GetConfigurationServerFQDN; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetConfigurationServerFQDN(soap, &soap_tmp___sai__GetConfigurationServerFQDN); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetConfigurationServerFQDN(soap, &soap_tmp___sai__GetConfigurationServerFQDN, "-sai:GetConfigurationServerFQDN", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetConfigurationServerFQDN(soap, &soap_tmp___sai__GetConfigurationServerFQDN, "-sai:GetConfigurationServerFQDN", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetConfigurationServerFQDNResponse) + return soap_closesock(soap); + sai__GetConfigurationServerFQDNResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetConfigurationServerFQDNResponse->soap_get(soap, "sai:GetConfigurationServerFQDNResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetConfigurationServerFQDN(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetConfigurationServerFQDN *sai__SetConfigurationServerFQDN, _sai__SetConfigurationServerFQDNResponse *sai__SetConfigurationServerFQDNResponse) +{ struct __sai__SetConfigurationServerFQDN soap_tmp___sai__SetConfigurationServerFQDN; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetConfigurationServerFQDN"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetConfigurationServerFQDN.sai__SetConfigurationServerFQDN = sai__SetConfigurationServerFQDN; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetConfigurationServerFQDN(soap, &soap_tmp___sai__SetConfigurationServerFQDN); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetConfigurationServerFQDN(soap, &soap_tmp___sai__SetConfigurationServerFQDN, "-sai:SetConfigurationServerFQDN", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetConfigurationServerFQDN(soap, &soap_tmp___sai__SetConfigurationServerFQDN, "-sai:SetConfigurationServerFQDN", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetConfigurationServerFQDNResponse) + return soap_closesock(soap); + sai__SetConfigurationServerFQDNResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetConfigurationServerFQDNResponse->soap_get(soap, "sai:SetConfigurationServerFQDNResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__SetAclEnabledState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__SetAclEnabledState *sai__SetAclEnabledState, _sai__SetAclEnabledStateResponse *sai__SetAclEnabledStateResponse) +{ struct __sai__SetAclEnabledState soap_tmp___sai__SetAclEnabledState; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/SetAclEnabledState"; + soap->encodingStyle = NULL; + soap_tmp___sai__SetAclEnabledState.sai__SetAclEnabledState = sai__SetAclEnabledState; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__SetAclEnabledState(soap, &soap_tmp___sai__SetAclEnabledState); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetAclEnabledState(soap, &soap_tmp___sai__SetAclEnabledState, "-sai:SetAclEnabledState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__SetAclEnabledState(soap, &soap_tmp___sai__SetAclEnabledState, "-sai:SetAclEnabledState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__SetAclEnabledStateResponse) + return soap_closesock(soap); + sai__SetAclEnabledStateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__SetAclEnabledStateResponse->soap_get(soap, "sai:SetAclEnabledStateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___sai__GetAclEnabledState(struct soap *soap, const char *soap_endpoint, const char *soap_action, _sai__GetAclEnabledState *sai__GetAclEnabledState, _sai__GetAclEnabledStateResponse *sai__GetAclEnabledStateResponse) +{ struct __sai__GetAclEnabledState soap_tmp___sai__GetAclEnabledState; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/SecurityAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/SecurityAdministration/2006/01/GetAclEnabledState"; + soap->encodingStyle = NULL; + soap_tmp___sai__GetAclEnabledState.sai__GetAclEnabledState = sai__GetAclEnabledState; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___sai__GetAclEnabledState(soap, &soap_tmp___sai__GetAclEnabledState); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetAclEnabledState(soap, &soap_tmp___sai__GetAclEnabledState, "-sai:GetAclEnabledState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___sai__GetAclEnabledState(soap, &soap_tmp___sai__GetAclEnabledState, "-sai:GetAclEnabledState", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!sai__GetAclEnabledStateResponse) + return soap_closesock(soap); + sai__GetAclEnabledStateResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + sai__GetAclEnabledStateResponse->soap_get(soap, "sai:GetAclEnabledStateResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___str__ExecuteStorageOperation(struct soap *soap, const char *soap_endpoint, const char *soap_action, _str__ExecuteStorageOperation *str__ExecuteStorageOperation, _str__ExecuteStorageOperationResponse *str__ExecuteStorageOperationResponse) +{ struct __str__ExecuteStorageOperation soap_tmp___str__ExecuteStorageOperation; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/Storage/2004/01/ExecuteStorageOperation"; + soap->encodingStyle = NULL; + soap_tmp___str__ExecuteStorageOperation.str__ExecuteStorageOperation = str__ExecuteStorageOperation; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___str__ExecuteStorageOperation(soap, &soap_tmp___str__ExecuteStorageOperation); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___str__ExecuteStorageOperation(soap, &soap_tmp___str__ExecuteStorageOperation, "-str:ExecuteStorageOperation", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___str__ExecuteStorageOperation(soap, &soap_tmp___str__ExecuteStorageOperation, "-str:ExecuteStorageOperation", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!str__ExecuteStorageOperationResponse) + return soap_closesock(soap); + str__ExecuteStorageOperationResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + str__ExecuteStorageOperationResponse->soap_get(soap, "str:ExecuteStorageOperationResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__GetGlobalStorageAttributes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__GetGlobalStorageAttributes *stra__GetGlobalStorageAttributes, _stra__GetGlobalStorageAttributesResponse *stra__GetGlobalStorageAttributesResponse) +{ struct __stra__GetGlobalStorageAttributes soap_tmp___stra__GetGlobalStorageAttributes; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/GetGlobalStorageAttributes"; + soap->encodingStyle = NULL; + soap_tmp___stra__GetGlobalStorageAttributes.stra__GetGlobalStorageAttributes = stra__GetGlobalStorageAttributes; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__GetGlobalStorageAttributes(soap, &soap_tmp___stra__GetGlobalStorageAttributes); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__GetGlobalStorageAttributes(soap, &soap_tmp___stra__GetGlobalStorageAttributes, "-stra:GetGlobalStorageAttributes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__GetGlobalStorageAttributes(soap, &soap_tmp___stra__GetGlobalStorageAttributes, "-stra:GetGlobalStorageAttributes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__GetGlobalStorageAttributesResponse) + return soap_closesock(soap); + stra__GetGlobalStorageAttributesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__GetGlobalStorageAttributesResponse->soap_get(soap, "stra:GetGlobalStorageAttributesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__SetGlobalStorageAttributes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__SetGlobalStorageAttributes *stra__SetGlobalStorageAttributes, _stra__SetGlobalStorageAttributesResponse *stra__SetGlobalStorageAttributesResponse) +{ struct __stra__SetGlobalStorageAttributes soap_tmp___stra__SetGlobalStorageAttributes; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/SetGlobalStorageAttributes"; + soap->encodingStyle = NULL; + soap_tmp___stra__SetGlobalStorageAttributes.stra__SetGlobalStorageAttributes = stra__SetGlobalStorageAttributes; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__SetGlobalStorageAttributes(soap, &soap_tmp___stra__SetGlobalStorageAttributes); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__SetGlobalStorageAttributes(soap, &soap_tmp___stra__SetGlobalStorageAttributes, "-stra:SetGlobalStorageAttributes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__SetGlobalStorageAttributes(soap, &soap_tmp___stra__SetGlobalStorageAttributes, "-stra:SetGlobalStorageAttributes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__SetGlobalStorageAttributesResponse) + return soap_closesock(soap); + stra__SetGlobalStorageAttributesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__SetGlobalStorageAttributesResponse->soap_get(soap, "stra:SetGlobalStorageAttributesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AdminGetRegisteredApplications(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AdminGetRegisteredApplications *stra__AdminGetRegisteredApplications, _stra__AdminGetRegisteredApplicationsResponse *stra__AdminGetRegisteredApplicationsResponse) +{ struct __stra__AdminGetRegisteredApplications soap_tmp___stra__AdminGetRegisteredApplications; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/AdminGetRegisteredApplications"; + soap->encodingStyle = NULL; + soap_tmp___stra__AdminGetRegisteredApplications.stra__AdminGetRegisteredApplications = stra__AdminGetRegisteredApplications; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__AdminGetRegisteredApplications(soap, &soap_tmp___stra__AdminGetRegisteredApplications); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AdminGetRegisteredApplications(soap, &soap_tmp___stra__AdminGetRegisteredApplications, "-stra:AdminGetRegisteredApplications", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AdminGetRegisteredApplications(soap, &soap_tmp___stra__AdminGetRegisteredApplications, "-stra:AdminGetRegisteredApplications", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__AdminGetRegisteredApplicationsResponse) + return soap_closesock(soap); + stra__AdminGetRegisteredApplicationsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__AdminGetRegisteredApplicationsResponse->soap_get(soap, "stra:AdminGetRegisteredApplicationsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AdminGetApplicationAttributes(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AdminGetApplicationAttributes *stra__AdminGetApplicationAttributes, _stra__AdminGetApplicationAttributesResponse *stra__AdminGetApplicationAttributesResponse) +{ struct __stra__AdminGetApplicationAttributes soap_tmp___stra__AdminGetApplicationAttributes; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/AdminGetApplicationAttributes"; + soap->encodingStyle = NULL; + soap_tmp___stra__AdminGetApplicationAttributes.stra__AdminGetApplicationAttributes = stra__AdminGetApplicationAttributes; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__AdminGetApplicationAttributes(soap, &soap_tmp___stra__AdminGetApplicationAttributes); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AdminGetApplicationAttributes(soap, &soap_tmp___stra__AdminGetApplicationAttributes, "-stra:AdminGetApplicationAttributes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AdminGetApplicationAttributes(soap, &soap_tmp___stra__AdminGetApplicationAttributes, "-stra:AdminGetApplicationAttributes", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__AdminGetApplicationAttributesResponse) + return soap_closesock(soap); + stra__AdminGetApplicationAttributesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__AdminGetApplicationAttributesResponse->soap_get(soap, "stra:AdminGetApplicationAttributesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AdminRemoveApplication(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AdminRemoveApplication *stra__AdminRemoveApplication, _stra__AdminRemoveApplicationResponse *stra__AdminRemoveApplicationResponse) +{ struct __stra__AdminRemoveApplication soap_tmp___stra__AdminRemoveApplication; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/AdminRemoveApplication"; + soap->encodingStyle = NULL; + soap_tmp___stra__AdminRemoveApplication.stra__AdminRemoveApplication = stra__AdminRemoveApplication; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__AdminRemoveApplication(soap, &soap_tmp___stra__AdminRemoveApplication); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AdminRemoveApplication(soap, &soap_tmp___stra__AdminRemoveApplication, "-stra:AdminRemoveApplication", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AdminRemoveApplication(soap, &soap_tmp___stra__AdminRemoveApplication, "-stra:AdminRemoveApplication", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__AdminRemoveApplicationResponse) + return soap_closesock(soap); + stra__AdminRemoveApplicationResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__AdminRemoveApplicationResponse->soap_get(soap, "stra:AdminRemoveApplicationResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AddStorageEaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AddStorageEaclEntry *stra__AddStorageEaclEntry, _stra__AddStorageEaclEntryResponse *stra__AddStorageEaclEntryResponse) +{ struct __stra__AddStorageEaclEntry soap_tmp___stra__AddStorageEaclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/AddStorageEaclEntry"; + soap->encodingStyle = NULL; + soap_tmp___stra__AddStorageEaclEntry.stra__AddStorageEaclEntry = stra__AddStorageEaclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__AddStorageEaclEntry(soap, &soap_tmp___stra__AddStorageEaclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AddStorageEaclEntry(soap, &soap_tmp___stra__AddStorageEaclEntry, "-stra:AddStorageEaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AddStorageEaclEntry(soap, &soap_tmp___stra__AddStorageEaclEntry, "-stra:AddStorageEaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__AddStorageEaclEntryResponse) + return soap_closesock(soap); + stra__AddStorageEaclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__AddStorageEaclEntryResponse->soap_get(soap, "stra:AddStorageEaclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__EnumerateStorageEaclEntries(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__EnumerateStorageEaclEntries *stra__EnumerateStorageEaclEntries, _stra__EnumerateStorageEaclEntriesResponse *stra__EnumerateStorageEaclEntriesResponse) +{ struct __stra__EnumerateStorageEaclEntries soap_tmp___stra__EnumerateStorageEaclEntries; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/EnumerateStorageEaclEntries"; + soap->encodingStyle = NULL; + soap_tmp___stra__EnumerateStorageEaclEntries.stra__EnumerateStorageEaclEntries = stra__EnumerateStorageEaclEntries; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__EnumerateStorageEaclEntries(soap, &soap_tmp___stra__EnumerateStorageEaclEntries); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__EnumerateStorageEaclEntries(soap, &soap_tmp___stra__EnumerateStorageEaclEntries, "-stra:EnumerateStorageEaclEntries", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__EnumerateStorageEaclEntries(soap, &soap_tmp___stra__EnumerateStorageEaclEntries, "-stra:EnumerateStorageEaclEntries", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__EnumerateStorageEaclEntriesResponse) + return soap_closesock(soap); + stra__EnumerateStorageEaclEntriesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__EnumerateStorageEaclEntriesResponse->soap_get(soap, "stra:EnumerateStorageEaclEntriesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__GetStorageEaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__GetStorageEaclEntry *stra__GetStorageEaclEntry, _stra__GetStorageEaclEntryResponse *stra__GetStorageEaclEntryResponse) +{ struct __stra__GetStorageEaclEntry soap_tmp___stra__GetStorageEaclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/GetStorageEaclEntry"; + soap->encodingStyle = NULL; + soap_tmp___stra__GetStorageEaclEntry.stra__GetStorageEaclEntry = stra__GetStorageEaclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__GetStorageEaclEntry(soap, &soap_tmp___stra__GetStorageEaclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__GetStorageEaclEntry(soap, &soap_tmp___stra__GetStorageEaclEntry, "-stra:GetStorageEaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__GetStorageEaclEntry(soap, &soap_tmp___stra__GetStorageEaclEntry, "-stra:GetStorageEaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__GetStorageEaclEntryResponse) + return soap_closesock(soap); + stra__GetStorageEaclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__GetStorageEaclEntryResponse->soap_get(soap, "stra:GetStorageEaclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__RemoveStorageEaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__RemoveStorageEaclEntry *stra__RemoveStorageEaclEntry, _stra__RemoveStorageEaclEntryResponse *stra__RemoveStorageEaclEntryResponse) +{ struct __stra__RemoveStorageEaclEntry soap_tmp___stra__RemoveStorageEaclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/RemoveStorageEaclEntry"; + soap->encodingStyle = NULL; + soap_tmp___stra__RemoveStorageEaclEntry.stra__RemoveStorageEaclEntry = stra__RemoveStorageEaclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__RemoveStorageEaclEntry(soap, &soap_tmp___stra__RemoveStorageEaclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__RemoveStorageEaclEntry(soap, &soap_tmp___stra__RemoveStorageEaclEntry, "-stra:RemoveStorageEaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__RemoveStorageEaclEntry(soap, &soap_tmp___stra__RemoveStorageEaclEntry, "-stra:RemoveStorageEaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__RemoveStorageEaclEntryResponse) + return soap_closesock(soap); + stra__RemoveStorageEaclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__RemoveStorageEaclEntryResponse->soap_get(soap, "stra:RemoveStorageEaclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__AddStorageFpaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__AddStorageFpaclEntry *stra__AddStorageFpaclEntry, _stra__AddStorageFpaclEntryResponse *stra__AddStorageFpaclEntryResponse) +{ struct __stra__AddStorageFpaclEntry soap_tmp___stra__AddStorageFpaclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/AddStorageFpaclEntry"; + soap->encodingStyle = NULL; + soap_tmp___stra__AddStorageFpaclEntry.stra__AddStorageFpaclEntry = stra__AddStorageFpaclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__AddStorageFpaclEntry(soap, &soap_tmp___stra__AddStorageFpaclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AddStorageFpaclEntry(soap, &soap_tmp___stra__AddStorageFpaclEntry, "-stra:AddStorageFpaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__AddStorageFpaclEntry(soap, &soap_tmp___stra__AddStorageFpaclEntry, "-stra:AddStorageFpaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__AddStorageFpaclEntryResponse) + return soap_closesock(soap); + stra__AddStorageFpaclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__AddStorageFpaclEntryResponse->soap_get(soap, "stra:AddStorageFpaclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__EnumerateStorageAllocEntries(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__EnumerateStorageAllocEntries *stra__EnumerateStorageAllocEntries, _stra__EnumerateStorageAllocEntriesResponse *stra__EnumerateStorageAllocEntriesResponse) +{ struct __stra__EnumerateStorageAllocEntries soap_tmp___stra__EnumerateStorageAllocEntries; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/EnumerateStorageAllocEntries"; + soap->encodingStyle = NULL; + soap_tmp___stra__EnumerateStorageAllocEntries.stra__EnumerateStorageAllocEntries = stra__EnumerateStorageAllocEntries; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__EnumerateStorageAllocEntries(soap, &soap_tmp___stra__EnumerateStorageAllocEntries); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__EnumerateStorageAllocEntries(soap, &soap_tmp___stra__EnumerateStorageAllocEntries, "-stra:EnumerateStorageAllocEntries", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__EnumerateStorageAllocEntries(soap, &soap_tmp___stra__EnumerateStorageAllocEntries, "-stra:EnumerateStorageAllocEntries", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__EnumerateStorageAllocEntriesResponse) + return soap_closesock(soap); + stra__EnumerateStorageAllocEntriesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__EnumerateStorageAllocEntriesResponse->soap_get(soap, "stra:EnumerateStorageAllocEntriesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__GetStorageAllocEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__GetStorageAllocEntry *stra__GetStorageAllocEntry, _stra__GetStorageAllocEntryResponse *stra__GetStorageAllocEntryResponse) +{ struct __stra__GetStorageAllocEntry soap_tmp___stra__GetStorageAllocEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/GetStorageAllocEntry"; + soap->encodingStyle = NULL; + soap_tmp___stra__GetStorageAllocEntry.stra__GetStorageAllocEntry = stra__GetStorageAllocEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__GetStorageAllocEntry(soap, &soap_tmp___stra__GetStorageAllocEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__GetStorageAllocEntry(soap, &soap_tmp___stra__GetStorageAllocEntry, "-stra:GetStorageAllocEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__GetStorageAllocEntry(soap, &soap_tmp___stra__GetStorageAllocEntry, "-stra:GetStorageAllocEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__GetStorageAllocEntryResponse) + return soap_closesock(soap); + stra__GetStorageAllocEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__GetStorageAllocEntryResponse->soap_get(soap, "stra:GetStorageAllocEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__UpdateStorageFpaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__UpdateStorageFpaclEntry *stra__UpdateStorageFpaclEntry, _stra__UpdateStorageFpaclEntryResponse *stra__UpdateStorageFpaclEntryResponse) +{ struct __stra__UpdateStorageFpaclEntry soap_tmp___stra__UpdateStorageFpaclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/UpdateStorageFpaclEntry"; + soap->encodingStyle = NULL; + soap_tmp___stra__UpdateStorageFpaclEntry.stra__UpdateStorageFpaclEntry = stra__UpdateStorageFpaclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__UpdateStorageFpaclEntry(soap, &soap_tmp___stra__UpdateStorageFpaclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__UpdateStorageFpaclEntry(soap, &soap_tmp___stra__UpdateStorageFpaclEntry, "-stra:UpdateStorageFpaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__UpdateStorageFpaclEntry(soap, &soap_tmp___stra__UpdateStorageFpaclEntry, "-stra:UpdateStorageFpaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__UpdateStorageFpaclEntryResponse) + return soap_closesock(soap); + stra__UpdateStorageFpaclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__UpdateStorageFpaclEntryResponse->soap_get(soap, "stra:UpdateStorageFpaclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___stra__RemoveStorageFpaclEntry(struct soap *soap, const char *soap_endpoint, const char *soap_action, _stra__RemoveStorageFpaclEntry *stra__RemoveStorageFpaclEntry, _stra__RemoveStorageFpaclEntryResponse *stra__RemoveStorageFpaclEntryResponse) +{ struct __stra__RemoveStorageFpaclEntry soap_tmp___stra__RemoveStorageFpaclEntry; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/StorageAdministrationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/StorageAdministration/2004/01/RemoveStorageFpaclEntry"; + soap->encodingStyle = NULL; + soap_tmp___stra__RemoveStorageFpaclEntry.stra__RemoveStorageFpaclEntry = stra__RemoveStorageFpaclEntry; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___stra__RemoveStorageFpaclEntry(soap, &soap_tmp___stra__RemoveStorageFpaclEntry); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__RemoveStorageFpaclEntry(soap, &soap_tmp___stra__RemoveStorageFpaclEntry, "-stra:RemoveStorageFpaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___stra__RemoveStorageFpaclEntry(soap, &soap_tmp___stra__RemoveStorageFpaclEntry, "-stra:RemoveStorageFpaclEntry", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!stra__RemoveStorageFpaclEntryResponse) + return soap_closesock(soap); + stra__RemoveStorageFpaclEntryResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + stra__RemoveStorageFpaclEntryResponse->soap_get(soap, "stra:RemoveStorageFpaclEntryResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___tim__GetLowAccuracyTimeSynch(struct soap *soap, const char *soap_endpoint, const char *soap_action, _tim__GetLowAccuracyTimeSynch *tim__GetLowAccuracyTimeSynch, _tim__GetLowAccuracyTimeSynchResponse *tim__GetLowAccuracyTimeSynchResponse) +{ struct __tim__GetLowAccuracyTimeSynch soap_tmp___tim__GetLowAccuracyTimeSynch; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkTimeService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkTime/2004/01/GetLowAccuracyTimeSynch"; + soap->encodingStyle = NULL; + soap_tmp___tim__GetLowAccuracyTimeSynch.tim__GetLowAccuracyTimeSynch = tim__GetLowAccuracyTimeSynch; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___tim__GetLowAccuracyTimeSynch(soap, &soap_tmp___tim__GetLowAccuracyTimeSynch); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___tim__GetLowAccuracyTimeSynch(soap, &soap_tmp___tim__GetLowAccuracyTimeSynch, "-tim:GetLowAccuracyTimeSynch", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___tim__GetLowAccuracyTimeSynch(soap, &soap_tmp___tim__GetLowAccuracyTimeSynch, "-tim:GetLowAccuracyTimeSynch", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!tim__GetLowAccuracyTimeSynchResponse) + return soap_closesock(soap); + tim__GetLowAccuracyTimeSynchResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + tim__GetLowAccuracyTimeSynchResponse->soap_get(soap, "tim:GetLowAccuracyTimeSynchResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___tim__SetHighAccuracyTimeSynch(struct soap *soap, const char *soap_endpoint, const char *soap_action, _tim__SetHighAccuracyTimeSynch *tim__SetHighAccuracyTimeSynch, _tim__SetHighAccuracyTimeSynchResponse *tim__SetHighAccuracyTimeSynchResponse) +{ struct __tim__SetHighAccuracyTimeSynch soap_tmp___tim__SetHighAccuracyTimeSynch; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/NetworkTimeService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/NetworkTime/2004/01/SetHighAccuracyTimeSynch"; + soap->encodingStyle = NULL; + soap_tmp___tim__SetHighAccuracyTimeSynch.tim__SetHighAccuracyTimeSynch = tim__SetHighAccuracyTimeSynch; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___tim__SetHighAccuracyTimeSynch(soap, &soap_tmp___tim__SetHighAccuracyTimeSynch); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___tim__SetHighAccuracyTimeSynch(soap, &soap_tmp___tim__SetHighAccuracyTimeSynch, "-tim:SetHighAccuracyTimeSynch", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___tim__SetHighAccuracyTimeSynch(soap, &soap_tmp___tim__SetHighAccuracyTimeSynch, "-tim:SetHighAccuracyTimeSynch", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!tim__SetHighAccuracyTimeSynchResponse) + return soap_closesock(soap); + tim__SetHighAccuracyTimeSynchResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + tim__SetHighAccuracyTimeSynchResponse->soap_get(soap, "tim:SetHighAccuracyTimeSynchResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__AddWirelessProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__AddWirelessProfileRequest *wcxs__AddWirelessProfileRequest, _wcxs__AddWirelessProfileResponse *wcxs__AddWirelessProfileResponse) +{ struct __wcxs__AddWirelessProfile soap_tmp___wcxs__AddWirelessProfile; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/WirelessConfigurationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/WirelessConfiguration/2006/01/AddWirelessProfile"; + soap->encodingStyle = NULL; + soap_tmp___wcxs__AddWirelessProfile.wcxs__AddWirelessProfileRequest = wcxs__AddWirelessProfileRequest; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___wcxs__AddWirelessProfile(soap, &soap_tmp___wcxs__AddWirelessProfile); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__AddWirelessProfile(soap, &soap_tmp___wcxs__AddWirelessProfile, "-wcxs:AddWirelessProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__AddWirelessProfile(soap, &soap_tmp___wcxs__AddWirelessProfile, "-wcxs:AddWirelessProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!wcxs__AddWirelessProfileResponse) + return soap_closesock(soap); + wcxs__AddWirelessProfileResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + wcxs__AddWirelessProfileResponse->soap_get(soap, "wcxs:AddWirelessProfileResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__GetWirelessProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__GetWirelessProfileRequest *wcxs__GetWirelessProfileRequest, _wcxs__GetWirelessProfileResponse *wcxs__GetWirelessProfileResponse) +{ struct __wcxs__GetWirelessProfile soap_tmp___wcxs__GetWirelessProfile; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/WirelessConfigurationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/WirelessConfiguration/2006/01/GetWirelessProfile"; + soap->encodingStyle = NULL; + soap_tmp___wcxs__GetWirelessProfile.wcxs__GetWirelessProfileRequest = wcxs__GetWirelessProfileRequest; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___wcxs__GetWirelessProfile(soap, &soap_tmp___wcxs__GetWirelessProfile); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__GetWirelessProfile(soap, &soap_tmp___wcxs__GetWirelessProfile, "-wcxs:GetWirelessProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__GetWirelessProfile(soap, &soap_tmp___wcxs__GetWirelessProfile, "-wcxs:GetWirelessProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!wcxs__GetWirelessProfileResponse) + return soap_closesock(soap); + wcxs__GetWirelessProfileResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + wcxs__GetWirelessProfileResponse->soap_get(soap, "wcxs:GetWirelessProfileResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__RemoveWirelessProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__RemoveWirelessProfileRequest *wcxs__RemoveWirelessProfileRequest, _wcxs__RemoveWirelessProfileResponse *wcxs__RemoveWirelessProfileResponse) +{ struct __wcxs__RemoveWirelessProfile soap_tmp___wcxs__RemoveWirelessProfile; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/WirelessConfigurationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/WirelessConfiguration/2006/01/RemoveWirelessProfile"; + soap->encodingStyle = NULL; + soap_tmp___wcxs__RemoveWirelessProfile.wcxs__RemoveWirelessProfileRequest = wcxs__RemoveWirelessProfileRequest; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___wcxs__RemoveWirelessProfile(soap, &soap_tmp___wcxs__RemoveWirelessProfile); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__RemoveWirelessProfile(soap, &soap_tmp___wcxs__RemoveWirelessProfile, "-wcxs:RemoveWirelessProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__RemoveWirelessProfile(soap, &soap_tmp___wcxs__RemoveWirelessProfile, "-wcxs:RemoveWirelessProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!wcxs__RemoveWirelessProfileResponse) + return soap_closesock(soap); + wcxs__RemoveWirelessProfileResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + wcxs__RemoveWirelessProfileResponse->soap_get(soap, "wcxs:RemoveWirelessProfileResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__UpdateWirelessProfile(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__UpdateWirelessProfileRequest *wcxs__UpdateWirelessProfileRequest, _wcxs__UpdateWirelessProfileResponse *wcxs__UpdateWirelessProfileResponse) +{ struct __wcxs__UpdateWirelessProfile soap_tmp___wcxs__UpdateWirelessProfile; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/WirelessConfigurationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/WirelessConfiguration/2006/01/UpdateWirelessProfile"; + soap->encodingStyle = NULL; + soap_tmp___wcxs__UpdateWirelessProfile.wcxs__UpdateWirelessProfileRequest = wcxs__UpdateWirelessProfileRequest; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___wcxs__UpdateWirelessProfile(soap, &soap_tmp___wcxs__UpdateWirelessProfile); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__UpdateWirelessProfile(soap, &soap_tmp___wcxs__UpdateWirelessProfile, "-wcxs:UpdateWirelessProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__UpdateWirelessProfile(soap, &soap_tmp___wcxs__UpdateWirelessProfile, "-wcxs:UpdateWirelessProfile", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!wcxs__UpdateWirelessProfileResponse) + return soap_closesock(soap); + wcxs__UpdateWirelessProfileResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + wcxs__UpdateWirelessProfileResponse->soap_get(soap, "wcxs:UpdateWirelessProfileResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__EnumerateWirelessProfiles(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__EnumerateWirelessProfilesRequest *wcxs__EnumerateWirelessProfilesRequest, _wcxs__EnumerateWirelessProfilesResponse *wcxs__EnumerateWirelessProfilesResponse) +{ struct __wcxs__EnumerateWirelessProfiles soap_tmp___wcxs__EnumerateWirelessProfiles; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/WirelessConfigurationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/WirelessConfiguration/2006/01/EnumerateWirelessProfiles"; + soap->encodingStyle = NULL; + soap_tmp___wcxs__EnumerateWirelessProfiles.wcxs__EnumerateWirelessProfilesRequest = wcxs__EnumerateWirelessProfilesRequest; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___wcxs__EnumerateWirelessProfiles(soap, &soap_tmp___wcxs__EnumerateWirelessProfiles); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__EnumerateWirelessProfiles(soap, &soap_tmp___wcxs__EnumerateWirelessProfiles, "-wcxs:EnumerateWirelessProfiles", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__EnumerateWirelessProfiles(soap, &soap_tmp___wcxs__EnumerateWirelessProfiles, "-wcxs:EnumerateWirelessProfiles", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!wcxs__EnumerateWirelessProfilesResponse) + return soap_closesock(soap); + wcxs__EnumerateWirelessProfilesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + wcxs__EnumerateWirelessProfilesResponse->soap_get(soap, "wcxs:EnumerateWirelessProfilesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__GetWirelessCapabilities(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__GetWirelessCapabilitiesRequest *wcxs__GetWirelessCapabilitiesRequest, _wcxs__GetWirelessCapabilitiesResponse *wcxs__GetWirelessCapabilitiesResponse) +{ struct __wcxs__GetWirelessCapabilities soap_tmp___wcxs__GetWirelessCapabilities; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/WirelessConfigurationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/WirelessConfiguration/2006/01/GetWirelessCapabilities"; + soap->encodingStyle = NULL; + soap_tmp___wcxs__GetWirelessCapabilities.wcxs__GetWirelessCapabilitiesRequest = wcxs__GetWirelessCapabilitiesRequest; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___wcxs__GetWirelessCapabilities(soap, &soap_tmp___wcxs__GetWirelessCapabilities); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__GetWirelessCapabilities(soap, &soap_tmp___wcxs__GetWirelessCapabilities, "-wcxs:GetWirelessCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__GetWirelessCapabilities(soap, &soap_tmp___wcxs__GetWirelessCapabilities, "-wcxs:GetWirelessCapabilities", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!wcxs__GetWirelessCapabilitiesResponse) + return soap_closesock(soap); + wcxs__GetWirelessCapabilitiesResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + wcxs__GetWirelessCapabilitiesResponse->soap_get(soap, "wcxs:GetWirelessCapabilitiesResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +SOAP_FMAC5 int SOAP_FMAC6 soap_call___wcxs__GetWirelessSettings(struct soap *soap, const char *soap_endpoint, const char *soap_action, _wcxs__GetWirelessSettingsRequest *wcxs__GetWirelessSettingsRequest, _wcxs__GetWirelessSettingsResponse *wcxs__GetWirelessSettingsResponse) +{ struct __wcxs__GetWirelessSettings soap_tmp___wcxs__GetWirelessSettings; + if (!soap_endpoint) + soap_endpoint = "http://hostname:16992/WirelessConfigurationService"; + if (!soap_action) + soap_action = "http://schemas.intel.com/platform/client/WirelessConfiguration/2006/01/GetWirelessSettings"; + soap->encodingStyle = NULL; + soap_tmp___wcxs__GetWirelessSettings.wcxs__GetWirelessSettingsRequest = wcxs__GetWirelessSettingsRequest; + soap_begin(soap); + soap_serializeheader(soap); + soap_serialize___wcxs__GetWirelessSettings(soap, &soap_tmp___wcxs__GetWirelessSettings); + if (soap_begin_count(soap)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__GetWirelessSettings(soap, &soap_tmp___wcxs__GetWirelessSettings, "-wcxs:GetWirelessSettings", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap->error; + } + if (soap_end_count(soap)) + return soap->error; + if (soap_connect(soap, soap_endpoint, soap_action) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_put___wcxs__GetWirelessSettings(soap, &soap_tmp___wcxs__GetWirelessSettings, "-wcxs:GetWirelessSettings", "") + || soap_body_end_out(soap) + || soap_envelope_end_out(soap) + || soap_end_send(soap)) + return soap_closesock(soap); + if (!wcxs__GetWirelessSettingsResponse) + return soap_closesock(soap); + wcxs__GetWirelessSettingsResponse->soap_default(soap); + if (soap_begin_recv(soap) + || soap_envelope_begin_in(soap) + || soap_recv_header(soap) + || soap_body_begin_in(soap)) + return soap_closesock(soap); + wcxs__GetWirelessSettingsResponse->soap_get(soap, "wcxs:GetWirelessSettingsResponse", ""); + if (soap->error) + { if (soap->error == SOAP_TAG_MISMATCH && soap->level == 2) + return soap_recv_fault(soap); + return soap_closesock(soap); + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + return soap_closesock(soap); +} + +/* End of soapClient.cpp */ diff --git a/pcucontrol/models/intelamt/stdsoap2.cpp b/pcucontrol/models/intelamt/stdsoap2.cpp new file mode 100644 index 0000000..c93354a --- /dev/null +++ b/pcucontrol/models/intelamt/stdsoap2.cpp @@ -0,0 +1,13925 @@ +/* + +stdsoap2.c[pp] 2.7.8c + +gSOAP runtime + +gSOAP XML Web services tools +Copyright (C) 2000-2006, Robert van Engelen, Genivia Inc., All Rights Reserved. +This part of the software is released under one of the following licenses: +GPL, the gSOAP public license, or Genivia's license for commercial use. +-------------------------------------------------------------------------------- +Contributors: + +Wind River Systems Inc., for the following additions under gSOAP public license: + - vxWorks compatible (#define VXWORKS) +-------------------------------------------------------------------------------- +gSOAP public license. + +The contents of this file are subject to the gSOAP Public License Version 1.3 +(the "License"); you may not use this file except in compliance with the +License. You may obtain a copy of the License at +http://www.cs.fsu.edu/~engelen/soaplicense.html +Software distributed under the License is distributed on an "AS IS" basis, +WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +for the specific language governing rights and limitations under the License. + +The Initial Developer of the Original Code is Robert A. van Engelen. +Copyright (C) 2000-2006, Robert van Engelen, Genivia Inc., All Rights Reserved. +-------------------------------------------------------------------------------- +GPL license. + +This program is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free Software +Foundation; either version 2 of the License, or (at your option) any later +version. + +This program is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with +this program; if not, write to the Free Software Foundation, Inc., 59 Temple +Place, Suite 330, Boston, MA 02111-1307 USA + +Author contact information: +engelen@genivia.com / engelen@acm.org +-------------------------------------------------------------------------------- +A commercial use license is available from Genivia, Inc., contact@genivia.com +-------------------------------------------------------------------------------- + +Installation note: + +Win32 build needs winsock.dll (Visual C++ "wsock32.lib") +To do this in Visual C++ 6.0, go to "Project", "settings", select the "Link" +tab (the project file needs to be selected in the file view) and add +"wsock32.lib" to the "Object/library modules" entry + +On Mac OS X with gcc (GCC) 3.1 20020420 (prerelease) you MUST compile with +-fstack_check when using -O2 because gcc 3.1 has a bug that smashes the stack +when locally allocated data exceeds 64K. + +*/ + +#ifdef AS400 +# pragma convert(819) /* EBCDIC to ASCII */ +#endif + +#include "stdsoap2.h" + +#ifdef __cplusplus +SOAP_SOURCE_STAMP("@(#) stdsoap2.cpp ver 2.7.8c 2006-06-24 12:00:00 GMT") +extern "C" { +#else +SOAP_SOURCE_STAMP("@(#) stdsoap2.c ver 2.7.8c 2006-06-24 12:00:00 GMT") +#endif + +/* 8bit character representing unknown/nonrepresentable character data (e.g. not supported by current locale with multibyte support enabled) */ +#ifndef SOAP_UNKNOWN_CHAR +#define SOAP_UNKNOWN_CHAR (127) +#endif + +/* EOF=-1 */ +#define SOAP_LT (soap_wchar)(-2) /* XML character '<' */ +#define SOAP_TT (soap_wchar)(-3) /* XML character '' */ +#define SOAP_QT (soap_wchar)(-5) /* XML character '"' */ +#define SOAP_AP (soap_wchar)(-6) /* XML character ''' */ + +#define soap_blank(c) ((c) >= 0 && (c) <= 32) +#define soap_notblank(c) ((c) > 32) +#define soap_hash_ptr(p) (((unsigned long)(p) >> 3) & (SOAP_PTRHASH - 1)) + +#ifdef SOAP_DEBUG +static void soap_init_logs(struct soap*); +static void soap_close_logfile(struct soap*, int); +static void soap_set_logfile(struct soap*, int, const char*); +static void soap_free_mht(struct soap*); +static void soap_track_unlink(struct soap*, const void*); +#endif + +#ifndef PALM_2 +static int soap_set_error(struct soap*, const char*, const char*, const char*, const char*, int); +static int soap_copy_fault(struct soap*, const char*, const char*, const char*, const char*); +static int soap_getattrval(struct soap*, char*, size_t, soap_wchar); +#endif + +#ifndef PALM_1 +static soap_wchar soap_char(struct soap*); +static soap_wchar soap_get_pi(struct soap*); +static int soap_isxdigit(int); +static void *fplugin(struct soap*, const char*); +#ifndef WITH_NOIDREF +static void soap_update_ptrs(struct soap*, char*, char*, char*, char*); +static int soap_has_copies(struct soap*, const char*, const char*); +static void soap_init_iht(struct soap*); +static void soap_free_iht(struct soap*); +static void soap_init_pht(struct soap*); +static void soap_free_pht(struct soap*); +#endif +#endif + +#ifndef WITH_LEAN +static const char *soap_set_validation_fault(struct soap*, const char*, const char*); +static int soap_isnumeric(struct soap*, const char*); +static time_t soap_timegm(struct tm*); +static struct soap_nlist *soap_lookup_ns(struct soap *soap, const char *tag, size_t n); +static struct soap_nlist *soap_push_ns(struct soap *soap, const char *id, const char *ns, short utilized); +static void soap_pop_ns(struct soap *soap); +static void soap_utilize_ns(struct soap *soap, const char *tag, size_t n); +#endif + +#ifndef WITH_LEANER +#ifndef PALM_1 +static struct soap_multipart *soap_new_multipart(struct soap*, struct soap_multipart**, struct soap_multipart**, char*, size_t); +static int soap_putdimefield(struct soap*, const char*, size_t); +static char *soap_getdimefield(struct soap*, size_t); +static void soap_select_mime_boundary(struct soap*); +static int soap_valid_mime_boundary(struct soap*); +static void soap_resolve_attachment(struct soap*, struct soap_multipart*); +#endif +#endif + +#ifdef WITH_GZIP +static int soap_getgziphdr(struct soap*); +#endif + +#ifdef WITH_OPENSSL +static int ssl_init_done = 0; +static int ssl_auth_init(struct soap*); +static int ssl_verify_callback(int, X509_STORE_CTX*); +static int ssl_password(char*, int, int, void *); +/* This callback is included for future references. It should not be deleted +static DH *ssl_tmp_dh(SSL*, int, int); +*/ +#endif + +#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER) +#ifndef PALM_1 +static const char *soap_decode(char*, size_t, const char*, const char*); +#endif +#endif + +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static soap_wchar soap_getchunkchar(struct soap*); +static const char *http_error(struct soap*, int); +static int http_post(struct soap*, const char*, const char*, int, const char*, const char*, size_t); +static int http_get(struct soap*); +static int http_send_header(struct soap*, const char*); +static int http_post_header(struct soap*, const char*, const char*); +static int http_response(struct soap*, int, size_t); +static int http_parse(struct soap*); +static int http_parse_header(struct soap*, const char*, const char*); +#endif +#endif + +#ifndef WITH_NOIO +#ifndef PALM_1 +static int fsend(struct soap*, const char*, size_t); +static size_t frecv(struct soap*, char*, size_t); +static int tcp_init(struct soap*); +static const char *tcp_error(struct soap*); +#ifndef WITH_IPV6 +static int tcp_gethost(struct soap*, const char *addr, struct in_addr *inaddr); +#endif +static int tcp_connect(struct soap*, const char *endpoint, const char *host, int port); +static int tcp_accept(struct soap*, int, struct sockaddr*, int*); +static int tcp_disconnect(struct soap*); +static int tcp_closesocket(struct soap*, SOAP_SOCKET); +static int tcp_shutdownsocket(struct soap*, SOAP_SOCKET, int); +static const char *soap_strerror(struct soap*); +#endif +#endif + +#if defined(PALM) && !defined(PALM_2) +unsigned short errno; +#endif + +#ifndef PALM_1 +static const char soap_env1[42] = "http://schemas.xmlsoap.org/soap/envelope/"; +static const char soap_enc1[42] = "http://schemas.xmlsoap.org/soap/encoding/"; +static const char soap_env2[40] = "http://www.w3.org/2003/05/soap-envelope"; +static const char soap_enc2[40] = "http://www.w3.org/2003/05/soap-encoding"; +static const char soap_rpc[35] = "http://www.w3.org/2003/05/soap-rpc"; +#endif + +#ifndef PALM_1 +const struct soap_double_nan soap_double_nan = {0xFFFFFFFF, 0xFFFFFFFF}; +static const char soap_base64o[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +static const char soap_base64i[81] = "\76XXX\77\64\65\66\67\70\71\72\73\74\75XXXXXXX\00\01\02\03\04\05\06\07\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31XXXXXX\32\33\34\35\36\37\40\41\42\43\44\45\46\47\50\51\52\53\54\55\56\57\60\61\62\63"; +#endif + +#ifndef WITH_LEAN +static const char soap_indent[11] = "\n\t\t\t\t\t\t\t\t\t"; +/* Alternative indentation form for SOAP_XML_INDENT: +static const char soap_indent[21] = "\n "; +*/ +#endif + +#ifndef SOAP_CANARY +# define SOAP_CANARY (0xC0DE) +#endif + +static const char soap_padding[4] = "\0\0\0"; +#define SOAP_STR_PADDING (soap_padding) +#define SOAP_STR_EOS (soap_padding) +#define SOAP_NON_NULL (soap_padding) + +#ifndef WITH_LEAN +static const struct soap_code_map html_entity_codes[] = /* entities for XHTML parsing */ +{ { 160, "nbsp" }, + { 161, "iexcl" }, + { 162, "cent" }, + { 163, "pound" }, + { 164, "curren" }, + { 165, "yen" }, + { 166, "brvbar" }, + { 167, "sect" }, + { 168, "uml" }, + { 169, "copy" }, + { 170, "ordf" }, + { 171, "laquo" }, + { 172, "not" }, + { 173, "shy" }, + { 174, "reg" }, + { 175, "macr" }, + { 176, "deg" }, + { 177, "plusmn" }, + { 178, "sup2" }, + { 179, "sup3" }, + { 180, "acute" }, + { 181, "micro" }, + { 182, "para" }, + { 183, "middot" }, + { 184, "cedil" }, + { 185, "sup1" }, + { 186, "ordm" }, + { 187, "raquo" }, + { 188, "frac14" }, + { 189, "frac12" }, + { 190, "frac34" }, + { 191, "iquest" }, + { 192, "Agrave" }, + { 193, "Aacute" }, + { 194, "Acirc" }, + { 195, "Atilde" }, + { 196, "Auml" }, + { 197, "Aring" }, + { 198, "AElig" }, + { 199, "Ccedil" }, + { 200, "Egrave" }, + { 201, "Eacute" }, + { 202, "Ecirc" }, + { 203, "Euml" }, + { 204, "Igrave" }, + { 205, "Iacute" }, + { 206, "Icirc" }, + { 207, "Iuml" }, + { 208, "ETH" }, + { 209, "Ntilde" }, + { 210, "Ograve" }, + { 211, "Oacute" }, + { 212, "Ocirc" }, + { 213, "Otilde" }, + { 214, "Ouml" }, + { 215, "times" }, + { 216, "Oslash" }, + { 217, "Ugrave" }, + { 218, "Uacute" }, + { 219, "Ucirc" }, + { 220, "Uuml" }, + { 221, "Yacute" }, + { 222, "THORN" }, + { 223, "szlig" }, + { 224, "agrave" }, + { 225, "aacute" }, + { 226, "acirc" }, + { 227, "atilde" }, + { 228, "auml" }, + { 229, "aring" }, + { 230, "aelig" }, + { 231, "ccedil" }, + { 232, "egrave" }, + { 233, "eacute" }, + { 234, "ecirc" }, + { 235, "euml" }, + { 236, "igrave" }, + { 237, "iacute" }, + { 238, "icirc" }, + { 239, "iuml" }, + { 240, "eth" }, + { 241, "ntilde" }, + { 242, "ograve" }, + { 243, "oacute" }, + { 244, "ocirc" }, + { 245, "otilde" }, + { 246, "ouml" }, + { 247, "divide" }, + { 248, "oslash" }, + { 249, "ugrave" }, + { 250, "uacute" }, + { 251, "ucirc" }, + { 252, "uuml" }, + { 253, "yacute" }, + { 254, "thorn" }, + { 255, "yuml" }, + { 0, NULL } +}; +#endif + +#ifndef WITH_NOIO +#ifndef WITH_LEAN +static const struct soap_code_map h_error_codes[] = +{ +#ifdef HOST_NOT_FOUND + { HOST_NOT_FOUND, "Host not found" }, +#endif +#ifdef TRY_AGAIN + { TRY_AGAIN, "Try Again" }, +#endif +#ifdef NO_RECOVERY + { NO_RECOVERY, "No Recovery" }, +#endif +#ifdef NO_DATA + { NO_DATA, "No Data" }, +#endif +#ifdef NO_ADDRESS + { NO_ADDRESS, "No Address" }, +#endif + { 0, NULL } +}; +#endif +#endif + +#ifndef WITH_NOHTTP +#ifndef WITH_LEAN +static const struct soap_code_map h_http_error_codes[] = +{ { 200, "OK" }, + { 201, "Created" }, + { 202, "Accepted" }, + { 203, "Non-Authoritative Information" }, + { 204, "No Content" }, + { 205, "Reset Content" }, + { 206, "Partial Content" }, + { 300, "Multiple Choices" }, + { 301, "Moved Permanently" }, + { 302, "Found" }, + { 303, "See Other" }, + { 304, "Not Modified" }, + { 305, "Use Proxy" }, + { 307, "Temporary Redirect" }, + { 400, "Bad Request" }, + { 401, "Unauthorized" }, + { 402, "Payment Required" }, + { 403, "Forbidden" }, + { 404, "Not Found" }, + { 405, "Method Not Allowed" }, + { 406, "Not Acceptable" }, + { 407, "Proxy Authentication Required" }, + { 408, "Request Time-out" }, + { 409, "Conflict" }, + { 410, "Gone" }, + { 411, "Length Required" }, + { 412, "Precondition Failed" }, + { 413, "Request Entity Too Large" }, + { 414, "Request-URI Too Large" }, + { 415, "Unsupported Media Type" }, + { 416, "Requested range not satisfiable" }, + { 417, "Expectation Failed" }, + { 500, "Internal Server Error" }, + { 501, "Not Implemented" }, + { 502, "Bad Gateway" }, + { 503, "Service Unavailable" }, + { 504, "Gateway Time-out" }, + { 505, "HTTP Version not supported" }, + { 0, NULL } +}; +#endif +#endif + +#ifdef WITH_OPENSSL +static const struct soap_code_map h_ssl_error_codes[] = +{ +#define _SSL_ERROR(e) { e, #e } + _SSL_ERROR(SSL_ERROR_SSL), + _SSL_ERROR(SSL_ERROR_ZERO_RETURN), + _SSL_ERROR(SSL_ERROR_WANT_READ), + _SSL_ERROR(SSL_ERROR_WANT_WRITE), + _SSL_ERROR(SSL_ERROR_WANT_CONNECT), + _SSL_ERROR(SSL_ERROR_WANT_X509_LOOKUP), + _SSL_ERROR(SSL_ERROR_SYSCALL), + { 0, NULL } +}; +#endif + +#ifndef WITH_LEANER +static const struct soap_code_map mime_codes[] = +{ { SOAP_MIME_7BIT, "7bit" }, + { SOAP_MIME_8BIT, "8bit" }, + { SOAP_MIME_BINARY, "binary" }, + { SOAP_MIME_QUOTED_PRINTABLE, "quoted-printable" }, + { SOAP_MIME_BASE64, "base64" }, + { SOAP_MIME_IETF_TOKEN, "ietf-token" }, + { SOAP_MIME_X_TOKEN, "x-token" }, + { 0, NULL } +}; +#endif + +#ifdef WIN32 +static int tcp_done = 0; +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static int +fsend(struct soap *soap, const char *s, size_t n) +{ register int nwritten; +#if defined(__cplusplus) && !defined(WITH_LEAN) + if (soap->os) + { soap->os->write(s, n); + if (soap->os->good()) + return SOAP_OK; + return SOAP_EOF; + } +#endif + while (n) + { if (soap_valid_socket(soap->socket)) + { +#ifndef WITH_LEAN + if (soap->send_timeout) + { struct timeval timeout; + fd_set fd; + if (soap->send_timeout > 0) + { timeout.tv_sec = soap->send_timeout; + timeout.tv_usec = 0; + } + else + { timeout.tv_sec = -soap->send_timeout/1000000; + timeout.tv_usec = -soap->send_timeout%1000000; + } +#ifndef WIN32 + if ((int)soap->socket > FD_SETSIZE) + return SOAP_FD_EXCEEDED; /* Hint: MUST increase FD_SETSIZE */ +#endif + FD_ZERO(&fd); + FD_SET((SOAP_SOCKET)soap->socket, &fd); + for (;;) + { register int r = select((SOAP_SOCKET)(soap->socket + 1), NULL, &fd, &fd, &timeout); + if (r > 0) + break; + if (!r) + { soap->errnum = 0; + return SOAP_EOF; + } + if (soap_socket_errno != SOAP_EINTR && soap_socket_errno != SOAP_EAGAIN) + { soap->errnum = soap_socket_errno; + return SOAP_EOF; + } + } + } +#endif +#ifdef WITH_OPENSSL + if (soap->ssl) + nwritten = SSL_write(soap->ssl, s, n); + else if (soap->bio) + nwritten = BIO_write(soap->bio, s, n); + else +#endif +#ifdef WITH_UDP + if ((soap->omode & SOAP_IO_UDP)) + { if (soap->peerlen) + nwritten = sendto((SOAP_SOCKET)soap->socket, s, n, soap->socket_flags, (struct sockaddr*)&soap->peer, soap->peerlen); + else + nwritten = send((SOAP_SOCKET)soap->socket, s, n, soap->socket_flags); + /* retry and back-off algorithm */ + /* TODO: this is not very clear from specs so verify and limit conditions under which we should loop (e.g. ENOBUFS) */ + if (nwritten < 0) + { struct timeval timeout; + fd_set fd; + int udp_repeat; + int udp_delay; +#ifndef WIN32 + if ((int)soap->socket > FD_SETSIZE) + return SOAP_FD_EXCEEDED; /* Hint: MUST increase FD_SETSIZE */ +#endif + if ((soap->connect_flags & SO_BROADCAST)) + udp_repeat = 3; /* SOAP-over-UDP MULTICAST_UDP_REPEAT - 1 */ + else + udp_repeat = 1; /* SOAP-over-UDP UNICAST_UDP_REPEAT - 1 */ + udp_delay = (soap_random % 201) + 50; /* UDP_MIN_DELAY .. UDP_MAX_DELAY */ + do + { timeout.tv_sec = 0; + timeout.tv_usec = 1000 * udp_delay; /* ms */ + FD_ZERO(&fd); + FD_SET((SOAP_SOCKET)soap->socket, &fd); + select((SOAP_SOCKET)(soap->socket + 1), NULL, NULL, &fd, &timeout); + if (soap->peerlen) + nwritten = sendto((SOAP_SOCKET)soap->socket, s, n, soap->socket_flags, (struct sockaddr*)&soap->peer, soap->peerlen); + else + nwritten = send((SOAP_SOCKET)soap->socket, s, n, soap->socket_flags); + udp_delay <<= 1; + if (udp_delay > 500) /* UDP_UPPER_DELAY */ + udp_delay = 500; + } + while (nwritten < 0 && --udp_repeat > 0); + } + } + else +#endif +#if !defined(PALM) && !defined(AS400) + nwritten = send((SOAP_SOCKET)soap->socket, s, n, soap->socket_flags); +#else + nwritten = send((SOAP_SOCKET)soap->socket, (void*)s, n, soap->socket_flags); +#endif + if (nwritten <= 0) + { +#ifdef WITH_OPENSSL + int err; + if (soap->ssl && (err = SSL_get_error(soap->ssl, nwritten)) != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE) + return SOAP_EOF; +#endif + if (soap_socket_errno != SOAP_EINTR && soap_socket_errno != SOAP_EWOULDBLOCK && soap_socket_errno != SOAP_EAGAIN) + { soap->errnum = soap_socket_errno; + return SOAP_EOF; + } + nwritten = 0; /* and call write() again */ + } + } + else + { +#ifdef WITH_FASTCGI + nwritten = fwrite((void*)s, 1, n, stdout); + fflush(stdout); +#else +#ifdef UNDER_CE + nwritten = fwrite(s, 1, n, soap->sendfd); +#else +#ifdef VXWORKS +#ifdef WMW_RPM_IO + if (soap->rpmreqid) + nwritten = (httpBlockPut(soap->rpmreqid, s, n) == 0) ? n : -1; + else +#endif + nwritten = fwrite(s, sizeof(char), n, fdopen(soap->sendfd, "w")); +#else + nwritten = write((SOAP_SOCKET)soap->sendfd, s, n); +#endif +#endif +#endif + if (nwritten <= 0) + { if (soap_errno != SOAP_EINTR && soap_errno != SOAP_EWOULDBLOCK && soap_errno != SOAP_EAGAIN) + { soap->errnum = soap_errno; + return SOAP_EOF; + } + nwritten = 0; /* and call write() again */ + } + } + n -= nwritten; + s += nwritten; + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_send_raw(struct soap *soap, const char *s, size_t n) +{ if (!n) + return SOAP_OK; + if (soap->mode & SOAP_IO_LENGTH) + { soap->count += n; +#ifndef WITH_LEANER + if (soap->fpreparesend && (soap->mode & SOAP_IO) != SOAP_IO_STORE) + return soap->error = soap->fpreparesend(soap, s, n); +#endif + return SOAP_OK; + } + if (soap->mode & SOAP_IO) + { register size_t i = SOAP_BUFLEN - soap->bufidx; + while (n >= i) + { memcpy(soap->buf + soap->bufidx, s, i); + soap->bufidx = SOAP_BUFLEN; + if (soap_flush(soap)) + return soap->error; + s += i; + n -= i; + i = SOAP_BUFLEN; + } + memcpy(soap->buf + soap->bufidx, s, n); + soap->bufidx += n; + return SOAP_OK; + } + return soap_flush_raw(soap, s, n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_flush(struct soap *soap) +{ register int n = soap->bufidx; + if (n) + { soap->bufidx = 0; +#ifdef WITH_ZLIB + if (soap->mode & SOAP_ENC_ZLIB) + { soap->d_stream.next_in = (Byte*)soap->buf; + soap->d_stream.avail_in = (unsigned int)n; +#ifdef WITH_GZIP + soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)n); +#endif + do + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating %u bytes\n", soap->d_stream.avail_in)); + if (deflate(&soap->d_stream, Z_NO_FLUSH) != Z_OK) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to deflate: %s\n", soap->d_stream.msg?soap->d_stream.msg:"")); + return soap->error = SOAP_ZLIB_ERROR; + } + if (!soap->d_stream.avail_out) + { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN)) + return soap->error; + soap->d_stream.next_out = (Byte*)soap->z_buf; + soap->d_stream.avail_out = SOAP_BUFLEN; + } + } while (soap->d_stream.avail_in); + } + else +#endif + return soap_flush_raw(soap, soap->buf, n); + } + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_flush_raw(struct soap *soap, const char *s, size_t n) +{ if ((soap->mode & SOAP_IO) == SOAP_IO_STORE) + { register char *t; + if (!(t = (char*)soap_push_block(soap, n))) + return soap->error = SOAP_EOM; + memcpy(t, s, n); +#ifndef WITH_LEANER + if (soap->fpreparesend) + return soap->error = soap->fpreparesend(soap, s, n); +#endif + return SOAP_OK; + } +#ifndef WITH_LEANER + if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) + { char t[16]; + sprintf(t, "\r\n%lX\r\n" + (soap->chunksize ? 0 : 2), (unsigned long)n); + DBGMSG(SENT, t, strlen(t)); + if ((soap->error = soap->fsend(soap, t, strlen(t)))) + return soap->error; + soap->chunksize += n; + } + DBGMSG(SENT, s, n); +#endif + return soap->error = soap->fsend(soap, s, n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_send(struct soap *soap, const char *s) +{ if (s) + return soap_send_raw(soap, s, strlen(s)); + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_send2(struct soap *soap, const char *s1, const char *s2) +{ if (soap_send(soap, s1)) + return soap->error; + return soap_send(soap, s2); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_send3(struct soap *soap, const char *s1, const char *s2, const char *s3) +{ if (soap_send(soap, s1) + || soap_send(soap, s2)) + return soap->error; + return soap_send(soap, s3); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static size_t +frecv(struct soap *soap, char *s, size_t n) +{ register int r; +#ifdef PALM + register int timeouts = 0; +#endif + soap->errnum = 0; +#if defined(__cplusplus) && !defined(WITH_LEAN) + if (soap->is) + { if (soap->is->good()) + return soap->is->read(s, n).gcount(); + return 0; + } +#endif + if (soap_valid_socket(soap->socket)) + { for (;;) + { +#ifndef WITH_LEAN + if (soap->recv_timeout) + { struct timeval timeout; + fd_set fd; + if (soap->recv_timeout > 0) + { timeout.tv_sec = soap->recv_timeout; + timeout.tv_usec = 0; + } + else + { timeout.tv_sec = -soap->recv_timeout/1000000; + timeout.tv_usec = -soap->recv_timeout%1000000; + } +#ifndef WIN32 + if ((int)soap->socket > FD_SETSIZE) + { soap->error = SOAP_FD_EXCEEDED; + return 0; /* Hint: MUST increase FD_SETSIZE */ + } +#endif + FD_ZERO(&fd); + FD_SET((SOAP_SOCKET)soap->socket, &fd); + for (;;) + { r = select((SOAP_SOCKET)(soap->socket + 1), &fd, NULL, &fd, &timeout); + if (r > 0) + break; + if (!r) + { soap->errnum = 0; + return 0; + } + if (soap_socket_errno != SOAP_EINTR && soap_socket_errno != SOAP_EAGAIN) + { soap->errnum = soap_socket_errno; + return 0; + } + } + } +#endif +#ifdef WITH_OPENSSL + if (soap->ssl) + { int err; + r = SSL_read(soap->ssl, s, n); + if (r > 0) + return (size_t)r; + err = SSL_get_error(soap->ssl, r); + if (err != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE) + return 0; + } + else if (soap->bio) + { r = BIO_read(soap->bio, s, n); + if (r > 0) + return (size_t)r; + return 0; + } + else +#endif + { +#ifdef WITH_UDP + if ((soap->omode & SOAP_IO_UDP)) + { SOAP_SOCKLEN_T k = (SOAP_SOCKLEN_T)sizeof(soap->peer); + memset((void*)&soap->peer, 0, sizeof(soap->peer)); + r = recvfrom((SOAP_SOCKET)soap->socket, s, n, soap->socket_flags, (struct sockaddr*)&soap->peer, &k); /* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */ + soap->peerlen = (size_t)k; +#ifndef WITH_IPV6 + soap->ip = ntohl(soap->peer.sin_addr.s_addr); +#endif + } + else +#endif + r = recv((SOAP_SOCKET)soap->socket, s, n, soap->socket_flags); +#ifdef PALM + /* CycleSyncDisplay(curStatusMsg); */ +#endif + if (r >= 0) + return (size_t)r; + if (soap_socket_errno != SOAP_EINTR && soap_socket_errno != SOAP_EAGAIN && soap_socket_errno != SOAP_EWOULDBLOCK) + { soap->errnum = soap_socket_errno; + return 0; + } + } +#ifndef WITH_LEAN + { struct timeval timeout; + fd_set fd; + timeout.tv_sec = 0; + timeout.tv_usec = 10000; +#ifndef WIN32 + if ((int)soap->socket > FD_SETSIZE) + { soap->error = SOAP_FD_EXCEEDED; + return 0; /* Hint: MUST increase FD_SETSIZE */ + } +#endif + FD_ZERO(&fd); + FD_SET((SOAP_SOCKET)soap->socket, &fd); +#ifdef WITH_OPENSSL + if (soap->ssl && SSL_get_error(soap->ssl, r) == SSL_ERROR_WANT_WRITE) + r = select((SOAP_SOCKET)(soap->socket + 1), NULL, &fd, &fd, &timeout); + else + r = select((SOAP_SOCKET)(soap->socket + 1), &fd, NULL, &fd, &timeout); +#else + r = select((SOAP_SOCKET)(soap->socket + 1), &fd, NULL, &fd, &timeout); +#endif + if (r < 0 && soap_socket_errno != SOAP_EINTR) + { soap->errnum = soap_socket_errno; + return 0; + } + } +#endif +#ifdef PALM + if (r < 0 && soap_socket_errno == SOAP_EINTR) + { timeouts++; + if (timeouts > 10) + { soap->errnum = soap_socket_errno; + return 0; + } + } +#endif + } + } +#ifdef WITH_FASTCGI + return fread(s, 1, n, stdin); +#else +#ifdef UNDER_CE + return fread(s, 1, n, soap->recvfd); +#else +#ifdef WMW_RPM_IO + if (soap->rpmreqid) + r = httpBlockRead(soap->rpmreqid, s, n); + else +#endif + r = read((SOAP_SOCKET)soap->recvfd, s, n); + if (r >= 0) + return (size_t)r; + soap->errnum = soap_errno; + return 0; +#endif +#endif +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static soap_wchar +soap_getchunkchar(struct soap *soap) +{ if (soap->bufidx < soap->buflen) + return soap->buf[soap->bufidx++]; + soap->bufidx = 0; + soap->buflen = soap->chunkbuflen = soap->frecv(soap, soap->buf, SOAP_BUFLEN); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes from socket %d\n", (unsigned int)soap->buflen, soap->socket)); + DBGMSG(RECV, soap->buf, soap->buflen); + if (soap->buflen) + return soap->buf[soap->bufidx++]; + return EOF; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +static int +soap_isxdigit(int c) +{ return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_recv_raw(struct soap *soap) +{ register size_t ret; +#ifdef WITH_ZLIB + if (soap->mode & SOAP_ENC_ZLIB) + { if (soap->d_stream.next_out == Z_NULL) + return EOF; + if (soap->d_stream.avail_in || !soap->d_stream.avail_out) + { register int r; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflating\n")); + soap->d_stream.next_out = (Byte*)soap->buf; + soap->d_stream.avail_out = SOAP_BUFLEN; + r = inflate(&soap->d_stream, Z_NO_FLUSH); + if (r == Z_OK || r == Z_STREAM_END) + { soap->bufidx = 0; + soap->buflen = SOAP_BUFLEN - soap->d_stream.avail_out; + if (soap->zlib_in == SOAP_ZLIB_GZIP) + soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)soap->buflen); + if (r == Z_STREAM_END) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %lu->%lu bytes\n", soap->d_stream.total_in, soap->d_stream.total_out)); + soap->z_ratio_in = (float)soap->d_stream.total_in / (float)soap->d_stream.total_out; + soap->d_stream.next_out = Z_NULL; + } + if (soap->buflen) + { soap->count += soap->buflen; + return SOAP_OK; + } + } + else if (r != Z_BUF_ERROR) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate error: %s\n", soap->d_stream.msg?soap->d_stream.msg:"")); + soap->d_stream.next_out = Z_NULL; + soap->error = SOAP_ZLIB_ERROR; + return EOF; + } + } +zlib_again: + if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK && !soap->chunksize) + { memcpy(soap->buf, soap->z_buf, SOAP_BUFLEN); + soap->buflen = soap->z_buflen; + } + } +#endif +#ifndef WITH_NOHTTP + if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) /* read HTTP chunked transfer */ + { +chunk_again: + if (soap->chunksize) + { soap->buflen = ret = soap->frecv(soap, soap->buf, soap->chunksize > SOAP_BUFLEN ? SOAP_BUFLEN : soap->chunksize); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk: read %u bytes\n", (unsigned int)ret)); + DBGMSG(RECV, soap->buf, ret); + soap->bufidx = 0; + soap->chunksize -= ret; + } + else + { register soap_wchar c; + char *t, tmp[8]; + t = tmp; + if (!soap->chunkbuflen) + { soap->chunkbuflen = ret = soap->frecv(soap, soap->buf, SOAP_BUFLEN); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes (chunked) from socket %d\n", (unsigned int)ret, soap->socket)); + DBGMSG(RECV, soap->buf, ret); + soap->bufidx = 0; + if (!ret) + return soap->ahead = EOF; + } + else + soap->bufidx = soap->buflen; + soap->buflen = soap->chunkbuflen; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Getting chunk size (idx=%u len=%u)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen)); + while (!soap_isxdigit((int)(c = soap_getchunkchar(soap)))) + if ((int)c == EOF) + return soap->ahead = EOF; + do + *t++ = (char)c; + while (soap_isxdigit((int)(c = soap_getchunkchar(soap))) && t - tmp < 7); + while ((int)c != EOF && c != '\n') + c = soap_getchunkchar(soap); + if ((int)c == EOF) + return soap->ahead = EOF; + *t = '\0'; + soap->chunksize = soap_strtoul(tmp, &t, 16); + if (!soap->chunksize) + { soap->chunkbuflen = 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of chunked message\n")); + while ((int)c != EOF && c != '\n') + c = soap_getchunkchar(soap); + return soap->ahead = EOF; + } + soap->buflen = soap->bufidx + soap->chunksize; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving buf len to idx=%u len=%u (%s)\n", (unsigned int)soap->bufidx, (unsigned int)soap->buflen, tmp)); + if (soap->buflen > soap->chunkbuflen) + { soap->buflen = soap->chunkbuflen; + soap->chunksize -= soap->buflen - soap->bufidx; + soap->chunkbuflen = 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Passed end of buffer for chunked HTTP (%u bytes left)\n", (unsigned int)(soap->buflen - soap->bufidx))); + } + else if (soap->chunkbuflen) + soap->chunksize = 0; + ret = soap->buflen - soap->bufidx; + if (!ret) + goto chunk_again; + } + } + else +#endif + { soap->bufidx = 0; + soap->buflen = ret = soap->frecv(soap, soap->buf, SOAP_BUFLEN); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Read %u bytes from socket %d\n", (unsigned int)ret, soap->socket)); + DBGMSG(RECV, soap->buf, ret); + } +#ifndef WITH_LEANER + if (soap->fpreparerecv && (soap->error = soap->fpreparerecv(soap, soap->buf, ret))) + return soap->error; +#endif +#ifdef WITH_ZLIB + if (soap->mode & SOAP_ENC_ZLIB) + { register int r; + memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN); + soap->d_stream.next_in = (Byte*)(soap->z_buf + soap->bufidx); + soap->d_stream.avail_in = (unsigned int)ret; + soap->d_stream.next_out = (Byte*)soap->buf; + soap->d_stream.avail_out = SOAP_BUFLEN; + r = inflate(&soap->d_stream, Z_NO_FLUSH); + if (r == Z_OK || r == Z_STREAM_END) + { soap->bufidx = 0; + soap->z_buflen = soap->buflen; + soap->buflen = ret = SOAP_BUFLEN - soap->d_stream.avail_out; + if (soap->zlib_in == SOAP_ZLIB_GZIP) + soap->z_crc = crc32(soap->z_crc, (Byte*)soap->buf, (unsigned int)soap->buflen); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %u bytes\n", (unsigned int)ret)); + if (!ret) + goto zlib_again; + if (r == Z_STREAM_END) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflated %lu->%lu bytes\n", soap->d_stream.total_in, soap->d_stream.total_out)); + soap->z_ratio_in = (float)soap->d_stream.total_in / (float)soap->d_stream.total_out; + soap->d_stream.next_out = Z_NULL; + } + } + else + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to inflate: (%d) %s\n", r, soap->d_stream.msg?soap->d_stream.msg:"")); + soap->d_stream.next_out = Z_NULL; + soap->error = SOAP_ZLIB_ERROR; + return EOF; + } + } +#endif + soap->count += ret; + return !ret; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_recv(struct soap *soap) +{ +#ifndef WITH_LEANER + if (soap->mode & SOAP_ENC_DIME) + { if (soap->dime.buflen) + { char *s; + int i; + unsigned char tmp[12]; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME hdr for chunked DIME is in buffer\n")); + soap->count += soap->dime.buflen - soap->buflen; + soap->buflen = soap->dime.buflen; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Skip padding (%ld bytes)\n", -(long)soap->dime.size&3)); + for (i = -(long)soap->dime.size&3; i > 0; i--) + { soap->bufidx++; + if (soap->bufidx >= soap->buflen) + if (soap_recv_raw(soap)) + return EOF; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME hdr for next chunk\n")); + s = (char*)tmp; + for (i = 12; i > 0; i--) + { *s++ = soap->buf[soap->bufidx++]; + if (soap->bufidx >= soap->buflen) + if (soap_recv_raw(soap)) + return EOF; + } + soap->dime.flags = tmp[0] & 0x7; + soap->dime.size = ((size_t)tmp[8] << 24) | ((size_t)tmp[9] << 16) | ((size_t)tmp[10] << 8) | ((size_t)tmp[11]); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME chunk (%u bytes)\n", (unsigned int)soap->dime.size)); + if (soap->dime.flags & SOAP_DIME_CF) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "More chunking\n")); + soap->dime.chunksize = soap->dime.size; + if (soap->buflen - soap->bufidx >= soap->dime.size) + { soap->dime.buflen = soap->buflen; + soap->buflen = soap->bufidx + soap->dime.chunksize; + } + else + soap->dime.chunksize -= soap->buflen - soap->bufidx; + } + else + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Last chunk\n")); + soap->dime.buflen = 0; + soap->dime.chunksize = 0; + } + soap->count = soap->buflen - soap->bufidx; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%u bytes remaining\n", (unsigned int)soap->count)); + return SOAP_OK; + } + if (soap->dime.chunksize) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get next DIME hdr for chunked DIME (%u bytes chunk)\n", (unsigned int)soap->dime.chunksize)); + if (soap_recv_raw(soap)) + return EOF; + if (soap->buflen - soap->bufidx >= soap->dime.chunksize) + { soap->dime.buflen = soap->buflen; + soap->count -= soap->buflen - soap->bufidx - soap->dime.chunksize; + soap->buflen = soap->bufidx + soap->dime.chunksize; + } + else + soap->dime.chunksize -= soap->buflen - soap->bufidx; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%lu bytes remaining, count=%u\n", (unsigned long)(soap->buflen-soap->bufidx), (unsigned int)soap->count)); + return SOAP_OK; + } + } +#endif + return soap_recv_raw(soap); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +soap_wchar +SOAP_FMAC2 +soap_getchar(struct soap *soap) +{ register soap_wchar c; + c = soap->ahead; + if (c) + { if (c != EOF) + soap->ahead = 0; + return c; + } + return soap_get1(soap); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +const struct soap_code_map* +SOAP_FMAC2 +soap_code(const struct soap_code_map *map, const char *str) +{ if (map && str) + { while (map->string) + { if (!strcmp(str, map->string)) /* case sensitive */ + return map; + map++; + } + } + return NULL; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +long +SOAP_FMAC2 +soap_code_int(const struct soap_code_map *map, const char *str, long other) +{ if (map) + { while (map->string) + { if (!soap_tag_cmp(str, map->string)) /* case insensitive */ + return map->code; + map++; + } + } + return other; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_code_str(const struct soap_code_map *map, long code) +{ if (!map) + return NULL; + while (map->code != code && map->string) + map++; + return map->string; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +long +SOAP_FMAC2 +soap_code_bits(const struct soap_code_map *map, const char *str) +{ register long bits = 0; + if (map) + { while (str && *str) + { const struct soap_code_map *p; + for (p = map; p->string; p++) + { register size_t n = strlen(p->string); + if (!strncmp(p->string, str, n) && soap_blank(str[n])) + { bits |= p->code; + str += n; + while (*str > 0 && *str <= 32) + str++; + break; + } + } + if (!p->string) + return 0; + } + } + return bits; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_code_list(struct soap *soap, const struct soap_code_map *map, long code) +{ register char *t = soap->tmpbuf; + if (map) + { while (map->string) + { if (map->code & code) + { register const char *s = map->string; + if (t != soap->tmpbuf) + *t++ = ' '; + while (*s && t < soap->tmpbuf + sizeof(soap->tmpbuf) - 1) + *t++ = *s++; + if (t == soap->tmpbuf + sizeof(soap->tmpbuf) - 1) + break; + } + map++; + } + } + *t = '\0'; + return soap->tmpbuf; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +static soap_wchar +soap_char(struct soap *soap) +{ char tmp[8]; + register int i; + register soap_wchar c; + register char *s = tmp; + for (i = 0; i < 7; i++) + { c = soap_get1(soap); + if (c == ';' || (int)c == EOF) + break; + *s++ = (char)c; + } + *s = '\0'; + if (*tmp == '#') + { if (tmp[1] == 'x' || tmp[1] == 'X') + return soap_strtol(tmp + 2, NULL, 16); + return atol(tmp + 1); + } + if (!strcmp(tmp, "lt")) + return '<'; + if (!strcmp(tmp, "gt")) + return '>'; + if (!strcmp(tmp, "amp")) + return '&'; + if (!strcmp(tmp, "quot")) + return '"'; + if (!strcmp(tmp, "apos")) + return '\''; +#ifndef WITH_LEAN + return (soap_wchar)soap_code_int(html_entity_codes, tmp, SOAP_UNKNOWN_CHAR); +#else + return SOAP_UNKNOWN_CHAR; /* use this to represent unknown code */ +#endif +} +#endif + +/******************************************************************************/ +#ifdef WITH_LEAN +#ifndef PALM_1 +soap_wchar +soap_get0(struct soap *soap) +{ if (soap->bufidx >= soap->buflen && soap_recv(soap)) + return EOF; + return (unsigned char)soap->buf[soap->bufidx]; +} +#endif +#endif + +/******************************************************************************/ +#ifdef WITH_LEAN +#ifndef PALM_1 +soap_wchar +soap_get1(struct soap *soap) +{ if (soap->bufidx >= soap->buflen && soap_recv(soap)) + return EOF; + return (unsigned char)soap->buf[soap->bufidx++]; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +soap_wchar +SOAP_FMAC2 +soap_get(struct soap *soap) +{ register soap_wchar c; + c = soap->ahead; + if (c) + { if ((int)c != EOF) + soap->ahead = 0; + } + else + c = soap_get1(soap); + while ((int)c != EOF) + { if (soap->cdata) + { if (c == ']') + { c = soap_get1(soap); + if (c == ']') + { c = soap_get0(soap); + if (c == '>') + { soap->cdata = 0; + soap_get1(soap); + c = soap_get1(soap); + } + else + { soap_unget(soap, ']'); + return ']'; + } + } + else + { soap_revget1(soap); + return ']'; + } + } + else + return c; + } + switch (c) + { case '<': + do c = soap_get1(soap); + while (soap_blank(c)); + if (c == '!' || c == '?' || c == '%') + { register int k = 1; + if (c == '!') + { c = soap_get1(soap); + if (c == '[') + { do c = soap_get1(soap); + while ((int)c != EOF && c != '['); + if ((int)c == EOF) + break; + soap->cdata = 1; + c = soap_get1(soap); + continue; + } + if (c == '-' && (c = soap_get1(soap)) == '-') + { do + { c = soap_get1(soap); + if (c == '-' && (c = soap_get1(soap)) == '-') + break; + } while ((int)c != EOF); + } + } + else if (c == '?') + c = soap_get_pi(soap); + while ((int)c != EOF) + { if (c == '<') + k++; + else if (c == '>') + { if (--k <= 0) + break; + } + c = soap_get1(soap); + } + if ((int)c == EOF) + break; + c = soap_get1(soap); + continue; + } + if (c == '/') + return SOAP_TT; + soap_revget1(soap); + return SOAP_LT; + case '>': + return SOAP_GT; + case '"': + return SOAP_QT; + case '\'': + return SOAP_AP; + case '&': + return soap_char(soap) | 0x80000000; + } + break; + } + return c; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +static soap_wchar +soap_get_pi(struct soap *soap) +{ char buf[64]; + register char *s = buf; + register int i = sizeof(buf); + register soap_wchar c = soap_getchar(soap); + /* This is a quick way to parse XML PI and we could use a callback instead to + * enable applications to intercept processing instructions */ + while ((int)c != EOF && c != '?') + { if (--i > 0) + { if (soap_blank(c)) + c = ' '; + *s++ = (char)c; + } + c = soap_getchar(soap); + } + *s = '\0'; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "XML PI \n", buf)); + if (!strncmp(buf, "xml ", 4)) + { s = strstr(buf, " encoding="); + if (s && s[10]) + { if (!soap_tag_cmp(s + 11, "iso-8859-1*") + || !soap_tag_cmp(s + 11, "latin1*")) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Switching to latin1 encoding\n")); + soap->mode |= SOAP_ENC_LATIN; + } + else if (!soap_tag_cmp(s + 11, "utf-8*")) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Switching to utf-8 encoding\n")); + soap->mode &= ~SOAP_ENC_LATIN; + } + } + } + if ((int)c != EOF) + c = soap_getchar(soap); + return c; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_move(struct soap *soap, long n) +{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Moving %ld bytes forward\n", (long)n)); + for (; n > 0; n--) + if ((int)soap_getchar(soap) == EOF) + return SOAP_EOF; + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +size_t +SOAP_FMAC2 +soap_tell(struct soap *soap) +{ return soap->count - soap->buflen + soap->bufidx - (soap->ahead != 0); +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_pututf8(struct soap *soap, register unsigned long c) +{ char tmp[16]; + if (c > 0 && c < 0x80) + { *tmp = (char)c; + return soap_send_raw(soap, tmp, 1); + } +#ifndef WITH_LEAN + if (soap->mode & SOAP_XML_CANONICAL) + { register char *t = tmp; + if (c < 0x0800) + *t++ = (char)(0xC0 | ((c >> 6) & 0x1F)); + else + { if (c < 0x010000) + *t++ = (char)(0xE0 | ((c >> 12) & 0x0F)); + else + { if (c < 0x200000) + *t++ = (char)(0xF0 | ((c >> 18) & 0x07)); + else + { if (c < 0x04000000) + *t++ = (char)(0xF8 | ((c >> 24) & 0x03)); + else + { *t++ = (char)(0xFC | ((c >> 30) & 0x01)); + *t++ = (char)(0x80 | ((c >> 24) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 18) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 12) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 6) & 0x3F)); + } + *t++ = (char)(0x80 | (c & 0x3F)); + *t = '\0'; + } + else +#endif + sprintf(tmp, "&#%lu;", c); + return soap_send(soap, tmp); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +soap_wchar +SOAP_FMAC2 +soap_getutf8(struct soap *soap) +{ register soap_wchar c, c1, c2, c3, c4; + c = soap->ahead; + if (c > 0xFF) + { soap->ahead = 0; + return c; + } +again: + c = soap_get(soap); + if (c < 0x80 || (soap->mode & SOAP_ENC_LATIN)) + return c; + c1 = soap_get1(soap); + if (c1 < 0x80) + { soap_revget1(soap); /* doesn't look like this is UTF8 */ + return c; + } + c1 &= 0x3F; + if (c < 0xE0) + return ((soap_wchar)(c & 0x1F) << 6) | c1; + c2 = (soap_wchar)soap_get1(soap) & 0x3F; + if (c == 0xEF && c1 == 0x3B && c2 == 0x3F) /* ignore UTF-8 BOM */ + goto again; + if (c < 0xF0) + return ((soap_wchar)(c & 0x0F) << 12) | (c1 << 6) | c2; + c3 = (soap_wchar)soap_get1(soap) & 0x3F; + if (c < 0xF8) + return ((soap_wchar)(c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3; + c4 = (soap_wchar)soap_get1(soap) & 0x3F; + if (c < 0xFC) + return ((soap_wchar)(c & 0x03) << 24) | (c1 << 18) | (c2 << 12) | (c3 << 6) | c4; + return ((soap_wchar)(c & 0x01) << 30) | (c1 << 24) | (c2 << 18) | (c3 << 12) | (c4 << 6) | (soap_wchar)(soap_get1(soap) & 0x3F); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_puthex(struct soap *soap, const unsigned char *s, int n) +{ char d[2]; + register int i; +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { if (!(soap->dom->data = soap_s2hex(soap, s, NULL, n))) + return soap->error; + return SOAP_OK; + } +#endif + for (i = 0; i < n; i++) + { register int m = *s++; + d[0] = (char)((m >> 4) + (m > 159 ? '7' : '0')); + m &= 0x0F; + d[1] = (char)(m + (m > 9 ? '7' : '0')); + if (soap_send_raw(soap, d, 2)) + return soap->error; + } + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +unsigned char* +SOAP_FMAC2 +soap_gethex(struct soap *soap, int *n) +{ +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { soap->dom->data = soap_string_in(soap, 0, -1, -1); + return (unsigned char*)soap_hex2s(soap, soap->dom->data, NULL, 0, n); + } +#endif +#ifdef WITH_FAST + soap->labidx = 0; + for (;;) + { register char *s; + register int i, k; + if (soap_append_lab(soap, NULL, 0)) + return NULL; + s = soap->labbuf + soap->labidx; + k = soap->lablen - soap->labidx; + soap->labidx = soap->lablen; + for (i = 0; i < k; i++) + { register char d1, d2; + register soap_wchar c; + c = soap_get(soap); + if (soap_isxdigit(c)) + { d1 = (char)c; + c = soap_get(soap); + if (soap_isxdigit(c)) + d2 = (char)c; + else + { soap->error = SOAP_TYPE; + return NULL; + } + } + else + { unsigned char *p; + soap_unget(soap, c); + if (n) + *n = (int)(soap->lablen - k + i); + p = (unsigned char*)soap_malloc(soap, soap->lablen - k + i); + if (p) + memcpy(p, soap->labbuf, soap->lablen - k + i); + return p; + } + *s++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0'); + } + } +#else + if (soap_new_block(soap)) + return NULL; + for (;;) + { register int i; + register char *s = (char*)soap_push_block(soap, SOAP_BLKLEN); + if (!s) + { soap_end_block(soap); + return NULL; + } + for (i = 0; i < SOAP_BLKLEN; i++) + { register char d1, d2; + register soap_wchar c = soap_get(soap); + if (soap_isxdigit(c)) + { d1 = (char)c; + c = soap_get(soap); + if (soap_isxdigit(c)) + d2 = (char)c; + else + { soap_end_block(soap); + soap->error = SOAP_TYPE; + return NULL; + } + } + else + { unsigned char *p; + soap_unget(soap, c); + if (n) + *n = soap_size_block(soap, i); + p = (unsigned char*)soap_save_block(soap, NULL, 0); + return p; + } + *s++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0'); + } + } +#endif +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_putbase64(struct soap *soap, const unsigned char *s, int n) +{ register int i; + register unsigned long m; + char d[4]; + if (!s) + return SOAP_OK; +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { if (!(soap->dom->data = soap_s2base64(soap, s, NULL, n))) + return soap->error; + return SOAP_OK; + } +#endif + for (; n > 2; n -= 3, s += 3) + { m = s[0]; + m = (m << 8) | s[1]; + m = (m << 8) | s[2]; + for (i = 4; i > 0; m >>= 6) + d[--i] = soap_base64o[m & 0x3F]; + if (soap_send_raw(soap, d, 4)) + return soap->error; + } + if (n > 0) + { m = 0; + for (i = 0; i < n; i++) + m = (m << 8) | *s++; + for (; i < 3; i++) + m <<= 8; + for (i++; i > 0; m >>= 6) + d[--i] = soap_base64o[m & 0x3F]; + for (i = 3; i > n; i--) + d[i] = '='; + if (soap_send_raw(soap, d, 4)) + return soap->error; + } + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +unsigned char* +SOAP_FMAC2 +soap_getbase64(struct soap *soap, int *n, int malloc_flag) +{ +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { soap->dom->data = soap_string_in(soap, 0, -1, -1); + return (unsigned char*)soap_base642s(soap, soap->dom->data, NULL, 0, n); + } +#endif +#ifdef WITH_FAST + soap->labidx = 0; + for (;;) + { register int i, k; + register char *s; + if (soap_append_lab(soap, NULL, 2)) + return NULL; + s = soap->labbuf + soap->labidx; + k = soap->lablen - soap->labidx; + soap->labidx = 3 * (soap->lablen / 3); + if (!s) + return NULL; + for (i = 0; i < k - 2; i += 3) + { register unsigned long m = 0; + register int j = 0; + do + { register soap_wchar c = soap_get(soap); + if (c == '=' || c < 0) + { unsigned char *p; + switch (j) + { case 2: + *s++ = (char)((m >> 4) & 0xFF); + i++; + break; + case 3: + *s++ = (char)((m >> 10) & 0xFF); + *s++ = (char)((m >> 2) & 0xFF); + i += 2; + } + if (n) + *n = (int)(soap->lablen - k + i); + p = (unsigned char*)soap_malloc(soap, soap->lablen - k + i); + if (p) + memcpy(p, soap->labbuf, soap->lablen - k + i); + if (c >= 0) + { while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT) + ; + } + soap_unget(soap, c); + return p; + } + c -= '+'; + if (c >= 0 && c <= 79) + { m = (m << 6) + soap_base64i[c]; + j++; + } + } while (j < 4); + *s++ = (char)((m >> 16) & 0xFF); + *s++ = (char)((m >> 8) & 0xFF); + *s++ = (char)(m & 0xFF); + } + } +#else + if (soap_new_block(soap)) + return NULL; + for (;;) + { register int i; + register char *s = (char*)soap_push_block(soap, 3 * SOAP_BLKLEN); /* must be multiple of 3 */ + if (!s) + { soap_end_block(soap); + return NULL; + } + for (i = 0; i < SOAP_BLKLEN; i++) + { register unsigned long m = 0; + register int j = 0; + do + { register soap_wchar c = soap_get(soap); + if (c == '=' || c < 0) + { unsigned char *p; + i *= 3; + switch (j) + { case 2: + *s++ = (char)((m >> 4) & 0xFF); + i++; + break; + case 3: + *s++ = (char)((m >> 10) & 0xFF); + *s++ = (char)((m >> 2) & 0xFF); + i += 2; + } + if (n) + *n = (int)soap_size_block(soap, i); + p = (unsigned char*)soap_save_block(soap, NULL, 0); + if (c >= 0) + { while ((int)((c = soap_get(soap)) != EOF) && c != SOAP_LT && c != SOAP_TT) + ; + } + soap_unget(soap, c); + return p; + } + c -= '+'; + if (c >= 0 && c <= 79) + { m = (m << 6) + soap_base64i[c]; + j++; + } + } while (j < 4); + *s++ = (char)((m >> 16) & 0xFF); + *s++ = (char)((m >> 8) & 0xFF); + *s++ = (char)(m & 0xFF); + } + } +#endif +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_xop_forward(struct soap *soap, unsigned char **ptr, int *size, char **id, char **type, char **options) +{ /* Check MTOM xop:Include element (within hex/base64Binary) */ + /* TODO: this code to be obsoleted with new import/xop.h conventions */ + int body = soap->body; /* should save type too? */ + if (!soap_peek_element(soap)) + { if (!soap_element_begin_in(soap, "xop:Include", 0, NULL) && *soap->href) + { if (soap_dime_forward(soap, ptr, size, id, type, options)) + return soap->error; + } + if (soap->body && soap_element_end_in(soap, NULL)) + return soap->error; + } + soap->body = body; + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_dime_forward(struct soap *soap, unsigned char **ptr, int *size, char **id, char **type, char **options) +{ struct soap_xlist *xp = (struct soap_xlist*)SOAP_MALLOC(soap, sizeof(struct soap_xlist)); + *ptr = NULL; + *size = 0; + *id = soap_strdup(soap, soap->href); + *type = NULL; + *options = NULL; + if (!xp) + return soap->error = SOAP_EOM; + xp->next = soap->xlist; + xp->ptr = ptr; + xp->size = size; + xp->id = *id; + xp->type = type; + xp->options = options; + soap->xlist = xp; + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_strdup(struct soap *soap, const char *s) +{ char *t = NULL; + if (s && (t = (char*)soap_malloc(soap, strlen(s) + 1))) + strcpy(t, s); + return t; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_new_block(struct soap *soap) +{ struct soap_blist *p; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New block sequence (prev=%p)\n", soap->blist)); + if (!(p = (struct soap_blist*)SOAP_MALLOC(soap, sizeof(struct soap_blist)))) + return SOAP_EOM; + p->next = soap->blist; + p->ptr = NULL; + p->size = 0; + soap->blist = p; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void* +SOAP_FMAC2 +soap_push_block(struct soap *soap, size_t n) +{ char *p; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push block of %u bytes (%u bytes total)\n", (unsigned int)n, (unsigned int)soap->blist->size + (unsigned int)n)); + if (!(p = (char*)SOAP_MALLOC(soap, n + sizeof(char*) + sizeof(size_t)))) + { soap->error = SOAP_EOM; + return NULL; + } + *(char**)p = soap->blist->ptr; + *(size_t*)(p + sizeof(char*)) = n; + soap->blist->ptr = p; + soap->blist->size += n; + return p + sizeof(char*) + sizeof(size_t); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_pop_block(struct soap *soap) +{ char *p; + if (!soap->blist->ptr) + return; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pop block\n")); + p = soap->blist->ptr; + soap->blist->size -= *(size_t*)(p + sizeof(char*)); + soap->blist->ptr = *(char**)p; + SOAP_FREE(soap, p); +} +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_1 +static void +soap_update_ptrs(struct soap *soap, char *start, char *end, char *p1, char *p2) +{ int i; + register struct soap_ilist *ip; + register struct soap_flist *fp; +#ifndef WITH_LEANER + register struct soap_xlist *xp; +#endif + register void *p, **q; + for (i = 0; i < SOAP_IDHASH; i++) + { for (ip = soap->iht[i]; ip; ip = ip->next) + { if (ip->ptr && (char*)ip->ptr >= start && (char*)ip->ptr < end) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update id='%s' %p -> %p\n", ip->id, ip->ptr, (char*)ip->ptr + (p1-p2))); + ip->ptr = (char*)ip->ptr + (p1-p2); + } + for (q = &ip->link; q; q = (void**)p) + { p = *q; + if (p && (char*)p >= start && (char*)p < end) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Link update id='%s' %p\n", ip->id, p)); + *q = (char*)p + (p1-p2); + } + } + for (q = &ip->copy; q; q = (void**)p) + { p = *q; + if (p && (char*)p >= start && (char*)p < end) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy chain update id='%s' %p\n", ip->id, p)); + *q = (char*)p + (p1-p2); + } + } + for (fp = ip->flist; fp; fp = fp->next) + { if ((char*)fp->ptr >= start && (char*)fp->ptr < end) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy list update id='%s' %p\n", ip->id, fp)); + fp->ptr = (char*)fp->ptr + (p1-p2); + } + } + } + } +#ifndef WITH_LEANER + for (xp = soap->xlist; xp; xp = xp->next) + { if (xp->ptr && (char*)xp->ptr >= start && (char*)xp->ptr < end) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update id='%s' %p -> %p\n", xp->id?xp->id:"", xp->ptr, (char*)xp->ptr + (p1-p2))); + xp->ptr = (unsigned char**)((char*)xp->ptr + (p1-p2)); + xp->size = (int*)((char*)xp->size + (p1-p2)); + xp->type = (char**)((char*)xp->type + (p1-p2)); + xp->options = (char**)((char*)xp->options + (p1-p2)); + } + } +#endif +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_1 +static int +soap_has_copies(struct soap *soap, register const char *start, register const char *end) +{ register int i; + register struct soap_ilist *ip; + register struct soap_flist *fp; + register const char *p; + for (i = 0; i < SOAP_IDHASH; i++) + { for (ip = soap->iht[i]; ip; ip = ip->next) + { for (p = (const char*)ip->copy; p; p = *(const char**)p) + if (p >= start && p < end) + return SOAP_ERR; + for (fp = ip->flist; fp; fp = fp->next) + if ((const char*)fp->ptr >= start && (const char*)fp->ptr < end) + return SOAP_ERR; + } + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_resolve(struct soap *soap) +{ register int i; + register struct soap_ilist *ip; + register struct soap_flist *fp; + short flag; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving forwarded data\n")); + for (i = 0; i < SOAP_IDHASH; i++) + { for (ip = soap->iht[i]; ip; ip = ip->next) + { if (ip->ptr) + { register void *p, **q, *r; + q = (void**)ip->link; + ip->link = NULL; + r = ip->ptr; + DBGLOG(TEST, if (q) SOAP_MESSAGE(fdebug, "Traversing link chain to resolve id='%s'\n", ip->id)); + while (q) + { p = *q; + *q = r; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "... link %p -> %p\n", q, r)); + q = (void**)p; + } + } + else if (*ip->id == '#') + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Missing data for id='%s'\n", ip->id)); + strcpy(soap->id, ip->id + 1); + return soap->error = SOAP_MISSING_ID; + } + } + } + do + { flag = 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution phase\n")); + for (i = 0; i < SOAP_IDHASH; i++) + { for (ip = soap->iht[i]; ip; ip = ip->next) + { if (ip->ptr && !soap_has_copies(soap, (const char*)ip->ptr, (const char*)ip->ptr + ip->size)) + { if (ip->copy) + { register void *p, **q = (void**)ip->copy; + DBGLOG(TEST, if (q) SOAP_MESSAGE(fdebug, "Traversing copy chain to resolve id='%s'\n", ip->id)); + ip->copy = NULL; + do + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... copy %p -> %p (%u bytes)\n", ip->ptr, q, (unsigned int)ip->size)); + p = *q; + memcpy(q, ip->ptr, ip->size); + q = (void**)p; + } while (q); + flag = 1; + } + for (fp = ip->flist; fp; fp = ip->flist) + { register unsigned int k = fp->level; + register void *p = ip->ptr; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving forwarded data type=%d location=%p level=%u,%u id='%s'\n", ip->type, p, ip->level, fp->level, ip->id)); + while (ip->level < k) + { register void **q = (void**)soap_malloc(soap, sizeof(void*)); + if (!q) + return soap->error; + *q = p; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level, new location=%p holds=%p...\n", q, *q)); + p = (void*)q; + k--; + } + if (fp->fcopy) + fp->fcopy(soap, ip->type, fp->type, fp->ptr, fp->len, p, ip->size); + else + soap_fcopy(soap, ip->type, fp->type, fp->ptr, fp->len, p, ip->size); + ip->flist = fp->next; + SOAP_FREE(soap, fp); + flag = 1; + } + } + } + } + } while (flag); +#ifdef SOAP_DEBUG + for (i = 0; i < SOAP_IDHASH; i++) + { for (ip = soap->iht[i]; ip; ip = ip->next) + { if (ip->copy || ip->flist) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution error: forwarded data for id='%s' could not be propagated, please report this problem to the developers\n", ip->id)); + } + } + } +#endif + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolution done\n")); + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +size_t +SOAP_FMAC2 +soap_size_block(struct soap *soap, size_t n) +{ if (soap->blist->ptr) + { soap->blist->size -= *(size_t*)(soap->blist->ptr + sizeof(char*)) - n; + *(size_t*)(soap->blist->ptr + sizeof(char*)) = n; + } + return soap->blist->size; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +char* +SOAP_FMAC2 +soap_first_block(struct soap *soap) +{ char *p, *q, *r; + p = soap->blist->ptr; + if (!p) + return NULL; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "First block\n")); + r = NULL; + do + { q = *(char**)p; + *(char**)p = r; + r = p; + p = q; + } while (p); + soap->blist->ptr = r; + return r + sizeof(char*) + sizeof(size_t); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +char* +SOAP_FMAC2 +soap_next_block(struct soap *soap) +{ char *p; + p = soap->blist->ptr; + if (p) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Next block\n")); + soap->blist->ptr = *(char**)p; + SOAP_FREE(soap, p); + if (soap->blist->ptr) + return soap->blist->ptr + sizeof(char*) + sizeof(size_t); + } + return NULL; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +size_t +SOAP_FMAC2 +soap_block_size(struct soap *soap) +{ return *(size_t*)(soap->blist->ptr + sizeof(char*)); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_end_block(struct soap *soap) +{ struct soap_blist *bp; + char *p, *q; + bp = soap->blist; + if (bp) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of block sequence, free all remaining blocks\n")); + for (p = bp->ptr; p; p = q) + { q = *(char**)p; + SOAP_FREE(soap, p); + } + soap->blist = bp->next; + SOAP_FREE(soap, bp); + } + DBGLOG(TEST, if (soap->blist) SOAP_MESSAGE(fdebug, "Restore previous block sequence\n")); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +char* +SOAP_FMAC2 +soap_save_block(struct soap *soap, char *p, int flag) +{ register size_t n; + register char *q, *s; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Save all blocks in contiguous memory space of %u bytes (%p->%p)\n", (unsigned int)soap->blist->size, soap->blist->ptr, p)); + if (soap->blist->size) + { if (!p) + p = (char*)soap_malloc(soap, soap->blist->size); + if (p) + { for (s = p, q = soap_first_block(soap); q; q = soap_next_block(soap)) + { n = soap_block_size(soap); +#ifndef WITH_NOIDREF + if (flag) + soap_update_ptrs(soap, q, q + n, s, q); +#endif + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copy %u bytes from %p to %p\n", (unsigned int)n, q, s)); + memcpy(s, q, n); + s += n; + } + } + else + soap->error = SOAP_EOM; + } + soap_end_block(soap); + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_putsize(struct soap *soap, const char *type, int size) +{ return soap_putsizes(soap, type, &size, 1); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_putsizes(struct soap *soap, const char *type, const int *size, int dim) +{ return soap_putsizesoffsets(soap, type, size, NULL, dim); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_putsizesoffsets(struct soap *soap, const char *type, const int *size, const int *offset, int dim) +{ int i; + if (!type) + return NULL; + if (soap->version == 2) + { sprintf(soap->type, "%s[%d", type, size[0]); + for (i = 1; i < dim; i++) + sprintf(soap->type + strlen(soap->type), " %d", size[i]); + } + else + { if (offset) + { sprintf(soap->type, "%s[%d", type, size[0] + offset[0]); + for (i = 1; i < dim; i++) + sprintf(soap->type + strlen(soap->type), ",%d", size[i] + offset[i]); + } + else + { sprintf(soap->type, "%s[%d", type, size[0]); + for (i = 1; i < dim; i++) + sprintf(soap->type + strlen(soap->type), ",%d", size[i]); + } + strcat(soap->type, "]"); + } + return soap->type; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_putoffset(struct soap *soap, int offset) +{ return soap_putoffsets(soap, &offset, 1); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_putoffsets(struct soap *soap, const int *offset, int dim) +{ register int i; + sprintf(soap->arrayOffset, "[%d", offset[0]); + for (i = 1; i < dim; i++) + sprintf(soap->arrayOffset + strlen(soap->arrayOffset), ",%d", offset[i]); + strcat(soap->arrayOffset, "]"); + return soap->arrayOffset; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_size(const int *size, int dim) +{ register int i, n = size[0]; + for (i = 1; i < dim; i++) + n *= size[i]; + return n; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getoffsets(const char *attr, const int *size, int *offset, int dim) +{ register int i, j = 0; + if (offset) + for (i = 0; i < dim && attr && *attr; i++) + { attr++; + j *= size[i]; + j += offset[i] = (int)atol(attr); + attr = strchr(attr, ','); + } + else + for (i = 0; i < dim && attr && *attr; i++) + { attr++; + j *= size[i]; + j += (int)atol(attr); + attr = strchr(attr, ','); + } + return j; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getsize(const char *attr1, const char *attr2, int *j) +{ register int n, k; + char *s; + *j = 0; + if (!*attr1) + return -1; + if (*attr1 == '[') + attr1++; + n = 1; + for (;;) + { k = (int)soap_strtol(attr1, &s, 10); + n *= k; + if (k < 0 || n > SOAP_MAXARRAYSIZE || s == attr1) + return -1; + attr1 = strchr(s, ','); + if (!attr1) + attr1 = strchr(s, ' '); + if (attr2 && *attr2) + { attr2++; + *j *= k; + k = (int)soap_strtol(attr2, &s, 10); + *j += k; + if (k < 0) + return -1; + attr2 = s; + } + if (!attr1) + break; + attr1++; + } + return n - *j; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getsizes(const char *attr, int *size, int dim) +{ register int i, k, n; + if (!*attr) + return -1; + i = strlen(attr); + n = 1; + do + { for (i = i-1; i >= 0; i--) + if (attr[i] == '[' || attr[i] == ',' || attr[i] == ' ') + break; + k = (int)atol(attr + i + 1); + n *= size[--dim] = k; + if (k < 0 || n > SOAP_MAXARRAYSIZE) + return -1; + } while (i >= 0 && attr[i] != '['); + return n; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getposition(const char *attr, int *pos) +{ register int i, n; + if (!*attr) + return -1; + n = 0; + i = 1; + do + { pos[n++] = (int)atol(attr + i); + while (attr[i] && attr[i] != ',' && attr[i] != ']') + i++; + if (attr[i] == ',') + i++; + } while (n < SOAP_MAXDIMS && attr[i] && attr[i] != ']'); + return n; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_push_namespace(struct soap *soap, const char *id, const char *ns) +{ register struct soap_nlist *np; + register struct Namespace *p; + register short i = -1; + register size_t n, k; + n = strlen(id); + k = strlen(ns) + 1; + p = soap->local_namespaces; + if (p) + { for (i = 0; p->id; p++, i++) + { if (p->ns && !strcmp(ns, p->ns)) + { if (p->out) + { SOAP_FREE(soap, p->out); + p->out = NULL; + } + break; + } + if (p->out) + { if (!strcmp(ns, p->out)) + break; + } + else if (p->in) + { if (!soap_tag_cmp(ns, p->in)) + { if ((p->out = (char*)SOAP_MALLOC(soap, k))) + strcpy(p->out, ns); + break; + } + } + } + if (!p || !p->id) + i = -1; + } + if (i >= 0) + k = 0; + np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k); + if (!np) + return soap->error = SOAP_EOM; + np->next = soap->nlist; + soap->nlist = np; + np->level = soap->level; + np->index = i; + strcpy(np->id, id); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push namespace binding (level=%u) '%s' '%s'\n", soap->level, id, ns)); + if (i < 0) + { np->ns = np->id + n + 1; + strcpy(np->ns, ns); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push NOT OK: no match found for '%s' in namespace mapping table (added to stack anyway)\n", ns)); + } + else + { np->ns = NULL; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push OK ('%s' matches '%s' in namespace table)\n", id, p->id)); + } + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_pop_namespace(struct soap *soap) +{ register struct soap_nlist *np; + while (soap->nlist && soap->nlist->level >= soap->level) + { np = soap->nlist->next; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Popped namespace binding (level=%u) '%s'\n", soap->level, soap->nlist->id)); + SOAP_FREE(soap, soap->nlist); + soap->nlist = np; + } +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_match_namespace(struct soap *soap, const char *id1, const char *id2, int n1, int n2) +{ register struct soap_nlist *np = soap->nlist; + while (np && (strncmp(np->id, id1, n1) || np->id[n1])) + np = np->next; + if (np) + { if (np->index < 0 + || (soap->local_namespaces[np->index].id + && (strncmp(soap->local_namespaces[np->index].id, id2, n2) + || soap->local_namespaces[np->index].id[n2]))) + return SOAP_NAMESPACE; + return SOAP_OK; + } + if (n1 == 3 && n1 == n2 && !strcmp(id1, "xml") && !strcmp(id1, id2)) + return SOAP_OK; + return SOAP_SYNTAX_ERROR; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_current_namespace(struct soap *soap, const char *tag) +{ register struct soap_nlist *np; + register const char *s; + np = soap->nlist; + if (!(s = strchr(tag, ':'))) + { while (np && *np->id) /* find default namespace, if present */ + np = np->next; + } + else + { while (np && (strncmp(np->id, tag, s - tag) || np->id[s - tag])) + np = np->next; + if (!np) + soap->error = SOAP_NAMESPACE; + } + if (np) + { if (np->index >= 0) + return soap->namespaces[np->index].ns; + if (np->ns) + return soap_strdup(soap, np->ns); + } + return NULL; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_tag_cmp(const char *s, const char *t) +{ for (;;) + { register int c1 = *s; + register int c2 = *t; + if (!c1 || c1 == '"') + break; + if (c2 != '-') + { if (c1 != c2) + { if (c1 >= 'A' && c1 <= 'Z') + c1 += 'a' - 'A'; + if (c2 >= 'A' && c2 <= 'Z') + c2 += 'a' - 'A'; + } + if (c1 != c2) + { if (c2 != '*') + return 1; + c2 = *++t; + if (!c2) + return 0; + if (c2 >= 'A' && c2 <= 'Z') + c2 += 'a' - 'A'; + for (;;) + { c1 = *s; + if (!c1 || c1 == '"') + break; + if (c1 >= 'A' && c1 <= 'Z') + c1 += 'a' - 'A'; + if (c1 == c2 && !soap_tag_cmp(s + 1, t + 1)) + return 0; + s++; + } + break; + } + } + s++; + t++; + } + if (*t == '*' && !t[1]) + return 0; + return *t; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_match_tag(struct soap *soap, const char *tag1, const char *tag2) +{ register const char *s, *t; + if (!tag1 || !tag2 || !*tag2) + return SOAP_OK; + s = strchr(tag1, ':'); + t = strchr(tag2, ':'); + if (t) + { if (s) + { if (t[1] && SOAP_STRCMP(s + 1, t + 1)) + return SOAP_TAG_MISMATCH; + if (t != tag2 && soap_match_namespace(soap, tag1, tag2, s - tag1, t - tag2)) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2)); + return SOAP_TAG_MISMATCH; + } + } + else if (SOAP_STRCMP(tag1, t + 1)) + return SOAP_TAG_MISMATCH; + else if (t != tag2 && soap_match_namespace(soap, tag1, tag2, 0, t - tag2)) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags '%s' and '%s' match but namespaces differ\n", tag1, tag2)); + return SOAP_TAG_MISMATCH; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags and (default) namespaces match: '%s' '%s'\n", tag1, tag2)); + return SOAP_OK; + } + if (s) + { if (SOAP_STRCMP(s + 1, tag2)) + return SOAP_TAG_MISMATCH; + } + else if (SOAP_STRCMP(tag1, tag2)) + return SOAP_TAG_MISMATCH; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Tags match: '%s' '%s'\n", tag1, tag2)); + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_match_array(struct soap *soap, const char *type) +{ if (*soap->arrayType) + if (soap_match_tag(soap, soap->arrayType, type) + && soap_match_tag(soap, soap->arrayType, "xsd:anyType") + && soap_match_tag(soap, soap->arrayType, "xsd:ur-type") + ) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array type mismatch: '%s' '%s'\n", soap->arrayType, type)); + return SOAP_TAG_MISMATCH; + } + return SOAP_OK; +} +#endif + +/******************************************************************************\ + * + * SSL + * +\******************************************************************************/ + +#ifdef WITH_OPENSSL +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_rand() +{ unsigned char buf[4]; + if (!ssl_init_done) + soap_ssl_init(); + RAND_pseudo_bytes(buf, 4); + return *(int*)buf; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_ssl_server_context(struct soap *soap, unsigned short flags, const char *keyfile, const char *password, const char *cafile, const char *capath, const char *dhfile, const char *randfile, const char *sid) +{ int err; + soap->keyfile = keyfile; + soap->password = password; + soap->cafile = cafile; + soap->capath = capath; + soap->dhfile = dhfile; + soap->rsa = (dhfile == NULL); + soap->randfile = randfile; + soap->require_client_auth = (flags & SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION); + if (!(err = soap->fsslauth(soap))) + { if (sid) + SSL_CTX_set_session_id_context(soap->ctx, (unsigned char*)sid, strlen(sid)); + } + return err; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_ssl_client_context(struct soap *soap, unsigned short flags, const char *keyfile, const char *password, const char *cafile, const char *capath, const char *randfile) +{ soap->keyfile = keyfile; + soap->password = password; + soap->cafile = cafile; + soap->capath = capath; + soap->dhfile = NULL; + soap->rsa = 0; + soap->randfile = randfile; + soap->require_server_auth = (flags & SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION); + return soap->fsslauth(soap); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_ssl_init() +{ /* Note: for MT systems, the main program MUST call soap_ssl_init() before any threads are started */ + if (!ssl_init_done) + { ssl_init_done = 1; + SSL_library_init(); +#ifndef WITH_LEAN + SSL_load_error_strings(); +#endif + if (!RAND_load_file("/dev/urandom", 1024)) + { char buf[1024]; + RAND_seed(buf, sizeof(buf)); + while (!RAND_status()) + { int r = rand(); + RAND_seed(&r, sizeof(int)); + } + } + } +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +const char * +SOAP_FMAC2 +soap_ssl_error(struct soap *soap, int ret) +{ int err = SSL_get_error(soap->ssl, ret); + const char *msg = soap_code_str(h_ssl_error_codes, err); + if (msg) + strcpy(soap->msgbuf, msg); + else + return ERR_error_string(err, soap->msgbuf); + if (ERR_peek_error()) + { unsigned long r; + strcat(soap->msgbuf, "\n"); + while ((r = ERR_get_error())) + ERR_error_string_n(r, soap->msgbuf + strlen(soap->msgbuf), sizeof(soap->msgbuf) - strlen(soap->msgbuf)); + } + else + { switch (ret) + { case 0: + strcpy(soap->msgbuf, "EOF was observed that violates the protocol. The client probably provided invalid authentication information."); + break; + case -1: + sprintf(soap->msgbuf, "Error observed by underlying BIO: %s", strerror(errno)); + break; + } + } + return soap->msgbuf; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +static int +ssl_password(char *buf, int num, int rwflag, void *userdata) +{ if (num < (int)strlen((char*)userdata) + 1) + return 0; + return strlen(strcpy(buf, (char*)userdata)); +} +#endif + +/******************************************************************************/ +/* This callback is included for future references. It should not be deleted +#ifndef PALM_2 +static DH * +ssl_tmp_dh(SSL *ssl, int is_export, int keylength) +{ static DH *dh512 = NULL; + static DH *dh1024 = NULL; + DH *dh; + switch (keylength) + { case 512: + if (!dh512) + { BIO *bio = BIO_new_file("dh512.pem", "r"); + if (bio) + { dh512 = PEM_read_bio_DHparams(bio, NULL, NULL, NULL); + BIO_free(bio); + return dh512; + } + } + else + return dh512; + default: + if (!dh1024) + { BIO *bio = BIO_new_file("dh1024.pem", "r"); + if (bio) + { dh1024 = PEM_read_bio_DHparams(bio, NULL, NULL, NULL); + BIO_free(bio); + } + } + dh = dh1024; + } + return dh; +} +#endif +*/ + +/******************************************************************************/ +#ifndef PALM_1 +static int +ssl_auth_init(struct soap *soap) +{ if (!ssl_init_done) + soap_ssl_init(); + if (!soap->ctx) + { if (!(soap->ctx = SSL_CTX_new(SSLv23_method()))) + return soap_set_receiver_error(soap, "SSL error", "Can't setup context", SOAP_SSL_ERROR); + } + if (soap->randfile) + { if (!RAND_load_file(soap->randfile, -1)) + return soap_set_receiver_error(soap, "SSL error", "Can't load randomness", SOAP_SSL_ERROR); + } + if (soap->cafile || soap->capath) + { if (!SSL_CTX_load_verify_locations(soap->ctx, soap->cafile, soap->capath)) + return soap_set_receiver_error(soap, "SSL error", "Can't read CA file and directory", SOAP_SSL_ERROR); + if (soap->cafile && soap->require_client_auth) + SSL_CTX_set_client_CA_list(soap->ctx, SSL_load_client_CA_file(soap->cafile)); + } + if (!SSL_CTX_set_default_verify_paths(soap->ctx)) + return soap_set_receiver_error(soap, "SSL error", "Can't read default CA file and/or directory", SOAP_SSL_ERROR); +/* See below */ + if (soap->keyfile) + { if (!SSL_CTX_use_certificate_chain_file(soap->ctx, soap->keyfile)) + return soap_set_receiver_error(soap, "SSL error", "Can't read certificate key file", SOAP_SSL_ERROR); + if (soap->password) + { SSL_CTX_set_default_passwd_cb_userdata(soap->ctx, (void*)soap->password); + SSL_CTX_set_default_passwd_cb(soap->ctx, ssl_password); + } + if (!SSL_CTX_use_PrivateKey_file(soap->ctx, soap->keyfile, SSL_FILETYPE_PEM)) + return soap_set_receiver_error(soap, "SSL error", "Can't read key file", SOAP_SSL_ERROR); + } +/* Suggested alternative approach to check cafile first before the key file: + if (soap->password) + { SSL_CTX_set_default_passwd_cb_userdata(soap->ctx, (void*)soap->password); + SSL_CTX_set_default_passwd_cb(soap->ctx, ssl_password); + } + if (!soap->cafile || !SSL_CTX_use_certificate_chain_file(soap->ctx, soap->cafile)) + { if (soap->keyfile) + { if (!SSL_CTX_use_certificate_chain_file(soap->ctx, soap->keyfile)) + return soap_set_receiver_error(soap, "SSL error", "Can't read certificate or key file", SOAP_SSL_ERROR); + if (!SSL_CTX_use_PrivateKey_file(soap->ctx, soap->keyfile, SSL_FILETYPE_PEM)) + return soap_set_receiver_error(soap, "SSL error", "Can't read key file", SOAP_SSL_ERROR); + } + } +*/ + if (soap->rsa) + { RSA *rsa = RSA_generate_key(1024, RSA_F4, NULL, NULL); + if (!SSL_CTX_set_tmp_rsa(soap->ctx, rsa)) + { if (rsa) + RSA_free(rsa); + return soap_set_receiver_error(soap, "SSL error", "Can't set RSA key", SOAP_SSL_ERROR); + } + RSA_free(rsa); + } + else if (soap->dhfile) + { DH *dh = 0; + BIO *bio; + bio = BIO_new_file(soap->dhfile, "r"); + if (!bio) + return soap_set_receiver_error(soap, "SSL error", "Can't read DH file", SOAP_SSL_ERROR); + dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL); + BIO_free(bio); + if (SSL_CTX_set_tmp_dh(soap->ctx, dh) < 0) + { if (dh) + DH_free(dh); + return soap_set_receiver_error(soap, "SSL error", "Can't set DH parameters", SOAP_SSL_ERROR); + } + DH_free(dh); + } + SSL_CTX_set_options(soap->ctx, SSL_OP_ALL | SSL_OP_NO_SSLv2); + SSL_CTX_set_verify(soap->ctx, soap->require_client_auth ? (SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT) : soap->require_server_auth ? SSL_VERIFY_PEER : SSL_VERIFY_NONE, soap->fsslverify); +#if (OPENSSL_VERSION_NUMBER < 0x00905100L) + SSL_CTX_set_verify_depth(soap->ctx, 1); +#else + SSL_CTX_set_verify_depth(soap->ctx, 9); +#endif + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +static int +ssl_verify_callback(int ok, X509_STORE_CTX *store) +{ +#ifdef SOAP_DEBUG + if (!ok) + { char data[256]; + X509 *cert = X509_STORE_CTX_get_current_cert(store); + fprintf(stderr, "SSL verify error or warning with certificate at depth %d: %s\n", X509_STORE_CTX_get_error_depth(store), X509_verify_cert_error_string(X509_STORE_CTX_get_error(store))); + X509_NAME_oneline(X509_get_issuer_name(cert), data, sizeof(data)); + fprintf(stderr, "certificate issuer %s\n", data); + X509_NAME_oneline(X509_get_subject_name(cert), data, sizeof(data)); + fprintf(stderr, "certificate subject %s\n", data); + } +#endif + /* Note: return 1 to continue, but unsafe progress will be terminated by SSL */ + return ok; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_ssl_accept(struct soap *soap) +{ BIO *bio; + int i, r; + if (!soap_valid_socket(soap->socket)) + return soap_set_receiver_error(soap, "SSL error", "No socket in soap_ssl_accept()", SOAP_SSL_ERROR); + if (!soap->ctx && (soap->error = soap->fsslauth(soap))) + return SOAP_INVALID_SOCKET; + if (!soap->ssl) + { soap->ssl = SSL_new(soap->ctx); + if (!soap->ssl) + return soap_set_receiver_error(soap, "SSL error", "SSL_new() failed in soap_ssl_accept()", SOAP_SSL_ERROR); + } + else + SSL_clear(soap->ssl); + soap->imode |= SOAP_ENC_SSL; + soap->omode |= SOAP_ENC_SSL; +#if defined(WIN32) + { u_long nonblocking = 1; + ioctlsocket((SOAP_SOCKET)soap->socket, FIONBIO, &nonblocking); + } +#elif defined(VXWORKS) + { u_long nonblocking = 1; + ioctl((SOAP_SOCKET)soap->socket, FIONBIO, (int)&nonblocking); + } +#else + fcntl((SOAP_SOCKET)soap->socket, F_SETFL, fcntl((SOAP_SOCKET)soap->socket, F_GETFL)|O_NONBLOCK); +#endif + bio = BIO_new_socket((SOAP_SOCKET)soap->socket, BIO_NOCLOSE); + SSL_set_bio(soap->ssl, bio, bio); + i = 100; /* 100 * 0.1 ms retries */ + while ((r = SSL_accept(soap->ssl)) <= 0) + { int err = SSL_get_error(soap->ssl, r); + if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) + { struct timeval timeout; + fd_set fd; + if (i-- <= 0) + break; + timeout.tv_sec = 0; + timeout.tv_usec = 100000; +#ifndef WIN32 + if ((int)soap->socket > FD_SETSIZE) + return SOAP_FD_EXCEEDED; /* Hint: MUST increase FD_SETSIZE */ +#endif + FD_ZERO(&fd); + FD_SET((SOAP_SOCKET)soap->socket, &fd); + r = select((SOAP_SOCKET)(soap->socket + 1), &fd, NULL, &fd, &timeout); + if (r < 0 && soap_socket_errno != SOAP_EINTR) + { soap->errnum = soap_socket_errno; + return SOAP_EOF; + } + } + else + { soap->errnum = err; + break; + } + } +#if defined(WIN32) + { u_long blocking = 0; + ioctlsocket((SOAP_SOCKET)soap->socket, FIONBIO, &blocking); + } +#elif defined(VXWORKS) + { u_long blocking = 0; + ioctl((SOAP_SOCKET)soap->socket, FIONBIO, (int)&blocking); + } +#else + fcntl((SOAP_SOCKET)soap->socket, F_SETFL, fcntl((SOAP_SOCKET)soap->socket, F_GETFL)&~O_NONBLOCK); +#endif + if (r <= 0) + { soap_set_receiver_error(soap, soap_ssl_error(soap, r), "SSL_accept() failed in soap_ssl_accept()", SOAP_SSL_ERROR); + soap_closesock(soap); + return SOAP_SSL_ERROR; + } + if (soap->require_client_auth) + { X509 *peer; + int err; + if ((err = SSL_get_verify_result(soap->ssl)) != X509_V_OK) + { soap_closesock(soap); + return soap_set_sender_error(soap, X509_verify_cert_error_string(err), "SSL certificate presented by peer cannot be verified in soap_ssl_accept()", SOAP_SSL_ERROR); + } + peer = SSL_get_peer_certificate(soap->ssl); + if (!peer) + { soap_closesock(soap); + return soap_set_sender_error(soap, "SSL error", "No SSL certificate was presented by the peer in soap_ssl_accept()", SOAP_SSL_ERROR); + } + X509_free(peer); + } + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#endif /* WITH_OPENSSL */ + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static int +tcp_init(struct soap *soap) +{ soap->errmode = 1; +#ifdef WIN32 + if (tcp_done) + return 0; + else + { WSADATA w; + if (WSAStartup(MAKEWORD(1, 1), &w)) + return -1; + tcp_done = 1; + } +#endif + return 0; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_done(struct soap *soap) +{ +#ifdef SOAP_DEBUG + int i; +#endif + if (soap_check_state(soap)) + return; + soap_free(soap); + while (soap->clist) + { struct soap_clist *p = soap->clist->next; + SOAP_FREE(soap, soap->clist); + soap->clist = p; + } + soap->keep_alive = 0; /* to force close the socket */ + soap_closesock(soap); +#ifdef WITH_COOKIES + soap_free_cookies(soap); +#endif + while (soap->plugins) + { register struct soap_plugin *p = soap->plugins->next; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Removing plugin '%s'\n", soap->plugins->id)); + if (soap->plugins->fcopy || soap->state == SOAP_INIT) + soap->plugins->fdelete(soap, soap->plugins); + SOAP_FREE(soap, soap->plugins); + soap->plugins = p; + } + soap->fplugin = fplugin; +#ifndef WITH_NOHTTP + soap->fpost = http_post; + soap->fget = http_get; + soap->fform = NULL; + soap->fposthdr = http_post_header; + soap->fresponse = http_response; + soap->fparse = http_parse; + soap->fparsehdr = http_parse_header; +#endif + soap->fheader = NULL; +#ifndef WITH_NOIO +#ifndef WITH_IPV6 + soap->fresolve = tcp_gethost; +#else + soap->fresolve = NULL; +#endif + soap->faccept = tcp_accept; + soap->fopen = tcp_connect; + soap->fclose = tcp_disconnect; + soap->fclosesocket = tcp_closesocket; + soap->fshutdownsocket = tcp_shutdownsocket; + soap->fsend = fsend; + soap->frecv = frecv; + soap->fpoll = soap_poll; +#else + soap->fopen = NULL; + soap->fclose = NULL; + soap->fpoll = NULL; +#endif +#ifndef WITH_LEANER + soap->fprepareinit = NULL; + soap->fpreparesend = NULL; + soap->fpreparerecv = NULL; + soap->fpreparefinal = NULL; +#endif + soap->fseterror = NULL; + soap->fignore = NULL; + soap->fserveloop = NULL; +#ifdef WITH_OPENSSL + if (soap->session) + { SSL_SESSION_free(soap->session); + soap->session = NULL; + } +#endif + if (soap->state == SOAP_INIT) + { if (soap_valid_socket(soap->master)) + { soap->fclosesocket(soap, (SOAP_SOCKET)soap->master); + soap->master = SOAP_INVALID_SOCKET; + } +#ifdef WITH_OPENSSL + if (soap->ctx) + { SSL_CTX_free(soap->ctx); + soap->ctx = NULL; + } +#endif + } +#ifdef SOAP_DEBUG + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free logfiles\n")); + for (i = 0; i < SOAP_MAXLOGS; i++) + { if (soap->logfile[i]) + { SOAP_FREE(soap, (void*)soap->logfile[i]); + soap->logfile[i] = NULL; + } + soap_close_logfile(soap, i); + } + soap_free_mht(soap); + soap->state = 0; +#endif +} +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_cleanup(struct soap *soap) +{ soap_done(soap); +#ifdef WIN32 + if (!tcp_done) + return; + tcp_done = 0; + WSACleanup(); +#endif +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static const char* +tcp_error(struct soap *soap) +{ register const char *msg = NULL; + switch (soap->errmode) + { case 0: + msg = soap_strerror(soap); + break; + case 1: + msg = "WSAStartup failed"; + break; + case 2: + { +#ifndef WITH_LEAN + msg = soap_code_str(h_error_codes, soap->errnum); + if (!msg) +#endif + { sprintf(soap->msgbuf, "TCP/UDP IP error %d", soap->errnum); + msg = soap->msgbuf; + } + } + } + return msg; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static const char* +http_error(struct soap *soap, int status) +{ register const char *msg = SOAP_STR_EOS; +#ifndef WITH_LEAN + msg = soap_code_str(h_http_error_codes, status); + if (!msg) + msg = SOAP_STR_EOS; +#endif + return msg; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_IPV6 +#ifndef WITH_NOIO +#ifndef PALM_1 +static int +tcp_gethost(struct soap *soap, const char *addr, struct in_addr *inaddr) +{ soap_int32 iadd = -1; + struct hostent hostent, *host = &hostent; +#ifdef VXWORKS + int hostint; + /* inet_addr(), and hostGetByName() expect "char *"; addr is a "const char *". */ + iadd = inet_addr((char*)addr); +#else +#if defined(_AIXVERSION_431) || defined(TRU64) + struct hostent_data ht_data; +#endif +#ifdef AS400 + iadd = inet_addr((void*)addr); +#else + iadd = inet_addr(addr); +#endif +#endif + if (iadd != -1) + { memcpy(inaddr, &iadd, sizeof(iadd)); + return SOAP_OK; + } +#if defined(__GLIBC__) + if (gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &host, &soap->errnum) < 0) + host = NULL; +#elif defined(_AIXVERSION_431) || defined(TRU64) + memset((void*)&ht_data, 0, sizeof(ht_data)); + if (gethostbyname_r(addr, &hostent, &ht_data) < 0) + { host = NULL; + soap->errnum = h_errno; + } +#elif defined(HAVE_GETHOSTBYNAME_R) + host = gethostbyname_r(addr, &hostent, soap->buf, SOAP_BUFLEN, &soap->errnum); +#elif defined(VXWORKS) + /* If the DNS resolver library resolvLib has been configured in the vxWorks + * image, a query for the host IP address is sent to the DNS server, if the + * name was not found in the local host table. */ + hostint = hostGetByName((char*)addr); + if (hostint == ERROR) + { host = NULL; + soap->errnum = soap_errno; + } +#else +#ifdef AS400 + if (!(host = gethostbyname((void*)addr))) + soap->errnum = h_errno; +#else + if (!(host = gethostbyname(addr))) + soap->errnum = h_errno; +#endif +#endif + if (!host) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Host name not found\n")); + return SOAP_ERR; + } +#ifdef VXWORKS + inaddr->s_addr = hostint; +#else + memcpy(inaddr, host->h_addr, host->h_length); +#endif + return SOAP_OK; +} +#endif +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static int +tcp_connect(struct soap *soap, const char *endpoint, const char *host, int port) +{ +#ifdef WITH_IPV6 + struct addrinfo hints, *res, *ressave; + int err; +#endif + register int fd; +#ifndef WITH_LEAN + int len = SOAP_BUFLEN; + int set = 1; +#endif + if (soap_valid_socket(soap->socket)) + soap->fclosesocket(soap, (SOAP_SOCKET)soap->socket); + soap->socket = SOAP_INVALID_SOCKET; + if (tcp_init(soap)) + { soap->errnum = 0; + soap_set_sender_error(soap, tcp_error(soap), "TCP init failed in tcp_connect()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + soap->errmode = 0; +#ifdef WITH_IPV6 + memset((void*)&hints, 0, sizeof(hints)); + hints.ai_family = PF_UNSPEC; +#ifdef WITH_UDP + if ((soap->omode & SOAP_IO_UDP)) + hints.ai_socktype = SOCK_DGRAM; + else +#endif + hints.ai_socktype = SOCK_STREAM; + soap->errmode = 2; + if (soap->proxy_host) + err = getaddrinfo(soap->proxy_host, soap_int2s(soap, soap->proxy_port), &hints, &res); + else + err = getaddrinfo(host, soap_int2s(soap, port), &hints, &res); + if (err) + { soap_set_sender_error(soap, gai_strerror(err), "getaddrinfo failed in tcp_connect()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + ressave = res; +again: + fd = (int)socket(res->ai_family, res->ai_socktype, res->ai_protocol); + soap->errmode = 0; +#else +#ifdef WITH_UDP + if ((soap->omode & SOAP_IO_UDP)) + fd = (int)socket(AF_INET, SOCK_DGRAM, 0); + else +#endif + fd = (int)socket(AF_INET, SOCK_STREAM, 0); +#endif + if (fd < 0) + { soap->errnum = soap_socket_errno; + soap_set_sender_error(soap, tcp_error(soap), "socket failed in tcp_connect()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } +#ifdef SOCKET_CLOSE_ON_EXEC +#ifdef WIN32 +#ifndef UNDER_CE + SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, 0); +#endif +#else + fcntl(fd, F_SETFD, 1); +#endif +#endif +#ifndef WITH_LEAN + if (soap->connect_flags == SO_LINGER) + { struct linger linger; + memset((void*)&linger, 0, sizeof(linger)); + linger.l_onoff = 1; + linger.l_linger = 0; + if (setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger))) + { soap->errnum = soap_socket_errno; + soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_LINGER failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + } + else if (soap->connect_flags && setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, soap->connect_flags, (char*)&set, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_sender_error(soap, tcp_error(soap), "setsockopt failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + if (soap->keep_alive && setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + if (setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + if (setsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_sender_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } +#ifdef TCP_NODELAY + if (!(soap->omode & SOAP_IO_UDP) && setsockopt((SOAP_SOCKET)fd, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_sender_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } +#endif +#endif + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Opening socket %d to host='%s' port=%d\n", fd, host, port)); +#ifndef WITH_IPV6 + soap->peerlen = sizeof(soap->peer); + memset((void*)&soap->peer, 0, sizeof(soap->peer)); + soap->peer.sin_family = AF_INET; + soap->errmode = 2; + if (soap->proxy_host) + { if (soap->fresolve(soap, soap->proxy_host, &soap->peer.sin_addr)) + { soap_set_sender_error(soap, tcp_error(soap), "get proxy host by name failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + soap->peer.sin_port = htons((short)soap->proxy_port); + } + else + { if (soap->fresolve(soap, host, &soap->peer.sin_addr)) + { soap_set_sender_error(soap, tcp_error(soap), "get host by name failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + soap->peer.sin_port = htons((short)port); + } + soap->errmode = 0; + if ((soap->omode & SOAP_IO_UDP)) + return fd; +#endif +#ifndef WITH_LEAN + if (soap->connect_timeout) +#if defined(WIN32) + { u_long nonblocking = 1; + ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &nonblocking); + } +#elif defined(VXWORKS) + { u_long nonblocking = 1; + ioctl((SOAP_SOCKET)fd, FIONBIO, (int)(&nonblocking)); /* modified to use fd */ + } +#else + fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)|O_NONBLOCK); +#endif + else +#if defined(WIN32) + { u_long blocking = 0; + ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &blocking); + } +#elif defined(VXWORKS) + { u_long blocking = 0; + ioctl((SOAP_SOCKET)fd, FIONBIO, (int)(&blocking)); + } +#else + fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)&~O_NONBLOCK); +#endif +#endif + for (;;) + { +#ifdef WITH_IPV6 + if (connect((SOAP_SOCKET)fd, res->ai_addr, res->ai_addrlen)) +#else + if (connect((SOAP_SOCKET)fd, (struct sockaddr*)&soap->peer, sizeof(soap->peer))) +#endif + { +#ifndef WITH_LEAN + if (soap->connect_timeout && (soap_socket_errno == SOAP_EINPROGRESS || soap_socket_errno == SOAP_EWOULDBLOCK)) + { struct timeval timeout; + SOAP_SOCKLEN_T k; + fd_set fds; + if (soap->connect_timeout > 0) + { timeout.tv_sec = soap->connect_timeout; + timeout.tv_usec = 0; + } + else + { timeout.tv_sec = -soap->connect_timeout/1000000; + timeout.tv_usec = -soap->connect_timeout%1000000; + } +#ifndef WIN32 + if ((int)soap->socket > FD_SETSIZE) + { soap->error = SOAP_FD_EXCEEDED; + return SOAP_INVALID_SOCKET; /* Hint: MUST increase FD_SETSIZE */ + } +#endif + FD_ZERO(&fds); + FD_SET((SOAP_SOCKET)fd, &fds); + for (;;) + { int r = select((SOAP_SOCKET)(fd + 1), NULL, &fds, NULL, &timeout); + if (r > 0) + break; + if (!r) + { soap->errnum = 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connect timeout\n")); + soap_set_sender_error(soap, "Timeout", "connect failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + if (soap_socket_errno != SOAP_EINTR) + { soap->errnum = soap_socket_errno; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n")); + soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + } + k = (SOAP_SOCKLEN_T)sizeof(soap->errnum); + if (!getsockopt((SOAP_SOCKET)fd, SOL_SOCKET, SO_ERROR, (char*)&soap->errnum, &k) && !soap->errnum) /* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */ + break; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n")); + soap->errnum = soap_socket_errno; + soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + else +#endif +#ifdef WITH_IPV6 + if (res->ai_next) + { res = res->ai_next; + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + goto again; + } + else +#endif + if (soap_socket_errno != SOAP_EINTR) + { soap->errnum = soap_socket_errno; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not connect to host\n")); + soap_set_sender_error(soap, tcp_error(soap), "connect failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + } + else + break; + } +#ifdef WITH_IPV6 + soap->peerlen = 0; /* IPv6: already connected so use send() */ + freeaddrinfo(ressave); +#endif +#ifndef WITH_LEAN + if (soap->connect_timeout) +#if defined(WIN32) + { u_long blocking = 0; + ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &blocking); + } +#elif defined(VXWORKS) + { u_long blocking = 0; + ioctl((SOAP_SOCKET)fd, FIONBIO, (int)(&blocking)); + } +#else + fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)&~O_NONBLOCK); +#endif +#endif + soap->socket = fd; + soap->imode &= ~SOAP_ENC_SSL; + soap->omode &= ~SOAP_ENC_SSL; + if (!soap_tag_cmp(endpoint, "https:*")) + { +#ifdef WITH_OPENSSL + BIO *bio; + int r; + if (soap->proxy_host) + { unsigned int k = soap->omode; /* make sure we only parse HTTP */ + size_t n = soap->count; /* save the content length */ + char *userid, *passwd; + soap->omode &= ~SOAP_ENC; /* mask IO and ENC */ + soap->omode |= SOAP_IO_BUFFER; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connecting to proxy server\n")); + sprintf(soap->tmpbuf, "CONNECT %s:%d HTTP/%s", host, port, soap->http_version); + if (soap_begin_send(soap) + || (soap->error = soap->fposthdr(soap, soap->tmpbuf, NULL))) + { soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } +#ifndef WITH_LEAN + if (soap->proxy_userid && soap->proxy_passwd && strlen(soap->proxy_userid) + strlen(soap->proxy_passwd) < 761) + { sprintf(soap->tmpbuf + 262, "%s:%s", soap->proxy_userid, soap->proxy_passwd); + strcpy(soap->tmpbuf, "Basic "); + soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, strlen(soap->tmpbuf + 262)); + if ((soap->error = soap->fposthdr(soap, "Proxy-Authorization", soap->tmpbuf))) + { soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return soap->error; + } + } +#endif + if ((soap->error = soap->fposthdr(soap, NULL, NULL)) + || soap_flush(soap)) + { soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + soap->omode = k; + k = soap->imode; + soap->imode &= ~SOAP_ENC; /* mask IO and ENC */ + userid = soap->userid; /* preserve */ + passwd = soap->passwd; /* preserve */ + if ((soap->error = soap->fparse(soap))) + { soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + soap->userid = userid; /* restore */ + soap->passwd = passwd; /* restore */ + soap->imode = k; /* restore */ + soap->count = n; /* restore */ + if (soap_begin_send(soap)) + { soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + } + if (!soap->ctx && (soap->error = soap->fsslauth(soap))) + { soap_set_sender_error(soap, "SSL error", "SSL authentication failed in tcp_connect(): check password, key file, and ca file.", SOAP_SSL_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + soap->ssl = SSL_new(soap->ctx); + if (!soap->ssl) + { soap->fclosesocket(soap, (SOAP_SOCKET)fd); + soap->error = SOAP_SSL_ERROR; + return SOAP_INVALID_SOCKET; + } + if (soap->session) + { if (!strcmp(soap->session_host, host) && soap->session_port == port) + SSL_set_session(soap->ssl, soap->session); + SSL_SESSION_free(soap->session); + soap->session = NULL; + } + soap->imode |= SOAP_ENC_SSL; + soap->omode |= SOAP_ENC_SSL; + bio = BIO_new_socket((SOAP_SOCKET)fd, BIO_NOCLOSE); + SSL_set_bio(soap->ssl, bio, bio); +#ifndef WITH_LEAN + if (soap->connect_timeout) +#if defined(WIN32) + { u_long nonblocking = 1; + ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &nonblocking); + } +#elif defined(VXWORKS) + { u_long nonblocking = 1; + ioctl((SOAP_SOCKET)fd, FIONBIO, (int)(&nonblocking)); + } +#else + fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)|O_NONBLOCK); +#endif +#endif + for (;;) + { if ((r = SSL_connect(soap->ssl)) <= 0) + { int err = SSL_get_error(soap->ssl, r); + if (err != SSL_ERROR_NONE && err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE) + { soap_set_sender_error(soap, soap_ssl_error(soap, r), "SSL connect failed in tcp_connect()", SOAP_SSL_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + if (soap->connect_timeout) + { struct timeval timeout; + fd_set fds; + if (soap->connect_timeout > 0) + { timeout.tv_sec = soap->connect_timeout; + timeout.tv_usec = 0; + } + else + { timeout.tv_sec = -soap->connect_timeout/1000000; + timeout.tv_usec = -soap->connect_timeout%1000000; + } +#ifndef WIN32 + if ((int)soap->socket > FD_SETSIZE) + { soap->error = SOAP_FD_EXCEEDED; + return SOAP_INVALID_SOCKET; /* Hint: MUST increase FD_SETSIZE */ + } +#endif + FD_ZERO(&fds); + FD_SET((SOAP_SOCKET)fd, &fds); + for (;;) + { int r = select((SOAP_SOCKET)(fd + 1), &fds, NULL, &fds, &timeout); + if (r > 0) + break; + if (!r) + { soap->errnum = 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Connect timeout\n")); + soap_set_sender_error(soap, "Timeout", "connect failed in tcp_connect()", SOAP_TCP_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + } + continue; + } + } + break; + } +#ifndef WITH_LEAN + if (soap->connect_timeout) +#ifdef WIN32 + { u_long blocking = 0; + ioctlsocket((SOAP_SOCKET)fd, FIONBIO, &blocking); + } +#elif defined(VXWORKS) + { u_long blocking = 0; + ioctl((SOAP_SOCKET)fd, FIONBIO, (int)(&blocking)); + } +#else + fcntl((SOAP_SOCKET)fd, F_SETFL, fcntl((SOAP_SOCKET)fd, F_GETFL)&~O_NONBLOCK); +#endif +#endif + if (soap->require_server_auth) + { X509 *peer; + X509_NAME *subj; + int ext_count; + int err; + int ok = 0; + if ((err = SSL_get_verify_result(soap->ssl)) != X509_V_OK) + { soap_set_sender_error(soap, X509_verify_cert_error_string(err), "SSL certificate presented by peer cannot be verified in tcp_connect()", SOAP_SSL_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + peer = SSL_get_peer_certificate(soap->ssl); + if (!peer) + { soap_set_sender_error(soap, "SSL error", "No SSL certificate was presented by the peer in tcp_connect()", SOAP_SSL_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + return SOAP_INVALID_SOCKET; + } + ext_count = X509_get_ext_count(peer); + if (ext_count > 0) + { int i; + for (i = 0; i < ext_count; i++) + { X509_EXTENSION *ext = X509_get_ext(peer, i); + const char *ext_str = OBJ_nid2sn(OBJ_obj2nid(X509_EXTENSION_get_object(ext))); + if (!strcmp(ext_str, "subjectAltName")) + { int j; + STACK_OF(CONF_VALUE) *val; + X509V3_EXT_METHOD *meth = const_cast(X509V3_EXT_get(ext)); + if (!meth) + break; +#ifdef WIN32 + val = meth->i2v(meth, meth->d2i(NULL, (const unsigned char**)&ext->value->data, ext->value->length), NULL); +#else + /*val = meth->i2v(meth, meth->d2i(NULL, (unsigned char**)&ext->value->data, ext->value->length), NULL);*/ + val = meth->i2v(meth, meth->d2i(NULL, (const unsigned char**)&ext->value->data, ext->value->length), NULL); +#endif + for (j = 0; j < sk_CONF_VALUE_num(val); j++) + { CONF_VALUE *nval = sk_CONF_VALUE_value(val, j); + if (nval && !strcmp(nval->name, "DNS") && !strcmp(nval->value, host)) + { ok = 1; + break; + } + } + } + if (ok) + break; + } + } + if (!ok && (subj = X509_get_subject_name(peer))) + { X509_NAME_get_text_by_NID(subj, NID_commonName, soap->msgbuf, sizeof(soap->msgbuf)); + if (soap_tag_cmp(soap->msgbuf, host)) + { soap_set_sender_error(soap, "SSL error", "SSL certificate host name mismatch in tcp_connect()", SOAP_SSL_ERROR); + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + X509_free(peer); + return SOAP_INVALID_SOCKET; + } + } + X509_free(peer); + } +#else + soap->fclosesocket(soap, (SOAP_SOCKET)fd); + soap->error = SOAP_SSL_ERROR; + return SOAP_INVALID_SOCKET; +#endif + } + return fd; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_bind(struct soap *soap, const char *host, int port, int backlog) +{ +#ifdef WITH_IPV6 + struct addrinfo *addrinfo = NULL; + struct addrinfo hints; + struct addrinfo res; + int err; +#endif +#ifndef WITH_LEAN + int len = SOAP_BUFLEN; + int set = 1; +#endif + if (soap_valid_socket(soap->master)) + { soap->fclosesocket(soap, (SOAP_SOCKET)soap->master); + soap->master = SOAP_INVALID_SOCKET; + } + soap->socket = SOAP_INVALID_SOCKET; + soap->errmode = 1; + if (tcp_init(soap)) + { soap_set_receiver_error(soap, tcp_error(soap), "TCP init failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } +#ifdef WITH_IPV6 + memset((void*)&hints, 0, sizeof(hints)); + hints.ai_family = PF_UNSPEC; +#ifdef WITH_UDP + if ((soap->omode & SOAP_IO_UDP)) + hints.ai_socktype = SOCK_DGRAM; + else +#endif + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + soap->errmode = 2; + err = getaddrinfo(host, soap_int2s(soap, port), &hints, &addrinfo); + if (addrinfo) + { res = *addrinfo; + soap->peer = *((struct sockaddr_storage*)addrinfo->ai_addr); + soap->peerlen = addrinfo->ai_addrlen; + res.ai_addr = (struct sockaddr*)&soap->peer; + res.ai_addrlen = soap->peerlen; + freeaddrinfo(addrinfo); + } + if (err) + { soap_set_receiver_error(soap, gai_strerror(err), "getaddrinfo failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + soap->master = socket(res.ai_family, res.ai_socktype, res.ai_protocol); +#else +#ifdef WITH_UDP + if ((soap->omode & SOAP_IO_UDP)) + soap->master = (int)socket(AF_INET, SOCK_DGRAM, 0); + else +#endif + soap->master = (int)socket(AF_INET, SOCK_STREAM, 0); +#endif + soap->errmode = 0; + if (!soap_valid_socket(soap->master)) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "socket failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } +#ifdef WITH_UDP + if ((soap->omode & SOAP_IO_UDP)) + soap->socket = soap->master; +#endif +#ifdef SOCKET_CLOSE_ON_EXEC +#ifdef WIN32 +#ifndef UNDER_CE + SetHandleInformation((HANDLE)soap->master, HANDLE_FLAG_INHERIT, 0); +#endif +#else + fcntl(soap->master, F_SETFD, 1); +#endif +#endif +#ifndef WITH_LEAN + if (soap->bind_flags && setsockopt((SOAP_SOCKET)soap->master, SOL_SOCKET, soap->bind_flags, (char*)&set, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && setsockopt((SOAP_SOCKET)soap->master, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + if (setsockopt((SOAP_SOCKET)soap->master, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + if (setsockopt((SOAP_SOCKET)soap->master, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } +#ifdef TCP_NODELAY + if (!(soap->omode & SOAP_IO_UDP) && setsockopt((SOAP_SOCKET)soap->master, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } +#endif +#endif +#ifdef WITH_IPV6 + soap->errmode = 0; + if (bind((SOAP_SOCKET)soap->master, res.ai_addr, res.ai_addrlen)) + { soap->errnum = soap_socket_errno; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n")); + soap_closesock(soap); + soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } +#else + soap->peerlen = sizeof(soap->peer); + memset((void*)&soap->peer, 0, sizeof(soap->peer)); + soap->peer.sin_family = AF_INET; + soap->errmode = 2; + if (host) + { if (soap->fresolve(soap, host, &soap->peer.sin_addr)) + { soap_set_receiver_error(soap, tcp_error(soap), "get host by name failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + } + else + soap->peer.sin_addr.s_addr = htonl(INADDR_ANY); + soap->peer.sin_port = htons((short)port); + soap->errmode = 0; + if (bind((SOAP_SOCKET)soap->master, (struct sockaddr*)&soap->peer, soap->peerlen)) + { soap->errnum = soap_socket_errno; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n")); + soap_closesock(soap); + soap_set_receiver_error(soap, tcp_error(soap), "bind failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } +#endif + if (!(soap->omode & SOAP_IO_UDP) && listen((SOAP_SOCKET)soap->master, backlog)) + { soap->errnum = soap_socket_errno; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not bind to host\n")); + soap_closesock(soap); + soap_set_receiver_error(soap, tcp_error(soap), "listen failed in soap_bind()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + return soap->master; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_poll(struct soap *soap) +{ +#ifndef WITH_LEAN + struct timeval timeout; + fd_set rfd, sfd, xfd; + int r; + timeout.tv_sec = 0; + timeout.tv_usec = 0; +#ifndef WIN32 + if ((int)soap->socket > FD_SETSIZE) + return SOAP_FD_EXCEEDED; /* Hint: MUST increase FD_SETSIZE */ +#endif + FD_ZERO(&rfd); + FD_ZERO(&sfd); + FD_ZERO(&xfd); + if (soap_valid_socket(soap->socket)) + { FD_SET((SOAP_SOCKET)soap->socket, &rfd); + FD_SET((SOAP_SOCKET)soap->socket, &sfd); + FD_SET((SOAP_SOCKET)soap->socket, &xfd); + r = select((SOAP_SOCKET)(soap->socket + 1), &rfd, &sfd, &xfd, &timeout); + if (r > 0 && FD_ISSET((SOAP_SOCKET)soap->socket, &xfd)) + r = -1; + } + else if (soap_valid_socket(soap->master)) + { FD_SET((SOAP_SOCKET)soap->master, &sfd); + r = select((SOAP_SOCKET)(soap->master + 1), NULL, &sfd, NULL, &timeout); + } + else + return SOAP_OK; + if (r > 0) + { +#ifdef WITH_OPENSSL + if (soap->imode & SOAP_ENC_SSL) + { + if (soap_valid_socket(soap->socket) + && FD_ISSET((SOAP_SOCKET)soap->socket, &sfd) + && (!FD_ISSET((SOAP_SOCKET)soap->socket, &rfd) + || SSL_peek(soap->ssl, soap->tmpbuf, 1) > 0)) + return SOAP_OK; + } + else +#endif + if (soap_valid_socket(soap->socket) + && FD_ISSET((SOAP_SOCKET)soap->socket, &sfd) + && (!FD_ISSET((SOAP_SOCKET)soap->socket, &rfd) + || recv((SOAP_SOCKET)soap->socket, soap->tmpbuf, 1, MSG_PEEK) > 0)) + return SOAP_OK; + } + else if (r < 0) + { soap->errnum = soap_socket_errno; + if ((soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) && soap_socket_errno != SOAP_EINTR) + { soap_set_receiver_error(soap, tcp_error(soap), "select failed in soap_poll()", SOAP_TCP_ERROR); + return soap->error = SOAP_TCP_ERROR; + } + } + else + soap->errnum = 0; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Polling: other end down on socket=%d select=%d\n", soap->socket, r)); + return SOAP_EOF; +#else + return SOAP_OK; +#endif +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static int +tcp_accept(struct soap *soap, int s, struct sockaddr *a, int *n) +{ int fd; + fd = (int)accept((SOAP_SOCKET)s, a, (SOAP_SOCKLEN_T*)n); /* portability note: see SOAP_SOCKLEN_T definition in stdsoap2.h */ +#ifdef SOCKET_CLOSE_ON_EXEC +#ifdef WIN32 +#ifndef UNDER_CE + SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, 0); +#endif +#else + fcntl(fd, F_SETFD, FD_CLOEXEC); +#endif +#endif + return fd; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_accept(struct soap *soap) +{ int n = (int)sizeof(soap->peer); +#ifndef WITH_LEAN + int len = SOAP_BUFLEN; + int set = 1; +#endif + soap->error = SOAP_OK; +#ifdef WITH_UDP + if ((soap->omode & SOAP_IO_UDP)) + return soap->socket = soap->master; +#endif + memset((void*)&soap->peer, 0, sizeof(soap->peer)); + soap->socket = SOAP_INVALID_SOCKET; + soap->errmode = 0; + soap->keep_alive = 0; + if (soap_valid_socket(soap->master)) + { for (;;) + { +#ifndef WITH_LEAN + if (soap->accept_timeout) + { struct timeval timeout; + fd_set fd; + if (soap->accept_timeout > 0) + { timeout.tv_sec = soap->accept_timeout; + timeout.tv_usec = 0; + } + else + { timeout.tv_sec = -soap->accept_timeout/1000000; + timeout.tv_usec = -soap->accept_timeout%1000000; + } +#ifndef WIN32 + if ((int)soap->socket > FD_SETSIZE) + { soap->error = SOAP_FD_EXCEEDED; + return SOAP_INVALID_SOCKET; /* Hint: MUST increase FD_SETSIZE */ + } +#endif + FD_ZERO(&fd); + FD_SET((SOAP_SOCKET)soap->master, &fd); + for (;;) + { int r = select((SOAP_SOCKET)(soap->master + 1), &fd, &fd, NULL, &timeout); + if (r > 0) + break; + if (!r) + { soap->errnum = 0; + soap_set_receiver_error(soap, "Timeout", "accept failed in soap_accept()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + if (soap_socket_errno != SOAP_EINTR) + { soap->errnum = soap_socket_errno; + soap_closesock(soap); + soap_set_sender_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } + } +#if defined(WIN32) + { u_long nonblocking = 1; + ioctlsocket((SOAP_SOCKET)soap->master, FIONBIO, &nonblocking); + } +#elif defined(VXWORKS) + { u_long nonblocking = 1; + ioctl((SOAP_SOCKET)soap->master, FIONBIO, (int)(&nonblocking)); + } +#else + fcntl((SOAP_SOCKET)soap->master, F_SETFL, fcntl((SOAP_SOCKET)soap->master, F_GETFL)|O_NONBLOCK); +#endif + } + else +#if defined(WIN32) + { u_long blocking = 0; + ioctlsocket((SOAP_SOCKET)soap->master, FIONBIO, &blocking); + } +#elif defined(VXWORKS) + { u_long blocking = 0; + ioctl((SOAP_SOCKET)soap->master, FIONBIO, (int)(&blocking)); + } +#else + fcntl((SOAP_SOCKET)soap->master, F_SETFL, fcntl((SOAP_SOCKET)soap->master, F_GETFL)&~O_NONBLOCK); +#endif +#endif + soap->socket = soap->faccept(soap, soap->master, (struct sockaddr*)&soap->peer, &n); + soap->peerlen = (size_t)n; + if (soap_valid_socket(soap->socket)) + { +#ifdef WITH_IPV6 +/* Use soap->host to store the numeric form of the remote host */ + getnameinfo((struct sockaddr*)&soap->peer, n, soap->host, sizeof(soap->host), NULL, 0, NI_NUMERICHOST | NI_NUMERICSERV); + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept socket %d from %s\n", soap->socket, soap->host)); + soap->ip = 0; /* info stored in soap->peer and soap->host */ + soap->port = 0; /* info stored in soap->peer and soap->host */ +#else + soap->ip = ntohl(soap->peer.sin_addr.s_addr); + soap->port = (int)ntohs(soap->peer.sin_port); /* does not return port number on some systems */ + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept socket %d at port %d from IP %d.%d.%d.%d\n", soap->socket, soap->port, (int)(soap->ip>>24)&0xFF, (int)(soap->ip>>16)&0xFF, (int)(soap->ip>>8)&0xFF, (int)soap->ip&0xFF)); +#endif +#ifndef WITH_LEAN + if (soap->accept_flags == SO_LINGER) + { struct linger linger; + memset((void*)&linger, 0, sizeof(linger)); + linger.l_onoff = 1; + linger.l_linger = 0; + if (setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(struct linger))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_LINGER failed in soap_accept()", SOAP_TCP_ERROR); + soap_closesock(soap); + return SOAP_INVALID_SOCKET; + } + } + else if (soap->accept_flags && setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, soap->accept_flags, (char*)&set, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt failed in soap_accept()", SOAP_TCP_ERROR); + soap_closesock(soap); + return SOAP_INVALID_SOCKET; + } + if (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) && setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, SO_KEEPALIVE, (char*)&set, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_KEEPALIVE failed in soap_accept()", SOAP_TCP_ERROR); + soap_closesock(soap); + return SOAP_INVALID_SOCKET; + } + if (setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_SNDBUF failed in soap_accept()", SOAP_TCP_ERROR); + soap_closesock(soap); + return SOAP_INVALID_SOCKET; + } + if (setsockopt((SOAP_SOCKET)soap->socket, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt SO_RCVBUF failed in soap_accept()", SOAP_TCP_ERROR); + soap_closesock(soap); + return SOAP_INVALID_SOCKET; + } +#ifdef TCP_NODELAY + if (!(soap->omode & SOAP_IO_UDP) && setsockopt((SOAP_SOCKET)soap->socket, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int))) + { soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "setsockopt TCP_NODELAY failed in soap_accept()", SOAP_TCP_ERROR); + soap_closesock(soap); + return SOAP_INVALID_SOCKET; + } +#endif +#endif + if (soap->accept_timeout) + { +#if defined(WIN32) + u_long blocking = 0; + ioctlsocket((SOAP_SOCKET)soap->master, FIONBIO, &blocking); + ioctlsocket((SOAP_SOCKET)soap->socket, FIONBIO, &blocking); +#elif defined(VXWORKS) + u_long blocking = 0; + ioctl((SOAP_SOCKET)soap->master, FIONBIO, (int)(&blocking)); + ioctl((SOAP_SOCKET)soap->socket, FIONBIO, (int)(&blocking)); +#elif defined(PALM) + fcntl((SOAP_SOCKET)soap->master, F_SETFL, fcntl((SOAP_SOCKET)soap->master, F_GETFL,0)&~O_NONBLOCK); + fcntl((SOAP_SOCKET)soap->socket, F_SETFL, fcntl((SOAP_SOCKET)soap->socket, F_GETFL,0)&~O_NONBLOCK); +#elif defined(SYMBIAN) + long blocking = 0; + ioctl((SOAP_SOCKET)soap->master, 0/*FIONBIO*/, &blocking); +#else + fcntl((SOAP_SOCKET)soap->master, F_SETFL, fcntl((SOAP_SOCKET)soap->master, F_GETFL)&~O_NONBLOCK); + fcntl((SOAP_SOCKET)soap->socket, F_SETFL, fcntl((SOAP_SOCKET)soap->socket, F_GETFL)&~O_NONBLOCK); +#endif + } + soap->keep_alive = (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0); + return soap->socket; + } + if (soap_socket_errno != SOAP_EINTR && soap_socket_errno != SOAP_EAGAIN) + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Accept failed from %s\n", soap->host)); + soap->errnum = soap_socket_errno; + soap_set_receiver_error(soap, tcp_error(soap), "accept failed in soap_accept()", SOAP_TCP_ERROR); + soap_closesock(soap); + return SOAP_INVALID_SOCKET; + } + } + } + else + { soap->errnum = 0; + soap_set_receiver_error(soap, tcp_error(soap), "no master socket in soap_accept()", SOAP_TCP_ERROR); + return SOAP_INVALID_SOCKET; + } +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static int +tcp_disconnect(struct soap *soap) +{ +#ifdef WITH_OPENSSL + if (soap->ssl) + { int r, s = 0; + if (soap->session) + SSL_SESSION_free(soap->session); + if (*soap->host) + { soap->session = SSL_get1_session(soap->ssl); + if (soap->session) + { strcpy(soap->session_host, soap->host); + soap->session_port = soap->port; + } + } + r = SSL_shutdown(soap->ssl); + if (r != 1) + { s = ERR_get_error(); + if (s) + { if (soap_valid_socket(soap->socket)) + { soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 1); + soap->socket = SOAP_INVALID_SOCKET; + } + r = SSL_shutdown(soap->ssl); + } + } + DBGLOG(TEST, if (s) SOAP_MESSAGE(fdebug, "Shutdown failed: %d\n", SSL_get_error(soap->ssl, r))); + SSL_free(soap->ssl); + soap->ssl = NULL; + if (s) + return SOAP_SSL_ERROR; + ERR_remove_state(0); + } +#endif + if (soap_valid_socket(soap->socket) && !(soap->omode & SOAP_IO_UDP)) + { soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 2); + soap->fclosesocket(soap, (SOAP_SOCKET)soap->socket); + soap->socket = SOAP_INVALID_SOCKET; + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static int +tcp_closesocket(struct soap *soap, SOAP_SOCKET fd) +{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Close socket %d\n", (int)fd)); + return soap_closesocket(fd); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static int +tcp_shutdownsocket(struct soap *soap, SOAP_SOCKET fd, int how) +{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Shutdown socket %d how=%d\n", (int)fd, how)); + return shutdown(fd, how); +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_closesock(struct soap *soap) +{ register int status = soap->error; + if (status == SOAP_EOF || status == SOAP_TCP_ERROR || status == SOAP_SSL_ERROR || !soap->keep_alive) + { if (soap->fclose && (soap->error = soap->fclose(soap))) + return soap->error; + soap->keep_alive = 0; + } +#ifdef WITH_ZLIB + if (soap->zlib_state == SOAP_ZLIB_DEFLATE) + deflateEnd(&soap->d_stream); + else if (soap->zlib_state == SOAP_ZLIB_INFLATE) + inflateEnd(&soap->d_stream); + soap->zlib_state = SOAP_ZLIB_NONE; +#endif + return soap->error = status; +} +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +size_t +SOAP_FMAC2 +soap_hash(register const char *s) +{ register size_t h = 0; + while (*s) + h = 65599*h + *s++; + return h % SOAP_IDHASH; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_1 +static void +soap_init_pht(struct soap *soap) +{ register int i; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing pointer hashtable\n")); + soap->pblk = NULL; + soap->pidx = 0; + for (i = 0; i < (int)SOAP_PTRHASH; i++) + soap->pht[i] = NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +struct soap* +SOAP_FMAC2 +soap_new1(soap_mode mode) +{ return soap_new2(mode, mode); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +struct soap* +SOAP_FMAC2 +soap_new() +{ return soap_new2(SOAP_IO_DEFAULT, SOAP_IO_DEFAULT); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +struct soap* +SOAP_FMAC2 +soap_new2(soap_mode imode, soap_mode omode) +{ struct soap *soap = (struct soap*)malloc(sizeof(struct soap)); + if (soap) + soap_init2(soap, imode, omode); + return soap; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_del(struct soap *soap) +{ free(soap); +} +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_1 +static void +soap_free_pht(struct soap *soap) +{ register struct soap_pblk *pb, *next; + register int i; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free pointer hashtable\n")); + for (pb = soap->pblk; pb; pb = next) + { next = pb->next; + SOAP_FREE(soap, pb); + } + soap->pblk = NULL; + soap->pidx = 0; + for (i = 0; i < (int)SOAP_PTRHASH; i++) + soap->pht[i] = NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_embed(struct soap *soap, const void *p, const struct soap_array *a, int n, const char *tag, int type) +{ register int i; + struct soap_plist *pp; + if (soap->version != 1) + soap->encoding = 1; + if (a) + i = soap_array_pointer_lookup(soap, p, a, n, type, &pp); + else + i = soap_pointer_lookup(soap, p, type, &pp); + if (i) + { if (soap_is_embedded(soap, pp) + || soap_is_single(soap, pp)) + return 0; + soap_set_embedded(soap, pp); + } + return i; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_pointer_lookup(struct soap *soap, const void *p, int type, struct soap_plist **ppp) +{ register struct soap_plist *pp; + *ppp = NULL; + if (p) + { for (pp = soap->pht[soap_hash_ptr(p)]; pp; pp = pp->next) + { if (pp->ptr == p && pp->type == type) + { *ppp = pp; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d id=%d\n", p, type, pp->id)); + return pp->id; + } + } + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup location=%p type=%d: not found\n", p, type)); + return 0; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_pointer_enter(struct soap *soap, const void *p, const struct soap_array *a, int n, int type, struct soap_plist **ppp) +{ register int h; + register struct soap_plist *pp; + if (!soap->pblk || soap->pidx >= SOAP_PTRBLK) + { register struct soap_pblk *pb = (struct soap_pblk*)SOAP_MALLOC(soap, sizeof(struct soap_pblk)); + if (!pb) + { soap->error = SOAP_EOM; + return 0; + } + pb->next = soap->pblk; + soap->pblk = pb; + soap->pidx = 0; + } + *ppp = pp = &soap->pblk->plist[soap->pidx++]; + if (a) + h = soap_hash_ptr(a->__ptr); + else + h = soap_hash_ptr(p); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Pointer enter location=%p array=%p size=%d dim=%d type=%d id=%d\n", p, a?a->__ptr:NULL, a?a->__size:0, n, type, soap->idnum+1)); + pp->next = soap->pht[h]; + pp->type = type; + pp->mark1 = 0; + pp->mark2 = 0; + pp->ptr = p; + pp->array = a; + soap->pht[h] = pp; + pp->id = ++soap->idnum; + return pp->id; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_array_pointer_lookup(struct soap *soap, const void *p, const struct soap_array *a, int n, int type, struct soap_plist **ppp) +{ register struct soap_plist *pp; + *ppp = NULL; + if (!p || !a->__ptr) + return 0; + for (pp = soap->pht[soap_hash_ptr(a->__ptr)]; pp; pp = pp->next) + { if (pp->type == type && pp->array && pp->array->__ptr == a->__ptr) + { register int i; + for (i = 0; i < n; i++) + if (((const int*)&pp->array->__size)[i] != ((const int*)&a->__size)[i]) + break; + if (i == n) + { *ppp = pp; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array lookup location=%p type=%d id=%d\n", a->__ptr, type, pp->id)); + return pp->id; + } + } + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array lookup location=%p type=%d: not found\n", a->__ptr, type)); + return 0; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_begin_count(struct soap *soap) +{ +#ifndef WITH_LEANER + if ((soap->mode & SOAP_ENC_DIME) || (soap->omode & SOAP_ENC_DIME)) + soap->mode = soap->omode | SOAP_IO_LENGTH | SOAP_ENC_DIME; + else +#endif + { soap->mode = soap->omode; + if ((soap->mode & SOAP_IO) == SOAP_IO_STORE + || (((soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_ENC_XML)) +#ifndef WITH_LEANER + && !soap->fpreparesend +#endif + )) + soap->mode &= ~SOAP_IO_LENGTH; + else + soap->mode |= SOAP_IO_LENGTH; + } +#ifdef WITH_ZLIB + if ((soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) == SOAP_IO_FLUSH) + { if (!(soap->mode & SOAP_ENC_DIME)) + soap->mode &= ~SOAP_IO_LENGTH; + if (soap->mode & SOAP_ENC_XML) + soap->mode |= SOAP_IO_BUFFER; + else + soap->mode |= SOAP_IO_STORE; + } +#endif + if (!soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH)) + soap->mode |= SOAP_XML_TREE; +#ifndef WITH_LEANER + if ((soap->mode & SOAP_ENC_MTOM) && (soap->mode & SOAP_ENC_DIME)) + soap->mode |= SOAP_ENC_MIME; + else + soap->mode &= ~SOAP_ENC_MTOM; + if (soap->mode & SOAP_ENC_MIME) + soap_select_mime_boundary(soap); + soap->dime.list = soap->dime.last; /* keep track of last DIME attachment */ +#endif + soap->count = 0; + soap->ns = 0; + soap->null = 0; + soap->position = 0; + soap->mustUnderstand = 0; + soap->encoding = 0; + soap->part = SOAP_BEGIN; + soap->idnum = 0; + soap_clr_attr(soap); + soap_set_local_namespaces(soap); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin count phase (socket=%d mode=0x%x count=%lu)\n", soap->socket, soap->mode, (unsigned long)soap->count)); +#ifndef WITH_LEANER + soap->dime.count = 0; /* count # of attachments */ + soap->dime.size = 0; /* accumulate total size of attachments */ + if (soap->fprepareinit && (soap->mode & SOAP_IO) != SOAP_IO_STORE) + return soap->error = soap->fprepareinit(soap); +#endif + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_end_count(struct soap *soap) +{ +#ifndef WITH_LEANER + if (soap->fpreparefinal) + return soap->error = soap->fpreparefinal(soap); +#endif + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of count phase\n")); + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_begin_send(struct soap *soap) +{ soap->error = SOAP_OK; + soap->mode = soap->omode | (soap->mode & (SOAP_IO_LENGTH | SOAP_ENC_DIME)); +#ifdef WITH_ZLIB + if ((soap->mode & SOAP_ENC_ZLIB) && (soap->mode & SOAP_IO) == SOAP_IO_FLUSH) + { if (soap->mode & SOAP_ENC_XML) + soap->mode |= SOAP_IO_BUFFER; + else + soap->mode |= SOAP_IO_STORE; + } +#endif +#ifdef WITH_UDP + if ((soap->mode & SOAP_IO_UDP)) + { soap->mode |= SOAP_ENC_XML; + if (soap->count > SOAP_BUFLEN) + return soap->error = SOAP_UDP_ERROR; + } +#endif + if ((soap->mode & SOAP_IO) == SOAP_IO_FLUSH && soap_valid_socket(soap->socket)) + { if (soap->count || (soap->mode & SOAP_IO_LENGTH) || (soap->mode & SOAP_ENC_XML)) + soap->mode |= SOAP_IO_BUFFER; + else + soap->mode |= SOAP_IO_STORE; + } + soap->mode &= ~SOAP_IO_LENGTH; + if ((soap->mode & SOAP_IO) == SOAP_IO_STORE) + soap_new_block(soap); + if (!(soap->mode & SOAP_IO_KEEPALIVE)) + soap->keep_alive = 0; + if (!soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH)) + soap->mode |= SOAP_XML_TREE; +#ifndef WITH_LEANER + if ((soap->mode & SOAP_ENC_MTOM) && (soap->mode & SOAP_ENC_DIME)) + { soap->mode |= SOAP_ENC_MIME; + soap->mode &= ~SOAP_ENC_DIME; + } + else + soap->mode &= ~SOAP_ENC_MTOM; + if (soap->mode & SOAP_ENC_MIME) + soap_select_mime_boundary(soap); +#ifdef WIN32 +#ifndef UNDER_CE +#ifndef WITH_FASTCGI + if (!soap_valid_socket(soap->socket)) /* Set win32 stdout or soap->sendfd to BINARY, e.g. to support DIME */ +#ifdef __BORLANDC__ + setmode((SOAP_SOCKET)soap->sendfd, O_BINARY); +#else + _setmode((SOAP_SOCKET)soap->sendfd, _O_BINARY); +#endif +#endif +#endif +#endif +#endif + if (soap->mode & SOAP_IO) + { soap->bufidx = 0; + soap->buflen = 0; + } + soap->chunksize = 0; + soap->ns = 0; + soap->null = 0; + soap->position = 0; + soap->mustUnderstand = 0; + soap->encoding = 0; + soap->idnum = 0; + soap->level = 0; + soap_clr_attr(soap); + soap_set_local_namespaces(soap); +#ifdef WITH_ZLIB + soap->z_ratio_out = 1.0; + if ((soap->mode & SOAP_ENC_ZLIB) && soap->zlib_state != SOAP_ZLIB_DEFLATE) + { +#ifdef WITH_GZIP + memcpy(soap->z_buf, "\37\213\10\0\0\0\0\0\0\377", 10); + soap->d_stream.next_out = (Byte*)soap->z_buf + 10; + soap->d_stream.avail_out = SOAP_BUFLEN - 10; + soap->z_crc = crc32(0L, NULL, 0); + if (deflateInit2(&soap->d_stream, soap->z_level, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY) != Z_OK) +#else + soap->d_stream.next_out = (Byte*)soap->z_buf; + soap->d_stream.avail_out = SOAP_BUFLEN; + if (deflateInit(&soap->d_stream, soap->z_level) != Z_OK) +#endif + return soap->error = SOAP_ZLIB_ERROR; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflate initialized\n")); + soap->zlib_state = SOAP_ZLIB_DEFLATE; + } +#endif + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin send phase (socket=%d mode=0x%x count=%lu)\n", soap->socket, soap->mode, (unsigned long)soap->count)); + soap->part = SOAP_BEGIN; +#ifndef WITH_LEANER + if (soap->fprepareinit && (soap->mode & SOAP_IO) == SOAP_IO_STORE) + soap->fprepareinit(soap); +#endif + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_embedded(struct soap *soap, const void *p, int t) +{ struct soap_plist *pp; + if (soap_pointer_lookup(soap, p, t, &pp)) + { pp->mark1 = 1; + pp->mark2 = 1; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded %p type=%d mark set to 1\n", p, t)); + } +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_reference(struct soap *soap, const void *p, int t) +{ struct soap_plist *pp; + if (!p || (soap->mode & SOAP_XML_TREE)) + return 1; + if (soap_pointer_lookup(soap, p, t, &pp)) + { if (pp->mark1 == 0) + { pp->mark1 = 2; + pp->mark2 = 2; + } + } + else if (soap_pointer_enter(soap, p, NULL, 0, t, &pp)) + { pp->mark1 = 0; + pp->mark2 = 0; + } + else + return 1; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reference %p type=%d (%d %d)\n", p, t, (int)pp->mark1, (int)pp->mark2)); + return pp->mark1; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_array_reference(struct soap *soap, const void *p, const struct soap_array *a, int n, int t) +{ register int i; + struct soap_plist *pp; + if (!p || !a->__ptr) + return 1; + i = soap_array_pointer_lookup(soap, p, a, n, t, &pp); + if (i) + { if (pp->mark1 == 0) + { pp->mark1 = 2; + pp->mark2 = 2; + } + } + else if (!soap_pointer_enter(soap, p, a, n, t, &pp)) + return 1; + else + { pp->mark1 = 0; + pp->mark2 = 0; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Array reference %p ptr=%p dim=%d type=%d (%d %d)\n", p, a->__ptr, n, t, (int)pp->mark1, (int)pp->mark2)); + return pp->mark1; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_embedded_id(struct soap *soap, int id, const void *p, int t) +{ struct soap_plist *pp; + if (soap->mode & SOAP_XML_TREE) + return id; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id %p type=%d id=%d\n", p, t, id)); + if (soap->version == 1 && soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH) && soap->part != SOAP_IN_HEADER) + { if (id < 0) + { id = soap_pointer_lookup(soap, p, t, &pp); + if (id) + { if (soap->mode & SOAP_IO_LENGTH) + pp->mark1 = 2; + else + pp->mark2 = 2; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id multiref id=%d %p type=%d = (%d %d)\n", id, p, t, (int)pp->mark1, (int)pp->mark2)); + } + return -1; + } + return id; + } + if (id < 0) + id = soap_pointer_lookup(soap, p, t, &pp); + else if (id && !soap_pointer_lookup(soap, p, t, &pp)) + return 0; + if (id && pp) + { if (soap->mode & SOAP_IO_LENGTH) + pp->mark1 = 1; + else + pp->mark2 = 1; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Embedded_id embedded ref id=%d %p type=%d = (%d %d)\n", id, p, t, (int)pp->mark1, (int)pp->mark2)); + } + return id; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_is_embedded(struct soap *soap, struct soap_plist *pp) +{ if (!pp) + return 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Is embedded? %d %d\n", (int)pp->mark1, (int)pp->mark2)); + if (soap->version == 1 && soap->encodingStyle && !(soap->mode & SOAP_XML_GRAPH) && soap->part != SOAP_IN_HEADER) + { if (soap->mode & SOAP_IO_LENGTH) + return pp->mark1 != 0; + return pp->mark2 != 0; + } + if (soap->mode & SOAP_IO_LENGTH) + return pp->mark1 == 1; + return pp->mark2 == 1; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_is_single(struct soap *soap, struct soap_plist *pp) +{ if (soap->part == SOAP_IN_HEADER) + return 1; + if (!pp) + return 0; + if (soap->mode & SOAP_IO_LENGTH) + return pp->mark1 == 0; + return pp->mark2 == 0; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_set_embedded(struct soap *soap, struct soap_plist *pp) +{ if (!pp) + return; + if (soap->mode & SOAP_IO_LENGTH) + pp->mark1 = 1; + else + pp->mark2 = 1; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_attachment(struct soap *soap, const char *tag, int id, const void *p, const struct soap_array *a, const char *aid, const char *atype, const char *aoptions, int n, const char *type, int t) +{ struct soap_plist *pp; + int i; + if (!p || !a->__ptr || (!aid && !atype)) + return soap_element_id(soap, tag, id, p, a, n, type, t); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Attachment tag='%s' id='%s' (%d) type='%s'\n", tag, aid?aid:"", id, atype?atype:"")); + i = soap_array_pointer_lookup(soap, p, a, n, t, &pp); + if (!i) + { i = soap_pointer_enter(soap, p, a, n, t, &pp); + if (!i) + { soap->error = SOAP_EOM; + return -1; + } + } + if (id <= 0) + id = i; + if (!aid) + { sprintf(soap->tmpbuf, soap->dime_id_format, id); + aid = soap_strdup(soap, soap->tmpbuf); + } + /* Add MTOM xop:Include element when necessary */ + /* TODO: this code to be obsoleted with new import/xop.h conventions */ + if ((soap->mode & SOAP_ENC_MTOM) && strcmp(tag, "xop:Include")) + { if (soap_element_begin_out(soap, tag, 0, type) + || soap_element_href(soap, "xop:Include", 0, "href", aid) + || soap_element_end_out(soap, tag)) + return soap->error; + } + else if (soap_element_href(soap, tag, 0, "href", aid)) + return soap->error; + if (soap->mode & SOAP_IO_LENGTH) + { if (pp->mark1 != 3) + { struct soap_multipart *content; + if (soap->mode & SOAP_ENC_MTOM) + content = soap_new_multipart(soap, &soap->mime.first, &soap->mime.last, (char*)a->__ptr, a->__size); + else + content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, (char*)a->__ptr, a->__size); + if (!content) + { soap->error = SOAP_EOM; + return -1; + } + if (!strncmp(aid, "cid:", 4)) /* RFC 2111 */ + { if (soap->mode & SOAP_ENC_MTOM) + { char *s = (char*)soap_malloc(soap, strlen(aid) - 1); + if (s) + { *s = '<'; + strcpy(s + 1, aid + 4); + strcat(s, ">"); + content->id = s; + } + } + else + content->id = aid + 4; + } + else + content->id = aid; + content->type = atype; + content->options = aoptions; + content->encoding = SOAP_MIME_BINARY; + pp->mark1 = 3; + } + } + else + pp->mark2 = 3; + return -1; +} +#endif +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_1 +static void +soap_init_iht(struct soap *soap) +{ register int i; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing ID hashtable\n")); + for (i = 0; i < SOAP_IDHASH; i++) + soap->iht[i] = NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_1 +static void +soap_free_iht(struct soap *soap) +{ register int i; + register struct soap_ilist *ip, *p; + register struct soap_flist *fp, *fq; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free ID hashtable\n")); + for (i = 0; i < SOAP_IDHASH; i++) + { for (ip = soap->iht[i]; ip; ip = p) + { for (fp = ip->flist; fp; fp = fq) + { fq = fp->next; + SOAP_FREE(soap, fp); + } + p = ip->next; + SOAP_FREE(soap, ip); + } + soap->iht[i] = NULL; + } +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +struct soap_ilist * +SOAP_FMAC2 +soap_lookup(struct soap *soap, const char *id) +{ register struct soap_ilist *ip; + for (ip = soap->iht[soap_hash(id)]; ip; ip = ip->next) + if (!strcmp(ip->id, id)) + return ip; + return NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +struct soap_ilist * +SOAP_FMAC2 +soap_enter(struct soap *soap, const char *id) +{ register size_t h; + register struct soap_ilist *ip; + ip = (struct soap_ilist*)SOAP_MALLOC(soap, sizeof(struct soap_ilist) + strlen(id)); + if (ip) + { h = soap_hash(id); + strcpy(ip->id, id); + ip->next = soap->iht[h]; + soap->iht[h] = ip; + return ip; + } + return NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void* +SOAP_FMAC2 +soap_malloc(struct soap *soap, size_t n) +{ register char *p; + if (!n) + return (void*)SOAP_NON_NULL; + if (!soap) + return SOAP_MALLOC(soap, n); +#ifdef SOAP_DEBUG + n += sizeof(short); +#endif + n += (-(long)n) & (sizeof(void*)-1); /* align at 4-, 8- or 16-byte boundary */ + if (!(p = (char*)SOAP_MALLOC(soap, n + sizeof(void*) + sizeof(size_t)))) + { soap->error = SOAP_EOM; + return NULL; + } + /* keep chain of alloced cells for later destruction */ + soap->alloced = 1; +#ifdef SOAP_DEBUG + /* set the canary to detect corruption */ + *(short*)(p + n - sizeof(short)) = (short)SOAP_CANARY; +#endif + *(void**)(p + n) = soap->alist; + *(size_t*)(p + n + sizeof(void*)) = n; + soap->alist = p + n; + return p; +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +static void +soap_init_mht(struct soap *soap) +{ register int i; + for (i = 0; i < (int)SOAP_PTRHASH; i++) + soap->mht[i] = NULL; +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +static void +soap_free_mht(struct soap *soap) +{ register int i; + register struct soap_mlist *mp, *mq; + for (i = 0; i < (int)SOAP_PTRHASH; i++) + { for (mp = soap->mht[i]; mp; mp = mq) + { mq = mp->next; + if (mp->live) + fprintf(stderr, "%s(%d): malloc() = %p not freed (memory leak or forgot to call soap_end()?)\n", mp->file, mp->line, mp->ptr); + free(mp); + } + soap->mht[i] = NULL; + } +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +SOAP_FMAC1 +void* +SOAP_FMAC2 +soap_track_malloc(struct soap *soap, const char *file, int line, size_t size) +{ register void *p = malloc(size); + if (soap) + { register int h = soap_hash_ptr(p); + register struct soap_mlist *mp = (struct soap_mlist*)malloc(sizeof(struct soap_mlist)); + if (soap->fdebug[SOAP_INDEX_TEST]) + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): malloc(%lu) = %p\n", file, line, (unsigned long)size, p)); + mp->next = soap->mht[h]; + mp->ptr = p; + mp->file = file; + mp->line = line; + mp->live = 1; + soap->mht[h] = mp; + } + return p; +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_track_free(struct soap *soap, const char *file, int line, void *p) +{ register int h = soap_hash_ptr(p); + register struct soap_mlist *mp; + for (mp = soap->mht[h]; mp; mp = mp->next) + if (mp->ptr == p) + break; + if (mp) + { if (mp->live) + { free(p); + if (soap->fdebug[SOAP_INDEX_TEST]) + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "%s(%d): free(%p)\n", file, line, p)); + mp->live = 0; + } + else + fprintf(stderr, "%s(%d): free(%p) double free of pointer malloced at %s(%d)\n", file, line, p, mp->file, mp->line); + } + else + fprintf(stderr, "%s(%d): free(%p) pointer not malloced\n", file, line, p); +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +static void +soap_track_unlink(struct soap *soap, const void *p) +{ register int h = soap_hash_ptr(p); + register struct soap_mlist *mp; + for (mp = soap->mht[h]; mp; mp = mp->next) + if (mp->ptr == p) + break; + if (mp) + mp->live = 0; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_dealloc(struct soap *soap, void *p) +{ if (!soap) + return; + if (p) + { register char **q; + for (q = (char**)&soap->alist; *q; q = *(char***)q) + { +#ifdef SOAP_DEBUG + if (*(short*)(char*)(*q - sizeof(short)) != (short)SOAP_CANARY) + { fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n"); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n")); + DBGHEX(TEST, *q - 200, 200); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n")); + return; + } +#endif + if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*)))) + { *q = **(char***)q; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Freed data at %p\n", p)); + SOAP_FREE(soap, p); + return; + } + } + soap_delete(soap, p); + } + else + { register char *q; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free all soap_malloc() data\n")); + while (soap->alist) + { q = (char*)soap->alist; +#ifdef SOAP_DEBUG + if (*(short*)(char*)(q - sizeof(short)) != (short)SOAP_CANARY) + { fprintf(stderr, "Data corruption in dynamic allocation (see logs)\n"); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Data corruption:\n")); + DBGHEX(TEST, q - 200, 200); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n")); + return; + } +#endif + soap->alist = *(void**)q; + q -= *(size_t*)(q + sizeof(void*)); + SOAP_FREE(soap, q); + } + } + /* we must assume these were deallocated: */ + soap->action = NULL; + soap->fault = NULL; + soap->header = NULL; + soap->userid = NULL; + soap->passwd = NULL; + soap->authrealm = NULL; +#ifndef WITH_LEANER + soap_clr_mime(soap); +#endif +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_delete(struct soap *soap, void *p) +{ register struct soap_clist **cp; + if (soap_check_state(soap)) + return; + cp = &soap->clist; + if (p) + { while (*cp) + { if (p == (*cp)->ptr) + { register struct soap_clist *q = *cp; + *cp = q->next; + q->fdelete(q); + SOAP_FREE(soap, q); + return; + } + cp = &(*cp)->next; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not dealloc data %p: address not in list\n", p)); + } + else + { while (*cp) + { register struct soap_clist *q = *cp; + *cp = q->next; + q->fdelete(q); + SOAP_FREE(soap, q); + } + } +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +struct soap_clist * +SOAP_FMAC2 +soap_link(struct soap *soap, void *p, int t, int n, void (*fdelete)(struct soap_clist*)) +{ register struct soap_clist *cp; + if ((cp = (struct soap_clist*)SOAP_MALLOC(soap, sizeof(struct soap_clist)))) + { cp->next = soap->clist; + cp->type = t; + cp->size = n; + cp->ptr = p; + cp->fdelete = fdelete; + soap->clist = cp; + } + return cp; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_unlink(struct soap *soap, const void *p) +{ register char **q; + register struct soap_clist **cp; + if (!soap || !p) + return; + for (q = (char**)&soap->alist; *q; q = *(char***)q) + { if (p == (void*)(*q - *(size_t*)(*q + sizeof(void*)))) + { *q = **(char***)q; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked data %p\n", p)); +#ifdef SOAP_DEBUG + soap_track_unlink(soap, p); +#endif + return; + } + } + for (cp = &soap->clist; *cp; cp = &(*cp)->next) + { if (p == (*cp)->ptr) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unlinked class instance %p\n", p)); + q = (char**)*cp; + *cp = (*cp)->next; + SOAP_FREE(soap, q); + return; + } + } +} +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_lookup_type(struct soap *soap, const char *id) +{ register struct soap_ilist *ip; + if (id && *id) + { ip = soap_lookup(soap, id); + if (ip) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Lookup id='%s' type=%d\n", id, ip->type)); + return ip->type; + } + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "lookup type id='%s' NOT FOUND! Need to get it from xsi:type\n", id)); + return 0; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +void* +SOAP_FMAC2 +soap_id_lookup(struct soap *soap, const char *id, void **p, int t, size_t n, unsigned int k) +{ struct soap_ilist *ip; + void **q; + if (!p || !id || !*id) + return p; + ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */ + if (!ip) + { ip = soap_enter(soap, id); /* new hash table entry for string id */ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding first href='%s' type=%d %p (%u bytes)\n", id, t, p, (unsigned int)n)); + ip->type = t; + ip->size = n; + ip->link = p; + ip->copy = NULL; + ip->flist = NULL; + ip->ptr = NULL; + ip->level = k; + *p = NULL; + } + else if (ip->ptr) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolved href='%s' type=%d location=%p (%u bytes)\n", id, t, ip->ptr, (unsigned int)n)); + if (ip->type != t) + { strcpy(soap->id, id); + soap->error = SOAP_HREF; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Type incompatibility: id type=%d href type=%d\n", ip->type, t)); + return NULL; + } + while (ip->level < k) + { q = (void**)soap_malloc(soap, sizeof(void*)); + if (!q) + return NULL; + *p = (void*)q; + p = q; + k--; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level...\n")); + } + *p = ip->ptr; + } + else if (ip->level > k) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving level %u pointers to href='%s'\n", ip->level, id)); + while (ip->level > k) + { void *s, **r = &ip->link; + q = (void**)ip->link; + while (q) + { *r = (void*)soap_malloc(soap, sizeof(void*)); + s = *q; + *q = *r; + r = (void**)*r; + q = (void**)s; + } + *r = NULL; + ip->size = n; + ip->copy = NULL; + ip->level = ip->level - 1; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level...\n")); + } + q = (void**)ip->link; + ip->link = p; + *p = (void*)q; + } + else + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarded href='%s' type=%d location=%p (%u bytes)\n", id, t, p, (unsigned int)n)); + while (ip->level < k) + { q = (void**)soap_malloc(soap, sizeof(void*)); + *p = q; + p = q; + k--; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Descending one level...\n")); + } + q = (void**)ip->link; + ip->link = p; + *p = (void*)q; + } + return p; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIDREF +#ifndef PALM_2 +SOAP_FMAC1 +void* +SOAP_FMAC2 +soap_id_forward(struct soap *soap, const char *href, void *p, size_t len, int st, int tt, size_t n, unsigned int k, void (*fcopy)(struct soap*, int, int, void*, size_t, const void*, size_t)) +{ struct soap_ilist *ip; + if (!p || !href || !*href) + return p; + ip = soap_lookup(soap, href); /* lookup pointer to hash table entry for string id */ + if (!ip) + { ip = soap_enter(soap, href); /* new hash table entry for string id */ + ip->type = st; + ip->size = n; + ip->link = NULL; + ip->copy = NULL; + ip->ptr = NULL; + ip->level = 0; + ip->flist = NULL; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "New entry href='%s' type=%d size=%lu level=%d location=%p\n", href, st, (unsigned long)n, k, p)); + } + else if (ip->type != st || (ip->level == k && ip->size != n)) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Type incompatibility id='%s' expect type=%d size=%lu level=%u got type=%d size=%lu\n", href, ip->type, (unsigned long)ip->size, k, st, (unsigned long)n)); + strcpy(soap->id, href); + soap->error = SOAP_HREF; + return NULL; + } + if (fcopy || n < sizeof(void*) || *href != '#') + { register struct soap_flist *fp = (struct soap_flist*)SOAP_MALLOC(soap, sizeof(struct soap_flist)); + if (!fp) + { soap->error = SOAP_EOM; + return NULL; + } + fp->next = ip->flist; + fp->type = tt; + fp->ptr = p; + fp->level = k; + fp->len = len; + if (fcopy) + fp->fcopy = fcopy; + else + fp->fcopy = soap_fcopy; + ip->flist = fp; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding type=%d (target type=%d) size=%lu location=%p level=%u len=%lu href='%s'\n", st, tt, (unsigned long)n, p, k, (unsigned long)len, href)); + } + else + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Forwarding copying address %p for type=%d href='%s'\n", p, st, href)); + *(void**)p = ip->copy; + ip->copy = p; + } + return p; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void* +SOAP_FMAC2 +soap_id_enter(struct soap *soap, const char *id, void *p, int t, size_t n, unsigned int k, const char *type, const char *arrayType, void *(*finstantiate)(struct soap*, int, const char*, const char*, size_t*)) +{ +#ifndef WITH_NOIDREF + struct soap_ilist *ip; +#endif + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Enter id='%s' type=%d loc=%p size=%lu level=%u\n", id, t, p, (unsigned long)n, k)); + soap->alloced = 0; + if (!p) + { if (finstantiate) + p = finstantiate(soap, t, type, arrayType, &n); + else + p = soap_malloc(soap, n); + if (p) + soap->alloced = 1; + } +#ifndef WITH_NOIDREF + if (!id || !*id) +#endif + return p; +#ifndef WITH_NOIDREF + ip = soap_lookup(soap, id); /* lookup pointer to hash table entry for string id */ + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Lookup entry id='%s for location=%p'\n", id, p)); + if (!ip) + { ip = soap_enter(soap, id); /* new hash table entry for string id */ + ip->type = t; + ip->link = NULL; + ip->copy = NULL; + ip->flist = NULL; + ip->size = n; + ip->ptr = p; + ip->level = k; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "New entry id='%s' type=%d size=%lu level=%u location=%p\n", id, t, (unsigned long)n, k, p)); + } + else if ((ip->type != t || (ip->level == k && ip->size != n)) && (ip->copy || ip->flist)) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Type incompatibility id='%s' expect type=%d size=%lu level=%u got type=%d size=%lu\n", id, ip->type, (unsigned long)ip->size, k, t, (unsigned long)n)); + strcpy(soap->id, id); + soap->error = SOAP_HREF; + return NULL; + } + else if (ip->ptr) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Multiply defined id='%s'\n", id)); + strcpy(soap->id, id); + soap->error = SOAP_DUPLICATE_ID; + return NULL; + } + else + { ip->size = n; + ip->ptr = p; + ip->level = k; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Update entry id='%s' type=%d location=%p size=%lu level=%u\n", id, t, p, (unsigned long)n, k)); + } + return ip->ptr; +#endif +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_fcopy(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n) +{ DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Copying data type=%d (target type=%d) %p -> %p (%lu bytes)\n", st, tt, q, p, (unsigned long)n)); + memcpy(p, q, n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_end_send(struct soap *soap) +{ +#ifndef WITH_LEANER + if (soap->dime.list) + { /* SOAP body referenced attachments must appear first */ + soap->dime.last->next = soap->dime.first; + soap->dime.first = soap->dime.list->next; + soap->dime.list->next = NULL; + soap->dime.last = soap->dime.list; + } + if (soap_putdime(soap) || soap_putmime(soap)) + return soap->error; + soap->mime.list = NULL; + soap->mime.first = NULL; + soap->mime.last = NULL; + soap->dime.list = NULL; + soap->dime.first = NULL; + soap->dime.last = NULL; +#endif + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End send\n")); + if (soap->mode & SOAP_IO) /* need to flush the remaining data in buffer */ + { if (soap_flush(soap)) +#ifdef WITH_ZLIB + { if (soap->mode & SOAP_ENC_ZLIB && soap->zlib_state == SOAP_ZLIB_DEFLATE) + { soap->zlib_state = SOAP_ZLIB_NONE; + deflateEnd(&soap->d_stream); + } + return soap->error; + } +#else + return soap->error; +#endif +#ifdef WITH_ZLIB + if (soap->mode & SOAP_ENC_ZLIB) + { int r; + soap->d_stream.avail_in = 0; + do + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflating remainder\n")); + r = deflate(&soap->d_stream, Z_FINISH); + if (soap->d_stream.avail_out != SOAP_BUFLEN) + { if (soap_flush_raw(soap, soap->z_buf, SOAP_BUFLEN - soap->d_stream.avail_out)) + { soap->zlib_state = SOAP_ZLIB_NONE; + deflateEnd(&soap->d_stream); + return soap->error; + } + soap->d_stream.next_out = (Byte*)soap->z_buf; + soap->d_stream.avail_out = SOAP_BUFLEN; + } + } while (r == Z_OK); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Deflated %lu->%lu bytes\n", soap->d_stream.total_in, soap->d_stream.total_out)); + soap->z_ratio_out = (float)soap->d_stream.total_out / (float)soap->d_stream.total_in; + soap->mode &= ~SOAP_ENC_ZLIB; + soap->zlib_state = SOAP_ZLIB_NONE; + if (deflateEnd(&soap->d_stream) != Z_OK || r != Z_STREAM_END) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unable to end deflate: %s\n", soap->d_stream.msg?soap->d_stream.msg:"")); + return soap->error = SOAP_ZLIB_ERROR; + } +#ifdef WITH_GZIP + soap->z_buf[0] = soap->z_crc & 0xFF; + soap->z_buf[1] = (soap->z_crc >> 8) & 0xFF; + soap->z_buf[2] = (soap->z_crc >> 16) & 0xFF; + soap->z_buf[3] = (soap->z_crc >> 24) & 0xFF; + soap->z_buf[4] = soap->d_stream.total_in & 0xFF; + soap->z_buf[5] = (soap->d_stream.total_in >> 8) & 0xFF; + soap->z_buf[6] = (soap->d_stream.total_in >> 16) & 0xFF; + soap->z_buf[7] = (soap->d_stream.total_in >> 24) & 0xFF; + if (soap_flush_raw(soap, soap->z_buf, 8)) + return soap->error; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip crc32=%lu\n", (unsigned long)soap->z_crc)); +#endif + } +#endif + if ((soap->mode & SOAP_IO) == SOAP_IO_STORE) + { char *p; +#ifndef WITH_NOHTTP + if (!(soap->mode & SOAP_ENC_XML)) + { soap->mode--; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending buffered message of length %u\n", (unsigned int)soap->blist->size)); + if (soap->status >= SOAP_POST) + soap->error = soap->fpost(soap, soap->endpoint, soap->host, soap->port, soap->path, soap->action, soap->blist->size); + else if (soap->status != SOAP_STOP) + soap->error = soap->fresponse(soap, soap->status, soap->blist->size); + if (soap->error || soap_flush(soap)) + return soap->error; + soap->mode++; + } +#endif + for (p = soap_first_block(soap); p; p = soap_next_block(soap)) + { DBGMSG(SENT, p, soap_block_size(soap)); + if ((soap->error = soap->fsend(soap, p, soap_block_size(soap)))) + { soap_end_block(soap); + return soap->error; + } + } + soap_end_block(soap); + } +#ifndef WITH_LEANER + else if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) + { DBGMSG(SENT, "\r\n0\r\n\r\n", 7); + if ((soap->error = soap->fsend(soap, "\r\n0\r\n\r\n", 7))) + return soap->error; + } +#endif + } +#ifdef WITH_TCPFIN +#ifdef WITH_OPENSSL + if (!soap->ssl && soap_valid_socket(soap->socket) && !soap->keep_alive && !(soap->omode & SOAP_IO_UDP)) + soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 1); /* Send TCP FIN */ +#else + if (soap_valid_socket(soap->socket) && !soap->keep_alive && !(soap->omode & SOAP_IO_UDP)) + soap->fshutdownsocket(soap, (SOAP_SOCKET)soap->socket, 1); /* Send TCP FIN */ +#endif +#endif + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of send phase\n")); + soap->omode &= ~SOAP_XML_SEC; + soap->count = 0; + soap->part = SOAP_END; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_end_recv(struct soap *soap) +{ soap->part = SOAP_END; +#ifndef WITH_LEANER + if ((soap->mode & SOAP_ENC_DIME) && soap_getdime(soap)) + return soap->error; + soap->dime.list = soap->dime.first; + soap->dime.first = NULL; + soap->dime.last = NULL; + /* Check if MIME attachments and mime-post-check flag is set, if set call soap_resolve() and return */ + if (soap->mode & SOAP_ENC_MIME) + { if (soap->mode & SOAP_MIME_POSTCHECK) + { soap_resolve(soap); + return SOAP_OK; + } + if (soap_getmime(soap)) + return soap->error; + } + soap->mime.list = soap->mime.first; + soap->mime.first = NULL; + soap->mime.last = NULL; + soap->mime.boundary = NULL; +#endif + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "End of receive message ok\n")); +#ifdef WITH_ZLIB + if (soap->mode & SOAP_ENC_ZLIB) + { soap->mode &= ~SOAP_ENC_ZLIB; + memcpy(soap->buf, soap->z_buf, SOAP_BUFLEN); + soap->bufidx = (char*)soap->d_stream.next_in - soap->z_buf; + soap->buflen = soap->z_buflen; + soap->zlib_state = SOAP_ZLIB_NONE; + if (inflateEnd(&soap->d_stream) != Z_OK) + return soap->error = SOAP_ZLIB_ERROR; +#ifdef WITH_GZIP + if (soap->zlib_in == SOAP_ZLIB_GZIP) + { soap_wchar c; + short i; + for (i = 0; i < 8; i++) + { if ((int)(c = soap_getchar(soap)) == EOF) + return soap->error = SOAP_EOF; + soap->z_buf[i] = (char)c; + } + if (soap->z_crc != ((uLong)(unsigned char)soap->z_buf[0] | ((uLong)(unsigned char)soap->z_buf[1] << 8) | ((uLong)(unsigned char)soap->z_buf[2] << 16) | ((uLong)(unsigned char)soap->z_buf[3] << 24))) + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Gzip error: crc check failed, message corrupted? (crc32=%lu)\n", (unsigned long)soap->z_crc)); + return soap->error = SOAP_ZLIB_ERROR; + } + if (soap->d_stream.total_out != ((uLong)(unsigned char)soap->z_buf[4] | ((uLong)(unsigned char)soap->z_buf[5] << 8) | ((uLong)(unsigned char)soap->z_buf[6] << 16) | ((uLong)(unsigned char)soap->z_buf[7] << 24))) + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Gzip error: incorrect message length\n")); + return soap->error = SOAP_ZLIB_ERROR; + } + } +#endif + } +#endif + if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) + while ((int)soap_getchar(soap) != EOF) /* advance to last chunk */ + ; + if (soap->fdisconnect && (soap->error = soap->fdisconnect(soap))) + return soap->error; +#ifndef WITH_NOIDREF + return soap_resolve(soap); +#else +#ifndef WITH_LEANER + if (soap->xlist) + { if (soap->mode & SOAP_ENC_MTOM) + return soap->error = SOAP_MIME_HREF; + return soap->error = SOAP_DIME_HREF; + } +#endif + return SOAP_OK; +#endif +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_free(struct soap *soap) +{ register struct Namespace *ns; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free namespace stack\n")); + while (soap->nlist) + { register struct soap_nlist *np = soap->nlist->next; + SOAP_FREE(soap, soap->nlist); + soap->nlist = np; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free any remaining temp blocks\n")); + while (soap->blist) + soap_end_block(soap); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute storage\n")); + while (soap->attributes) + { register struct soap_attribute *tp = soap->attributes->next; + if (soap->attributes->value) + SOAP_FREE(soap, soap->attributes->value); + SOAP_FREE(soap, soap->attributes); + soap->attributes = tp; + } +#ifdef WITH_FAST + if (soap->labbuf) + SOAP_FREE(soap, soap->labbuf); + soap->labbuf = NULL; + soap->lablen = 0; + soap->labidx = 0; +#endif + ns = soap->local_namespaces; + if (ns) + { for (; ns->id; ns++) + { if (ns->out) + { if (soap->encodingStyle == ns->out) + soap->encodingStyle = SOAP_STR_EOS; + SOAP_FREE(soap, ns->out); + ns->out = NULL; + } + if (soap->encodingStyle == ns->ns) + soap->encodingStyle = SOAP_STR_EOS; + } + SOAP_FREE(soap, soap->local_namespaces); + soap->local_namespaces = NULL; + } +#ifndef WITH_LEANER + while (soap->xlist) + { struct soap_xlist *xp = soap->xlist->next; + SOAP_FREE(soap, soap->xlist); + soap->xlist = xp; + } +#endif +#ifndef WITH_NOIDREF + soap_free_pht(soap); + soap_free_iht(soap); +#endif +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +static void +soap_init_logs(struct soap *soap) +{ int i; + for (i = 0; i < SOAP_MAXLOGS; i++) + { soap->logfile[i] = NULL; + soap->fdebug[i] = NULL; + } +} +#endif + +/******************************************************************************/ +#if !defined(WITH_LEAN) || defined(SOAP_DEBUG) +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_open_logfile(struct soap *soap, int i) +{ if (soap->logfile[i]) + soap->fdebug[i] = fopen(soap->logfile[i], i < 2 ? "ab" : "a"); +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +static void +soap_close_logfile(struct soap *soap, int i) +{ if (soap->fdebug[i]) + { fclose(soap->fdebug[i]); + soap->fdebug[i] = NULL; + } +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_close_logfiles(struct soap *soap) +{ int i; + for (i = 0; i < SOAP_MAXLOGS; i++) + soap_close_logfile(soap, i); +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +static void +soap_set_logfile(struct soap *soap, int i, const char *logfile) +{ char *s = NULL; + soap_close_logfile(soap, i); + if (soap->logfile[i]) + SOAP_FREE(soap, (void*)soap->logfile[i]); + if (logfile) + if ((s = (char*)SOAP_MALLOC(soap, strlen(logfile) + 1))) + strcpy(s, logfile); + soap->logfile[i] = s; +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_set_recv_logfile(struct soap *soap, const char *logfile) +{ soap_set_logfile(soap, SOAP_INDEX_RECV, logfile); +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_set_sent_logfile(struct soap *soap, const char *logfile) +{ soap_set_logfile(soap, SOAP_INDEX_SENT, logfile); +} +#endif + +/******************************************************************************/ +#ifdef SOAP_DEBUG +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_set_test_logfile(struct soap *soap, const char *logfile) +{ soap_set_logfile(soap, SOAP_INDEX_TEST, logfile); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +struct soap* +SOAP_FMAC2 +soap_copy(struct soap *soap) +{ return soap_copy_context((struct soap*)malloc(sizeof(struct soap)), soap); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +struct soap* +SOAP_FMAC2 +soap_copy_context(struct soap *copy, struct soap *soap) +{ if (soap_check_state(soap)) + return NULL; + if (copy) + { register struct soap_plugin *p; + memcpy(copy, soap, sizeof(struct soap)); + copy->state = SOAP_COPY; + copy->error = SOAP_OK; + copy->userid = NULL; + copy->passwd = NULL; + copy->nlist = NULL; + copy->blist = NULL; + copy->clist = NULL; + copy->alist = NULL; + copy->attributes = NULL; +#ifdef WITH_FAST + copy->labbuf = NULL; + copy->lablen = 0; + copy->labidx = 0; +#endif +#ifdef SOAP_DEBUG + soap_init_mht(copy); +#endif + copy->local_namespaces = NULL; +#ifndef WITH_NOIDREF + soap_init_iht(copy); + soap_init_pht(copy); +#endif + copy->header = NULL; + copy->fault = NULL; + copy->action = NULL; +#ifndef WITH_LEAN +#ifdef WITH_COOKIES + copy->cookies = soap_copy_cookies(copy, soap); +#else + copy->cookies = NULL; +#endif +#endif +#ifdef SOAP_DEBUG + soap_init_logs(copy); + soap_set_recv_logfile(copy, soap->logfile[SOAP_INDEX_RECV]); + soap_set_sent_logfile(copy, soap->logfile[SOAP_INDEX_SENT]); + soap_set_test_logfile(copy, soap->logfile[SOAP_INDEX_TEST]); +#endif + copy->plugins = NULL; + for (p = soap->plugins; p; p = p->next) + { register struct soap_plugin *q = (struct soap_plugin*)SOAP_MALLOC(copy, sizeof(struct soap_plugin)); + if (!q) + return NULL; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying plugin '%s'\n", p->id)); + *q = *p; + if (p->fcopy && (soap->error = p->fcopy(copy, q, p))) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not copy plugin '%s'\n", p->id)); + SOAP_FREE(copy, q); + return NULL; + } + q->next = copy->plugins; + copy->plugins = q; + } + } + else + soap->error = SOAP_EOM; + return copy; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_copy_stream(struct soap *copy, struct soap *soap) +{ copy->mode = soap->mode; + copy->imode = soap->imode; + copy->omode = soap->omode; + copy->socket = soap->socket; + copy->recv_timeout = soap->recv_timeout; + copy->send_timeout = soap->send_timeout; +#if defined(__cplusplus) && !defined(WITH_LEAN) + copy->os = soap->os; + copy->is = soap->is; +#endif + copy->sendfd = soap->sendfd; + copy->recvfd = soap->recvfd; + copy->bufidx = soap->bufidx; + copy->buflen = soap->buflen; + copy->ahead = soap->ahead; + copy->cdata = soap->cdata; + copy->chunksize = soap->chunksize; + copy->chunkbuflen = soap->chunkbuflen; + copy->keep_alive = soap->keep_alive; + copy->max_keep_alive = soap->max_keep_alive; + copy->peer = soap->peer; + copy->peerlen = soap->peerlen; +#ifdef WITH_OPENSSL + copy->bio = soap->bio; + copy->ssl = soap->ssl; + copy->ctx = soap->ctx; +#endif +#ifdef WITH_ZLIB + copy->zlib_state = soap->zlib_state; + copy->zlib_in = soap->zlib_in; + copy->zlib_out = soap->zlib_out; + copy->d_stream = soap->d_stream; + copy->z_buflen = soap->z_buflen; + copy->z_level = soap->z_level; + copy->z_crc = soap->z_crc; + copy->z_ratio_in = soap->z_ratio_in; + copy->z_ratio_out = soap->z_ratio_out; + memcpy(copy->z_buf, soap->z_buf, sizeof(soap->z_buf)); +#endif + memcpy(copy->buf, soap->buf, sizeof(soap->buf)); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_init(struct soap *soap) +{ soap->state = SOAP_INIT; + soap->version = 0; + soap_imode(soap, SOAP_IO_DEFAULT); + soap_omode(soap, SOAP_IO_DEFAULT); + soap->plugins = NULL; + soap->user = NULL; + soap->userid = NULL; + soap->passwd = NULL; +#ifndef WITH_NOHTTP + soap->fpost = http_post; + soap->fget = http_get; + soap->fform = NULL; + soap->fposthdr = http_post_header; + soap->fresponse = http_response; + soap->fparse = http_parse; + soap->fparsehdr = http_parse_header; +#endif + soap->fheader = NULL; + soap->fconnect = NULL; + soap->fdisconnect = NULL; +#ifndef WITH_NOIO +#ifndef WITH_IPV6 + soap->fresolve = tcp_gethost; +#else + soap->fresolve = NULL; +#endif + soap->faccept = tcp_accept; + soap->fopen = tcp_connect; + soap->fclose = tcp_disconnect; + soap->fclosesocket = tcp_closesocket; + soap->fshutdownsocket = tcp_shutdownsocket; + soap->fsend = fsend; + soap->frecv = frecv; + soap->fpoll = soap_poll; +#else + soap->fopen = NULL; + soap->fclose = NULL; + soap->fpoll = NULL; +#endif + soap->fseterror = NULL; + soap->fignore = NULL; + soap->fserveloop = NULL; + soap->fplugin = fplugin; +#ifndef WITH_LEANER + soap->fprepareinit = NULL; + soap->fpreparesend = NULL; + soap->fpreparerecv = NULL; + soap->fpreparefinal = NULL; + soap->fdimereadopen = NULL; + soap->fdimewriteopen = NULL; + soap->fdimereadclose = NULL; + soap->fdimewriteclose = NULL; + soap->fdimeread = NULL; + soap->fdimewrite = NULL; + soap->fmimereadopen = NULL; + soap->fmimewriteopen = NULL; + soap->fmimereadclose = NULL; + soap->fmimewriteclose = NULL; + soap->fmimeread = NULL; + soap->fmimewrite = NULL; +#endif + soap->float_format = "%G"; + soap->double_format = "%lG"; + soap->dime_id_format = "cid:id%d"; /* default DIME id format */ + soap->http_version = "1.1"; + soap->http_content = NULL; + soap->actor = NULL; + soap->max_keep_alive = SOAP_MAXKEEPALIVE; + soap->keep_alive = 0; + soap->recv_timeout = 0; + soap->send_timeout = 0; + soap->connect_timeout = 0; + soap->accept_timeout = 0; + soap->socket_flags = 0; + soap->connect_flags = 0; + soap->bind_flags = 0; + soap->accept_flags = 0; + soap->ip = 0; +#ifdef WITH_FAST + soap->labbuf = NULL; + soap->lablen = 0; + soap->labidx = 0; +#endif + soap->encodingStyle = SOAP_STR_EOS; +#ifndef WITH_NONAMESPACES + soap->namespaces = namespaces; +#else + soap->namespaces = NULL; +#endif + soap->local_namespaces = NULL; + soap->nlist = NULL; + soap->blist = NULL; + soap->clist = NULL; + soap->alist = NULL; + soap->attributes = NULL; + soap->header = NULL; + soap->fault = NULL; + soap->master = SOAP_INVALID_SOCKET; + soap->socket = SOAP_INVALID_SOCKET; + soap->os = NULL; + soap->is = NULL; +#ifndef WITH_LEANER + soap->dom = NULL; + soap->dime.list = NULL; + soap->dime.first = NULL; + soap->dime.last = NULL; + soap->mime.list = NULL; + soap->mime.first = NULL; + soap->mime.last = NULL; + soap->mime.boundary = NULL; + soap->mime.start = NULL; + soap->xlist = NULL; +#endif +#ifndef UNDER_CE + soap->recvfd = 0; + soap->sendfd = 1; +#else + soap->recvfd = stdin; + soap->sendfd = stdout; +#endif + soap->host[0] = '\0'; + soap->port = 0; + soap->action = NULL; + soap->proxy_host = NULL; + soap->proxy_port = 8080; + soap->proxy_userid = NULL; + soap->proxy_passwd = NULL; + soap->authrealm = NULL; + soap->prolog = NULL; +#ifdef WITH_OPENSSL + if (!ssl_init_done) + soap_ssl_init(); + soap->fsslauth = ssl_auth_init; + soap->fsslverify = ssl_verify_callback; + soap->bio = NULL; + soap->ssl = NULL; + soap->ctx = NULL; + soap->require_server_auth = 0; + soap->require_client_auth = 0; + soap->rsa = 0; + soap->keyfile = NULL; + soap->password = NULL; + soap->dhfile = NULL; + soap->cafile = NULL; + soap->capath = NULL; + soap->crlfile = NULL; + soap->randfile = NULL; + soap->session = NULL; +#endif +#ifdef WITH_ZLIB + soap->zlib_state = SOAP_ZLIB_NONE; + soap->zlib_in = SOAP_ZLIB_NONE; + soap->zlib_out = SOAP_ZLIB_NONE; + soap->d_stream.zalloc = NULL; + soap->d_stream.zfree = NULL; + soap->d_stream.opaque = NULL; + soap->z_level = 6; +#endif +#ifndef WITH_LEAN + soap->c14ninclude = NULL; + soap->c14nexclude = NULL; + soap->cookies = NULL; + soap->cookie_domain = NULL; + soap->cookie_path = NULL; + soap->cookie_max = 32; +#endif +#ifdef SOAP_DEBUG + soap_init_mht(soap); + soap_init_logs(soap); + soap_set_recv_logfile(soap, "RECV.log"); + soap_set_sent_logfile(soap, "SENT.log"); + soap_set_test_logfile(soap, NULL); +#endif +#ifdef WMW_RPM_IO + soap->rpmreqid = NULL; +#endif +#ifdef PALM + palmNetLibOpen(); +#endif +#ifndef WITH_NOIDREF + soap_init_iht(soap); + soap_init_pht(soap); +#endif + soap_begin(soap); +#ifdef SOAP_DEBUG + soap_set_test_logfile(soap, "TEST.log"); +#endif +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_init1(struct soap *soap, soap_mode mode) +{ soap_init2(soap, mode, mode); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_init2(struct soap *soap, soap_mode imode, soap_mode omode) +{ soap_init(soap); + soap_imode(soap, imode); + soap_omode(soap, omode); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_begin(struct soap *soap) +{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Initializing\n")); + if (!soap->keep_alive) + { soap->buflen = 0; + soap->bufidx = 0; + } + soap->keep_alive = (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0); + soap->null = 0; + soap->position = 0; + soap->encoding = 0; + soap->mustUnderstand = 0; + soap->mode = 0; + soap->ns = 0; + soap->part = SOAP_END; + soap->alloced = 0; + soap->count = 0; + soap->length = 0; + soap->cdata = 0; + soap->error = SOAP_OK; + soap->peeked = 0; + soap->ahead = 0; + soap->idnum = 0; + soap->level = 0; + soap->endpoint[0] = '\0'; +#ifndef WITH_LEANER + soap->dime.chunksize = 0; + soap->dime.buflen = 0; +#endif + soap_free(soap); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_end(struct soap *soap) +{ register struct soap_clist *cp; + if (soap_check_state(soap)) + return; + soap_free(soap); + soap_dealloc(soap, NULL); + while (soap->clist) + { cp = soap->clist->next; + SOAP_FREE(soap, soap->clist); + soap->clist = cp; + } + soap_closesock(soap); +#ifdef SOAP_DEBUG + soap_close_logfiles(soap); +#endif +#ifdef PALM + palmNetLibClose(); +#endif +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_set_namespaces(struct soap *soap, const struct Namespace *p) +{ register struct Namespace *ns = soap->local_namespaces; + register struct soap_nlist *np, *nq, *nr; + register unsigned int level = soap->level; + soap->namespaces = p; + soap->local_namespaces = NULL; + soap_set_local_namespaces(soap); + /* reverse the namespace list */ + np = soap->nlist; + soap->nlist = NULL; + if (np) + { nq = np->next; + np->next = NULL; + while (nq) + { nr = nq->next; + nq->next = np; + np = nq; + nq = nr; + } + } + /* then push on new stack */ + while (np) + { register const char *s; + soap->level = np->level; /* preserve element nesting level */ + s = np->ns; + if (!s && np->index >= 0 && ns) + { s = ns[np->index].out; + if (!s) + s = ns[np->index].ns; + } + if (s && soap_push_namespace(soap, np->id, s)) + return soap->error; + nq = np; + np = np->next; + SOAP_FREE(soap, nq); + } + if (ns) + { register int i; + for (i = 0; ns[i].id; i++) + { if (ns[i].out) + { SOAP_FREE(soap, ns[i].out); + ns[i].out = NULL; + } + } + SOAP_FREE(soap, ns); + } + soap->level = level; /* restore level */ + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_set_local_namespaces(struct soap *soap) +{ if (soap->namespaces && !soap->local_namespaces) + { register const struct Namespace *ns1; + register struct Namespace *ns2; + register size_t n = 1; + for (ns1 = soap->namespaces; ns1->id; ns1++) + n++; + n *= sizeof(struct Namespace); + ns2 = (struct Namespace*)SOAP_MALLOC(soap, n); + if (ns2) + { memcpy(ns2, soap->namespaces, n); + if (ns2[0].ns) + { if (!strcmp(ns2[0].ns, soap_env1)) + soap->version = 1; + else + soap->version = 2; + } + soap->local_namespaces = ns2; + } + } +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +#ifndef PALM_1 +SOAP_FMAC1 +const char * +SOAP_FMAC2 +soap_strsearch(const char *big, const char *little) +{ size_t n = strlen(little); + const char *s = big; + while (s) + { if (!strncmp(s, little, n) && (s[n] == '\0' || s[n] == ' ')) + return s; + s = strchr(s, ' '); + if (s) + s++; + } + return NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +static struct soap_nlist * +soap_lookup_ns(struct soap *soap, const char *tag, size_t n) +{ register struct soap_nlist *np; + for (np = soap->nlist; np; np = np->next) + { if (!strncmp(np->id, tag, n) && !np->id[n]) + return np; + } + return NULL; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +static struct soap_nlist * +soap_push_ns(struct soap *soap, const char *id, const char *ns, short utilized) +{ register struct soap_nlist *np; + size_t n, k; + if (soap_strsearch(soap->c14nexclude, id)) + return NULL; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Push namespace binding (level=%u) '%s' '%s'\n", soap->level, id, ns?ns:"")); + if (!utilized) + { for (np = soap->nlist; np; np = np->next) + { if (!strcmp(np->id, id) && (!np->ns || !strcmp(np->ns, ns))) + break; + } + if (np) + { if (np->index == 1) + utilized = np->index; + else + return NULL; + } + } + n = strlen(id); + if (ns) + k = strlen(ns); + else + k = 0; + np = (struct soap_nlist*)SOAP_MALLOC(soap, sizeof(struct soap_nlist) + n + k + 1); + if (!np) + { soap->error = SOAP_EOM; + return NULL; + } + np->next = soap->nlist; + soap->nlist = np; + strcpy(np->id, id); + if (ns) + { np->ns = np->id + n + 1; + strcpy(np->ns, ns); + } + else + np->ns = NULL; + np->level = soap->level; + np->index = utilized; + return np; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +static void +soap_utilize_ns(struct soap *soap, const char *tag, size_t n) +{ register struct soap_nlist *np = soap_lookup_ns(soap, tag, n); + if (np) + { if (np->index == 0) + soap_push_ns(soap, np->id, np->ns, 1); + } + else + { strncpy(soap->tmpbuf, tag, n); + soap->tmpbuf[n] = '\0'; + soap_push_ns(soap, soap->tmpbuf, NULL, 1); + } +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +static void +soap_pop_ns(struct soap *soap) +{ soap_pop_namespace(soap); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element(struct soap *soap, const char *tag, int id, const char *type) +{ +#ifdef WITH_XMLNS + register const char *s; +#endif + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element begin tag='%s' id='%d' type='%s'\n", tag, id, type?type:"")); +#ifdef WITH_DOM + if (soap->mode & SOAP_XML_DOM) + { register struct soap_dom_element *elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element)); + if (!elt) + return soap->error = SOAP_EOM; + elt->soap = soap; + elt->next = NULL; + elt->prnt = soap->dom; + elt->name = soap_strdup(soap, tag); + elt->elts = NULL; + elt->atts = NULL; + elt->nstr = NULL; + elt->data = NULL; + elt->wide = NULL; + elt->node = NULL; + elt->type = 0; + elt->head = NULL; + elt->tail = NULL; + if (soap->dom) + { struct soap_dom_element *p = soap->dom->elts; + if (p) + { while (p->next) + p = p->next; + p->next = elt; + } + else + soap->dom->elts = elt; + } + soap->dom = elt; + } + else + { +#endif + soap->level++; +#ifndef WITH_LEAN + if (!soap->ns) + { if (!(soap->mode & SOAP_XML_CANONICAL) + && soap_send(soap, soap->prolog ? soap->prolog : "\n")) + return soap->error; + } + else if (soap->mode & SOAP_XML_INDENT) + { if (soap->ns == 1 && soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1)) + return soap->error; + soap->body = 1; + } +#endif +#ifdef WITH_XMLNS + s = strchr(tag, ':'); + if (s && strncmp(tag, "SOAP-ENV", s - tag)) + { struct Namespace *ns = soap->local_namespaces; + size_t n = s - tag; + if (soap_send_raw(soap, "<", 1) + || soap_send(soap, s + 1)) + return soap->error; + if (soap->nlist && !strncmp(soap->nlist->id, tag, n) && !soap->nlist->id[n]) + ns = NULL; + for (; ns && ns->id; ns++) + { if (*ns->id && (ns->out || ns->ns) && !strncmp(ns->id, tag, n) && !ns->id[n]) + { soap_push_ns(soap, ns->id, ns->out ? ns->out : ns->ns, 0); + if (soap_attribute(soap, "xmlns", ns->out ? ns->out : ns->ns)) + return soap->error; + break; + } + } + } + else +#endif + if (soap_send_raw(soap, "<", 1) + || soap_send(soap, tag)) + return soap->error; +#ifdef WITH_DOM + } +#endif + if (!soap->ns) + { struct Namespace *ns; + for (ns = soap->local_namespaces; ns && ns->id; ns++) + { if (*ns->id && (ns->out || ns->ns)) + { sprintf(soap->tmpbuf, "xmlns:%s", ns->id); + if (soap_attribute(soap, soap->tmpbuf, ns->out ? ns->out : ns->ns)) + return soap->error; + } + } + } + soap->ns = 1; /* start with 0 or 2, but should be one to continue */ +#ifndef WITH_LEAN + if (soap->mode & SOAP_XML_CANONICAL) + { const char *t = strchr(tag, ':'); + if (t) + soap_utilize_ns(soap, tag, t - tag); + } +#endif + if (id > 0) + { sprintf(soap->tmpbuf, "_%d", id); + if (soap_attribute(soap, "id", soap->tmpbuf)) + return soap->error; + } + if (type && *type) + { if (soap_attribute(soap, "xsi:type", type)) + return soap->error; +#ifndef WITH_LEAN + if (soap->mode & SOAP_XML_CANONICAL) + { const char *t = strchr(type, ':'); + if (t) + soap_utilize_ns(soap, type, t - type); + } +#endif + } + if (soap->null && soap->position > 0) + { register int i; + sprintf(soap->tmpbuf, "[%d", soap->positions[0]); + for (i = 1; i < soap->position; i++) + sprintf(soap->tmpbuf + strlen(soap->tmpbuf), ",%d", soap->positions[i]); + strcat(soap->tmpbuf, "]"); + if (soap_attribute(soap, "SOAP-ENC:position", soap->tmpbuf)) + return soap->error; + } + if (soap->mustUnderstand) + { if (soap->actor && *soap->actor) + { if (soap_attribute(soap, soap->version == 2 ? "SOAP-ENV:role" : "SOAP-ENV:actor", soap->actor)) + return soap->error; + } + if (soap_attribute(soap, "SOAP-ENV:mustUnderstand", soap->version == 2 ? "true" : "1")) + return soap->error; + soap->mustUnderstand = 0; + } + if (soap->encoding) + { if (soap->encodingStyle && soap->local_namespaces) + { if (!*soap->encodingStyle) + { if (soap->local_namespaces[1].out) + soap->encodingStyle = soap->local_namespaces[1].out; + else + soap->encodingStyle = soap->local_namespaces[1].ns; + } + if (soap_attribute(soap, "SOAP-ENV:encodingStyle", soap->encodingStyle)) + return soap->error; + } + soap->encoding = 0; + } + soap->null = 0; + soap->position = 0; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_begin_out(struct soap *soap, const char *tag, int id, const char *type) +{ if (*tag == '-') + return SOAP_OK; + if (soap_element(soap, tag, id, type)) + return soap->error; + return soap_element_start_end_out(soap, NULL); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +#ifndef HAVE_STRRCHR +SOAP_FMAC1 +char* +SOAP_FMAC2 +soap_strrchr(const char *s, int t) +{ register char *r = NULL; + while (*s) + if (*s++ == t) + r = (char*)s - 1; + return r; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_2 +#ifndef HAVE_STRTOL +SOAP_FMAC1 +long +SOAP_FMAC2 +soap_strtol(const char *s, char **t, int b) +{ register long n = 0; + register int c; + while (*s > 0 && *s <= 32) + s++; + if (b == 10) + { short neg = 0; + if (*s == '-') + { s++; + neg = 1; + } + else if (*s == '+') + s++; + while ((c = *s) && c >= '0' && c <= '9') + { if (n >= 214748364 && (n > 214748364 || c >= '8')) + break; + n *= 10; + n += c - '0'; + s++; + } + if (neg) + n = -n; + } + else /* b == 16 and value is always positive */ + { while ((c = *s)) + { if (c >= '0' && c <= '9') + c -= '0'; + else if (c >= 'A' && c <= 'F') + c -= 'A' - 10; + else if (c >= 'a' && c <= 'f') + c -= 'a' - 10; + if (n > 0x07FFFFFF) + break; + n <<= 4; + n += c; + s++; + } + } + if (t) + *t = (char*)s; + return n; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_2 +#ifndef HAVE_STRTOUL +SOAP_FMAC1 +unsigned long +SOAP_FMAC2 +soap_strtoul(const char *s, char **t, int b) +{ unsigned long n = 0; + register int c; + while (*s > 0 && *s <= 32) + s++; + if (b == 10) + { if (*s == '+') + s++; + while ((c = *s) && c >= '0' && c <= '9') + { if (n >= 429496729 && (n > 429496729 || c >= '6')) + break; + n *= 10; + n += c - '0'; + s++; + } + } + else /* b == 16 */ + { while ((c = *s)) + { if (c >= '0' && c <= '9') + c -= '0'; + else if (c >= 'A' && c <= 'F') + c -= 'A' - 10; + else if (c >= 'a' && c <= 'f') + c -= 'a' - 10; + if (n > 0x0FFFFFFF) + break; + n <<= 4; + n += c; + s++; + } + } + if (t) + *t = (char*)s; + return n; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_array_begin_out(struct soap *soap, const char *tag, int id, const char *type, const char *offset) +{ if (soap_element(soap, tag, id, "SOAP-ENC:Array")) + return soap->error; + if (soap->version == 2) + { const char *s; + s = soap_strrchr(type, '['); + if ((size_t)(s - type) < sizeof(soap->tmpbuf)) + { strncpy(soap->tmpbuf, type, s - type); + soap->tmpbuf[s - type] = '\0'; + if (type && *type && (soap_attribute(soap, "SOAP-ENC:itemType", soap->tmpbuf))) + return soap->error; + if (s && (soap_attribute(soap, "SOAP-ENC:arraySize", s + 1))) + return soap->error; + } + } + else + { if (offset && (soap_attribute(soap, "SOAP-ENC:offset", offset))) + return soap->error; + if (type && *type && (soap_attribute(soap, "SOAP-ENC:arrayType", type))) + return soap->error; + } +#ifndef WITH_LEAN + if (type && *type && (soap->mode & SOAP_XML_CANONICAL)) + { const char *s = strchr(type, ':'); + if (s) + soap_utilize_ns(soap, type, s - type); + } +#endif + return soap_element_start_end_out(soap, NULL); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_start_end_out(struct soap *soap, const char *tag) +{ register struct soap_attribute *tp; +#ifndef WITH_LEAN + if (soap->mode & SOAP_XML_CANONICAL) + { struct soap_nlist *np; + for (tp = soap->attributes; tp; tp = tp->next) + { if (tp->visible && tp->name) + { const char *s = strchr(tp->name, ':'); + if (s) + soap_utilize_ns(soap, tp->name, s - tp->name); + } + } + for (np = soap->nlist; np; np = np->next) + { if (np->index == 1 && np->ns) + { sprintf(soap->tmpbuf, "xmlns:%s", np->id); + soap_set_attr(soap, soap->tmpbuf, np->ns); + np->index = 2; + } + } + } +#endif +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { register struct soap_dom_attribute **att; + att = &soap->dom->atts; + for (tp = soap->attributes; tp; tp = tp->next) + { if (tp->visible) + { *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute)); + if (!*att) + return soap->error = SOAP_EOM; + (*att)->next = NULL; + (*att)->nstr = NULL; + (*att)->name = soap_strdup(soap, tp->name); + (*att)->data = soap_strdup(soap, tp->value); + (*att)->wide = NULL; + (*att)->soap = soap; + att = &(*att)->next; + tp->visible = 0; + } + } + return SOAP_OK; + } +#endif + for (tp = soap->attributes; tp; tp = tp->next) + { if (tp->visible) + { +#ifdef WITH_XMLNS + const char *s = strchr(tp->name, ':'); + if (s) + { size_t n = s - tp->name; + if (soap->nlist && !strncmp(soap->nlist->id, tp->name, n) && !soap->nlist->id[n]) + s++; + else + s = tp->name; + if (soap_send(soap, " ") || soap_send(soap, s)) + return soap->error; + } + else +#endif + if (soap_send(soap, " ") || soap_send(soap, tp->name)) + return soap->error; + if (tp->visible == 2 && tp->value) + if (soap_send_raw(soap, "=\"", 2) + || soap_string_out(soap, tp->value, 1) + || soap_send_raw(soap, "\"", 1)) + return soap->error; + tp->visible = 0; + } + } + if (tag) + { +#ifndef WITH_LEAN + if (soap->mode & SOAP_XML_CANONICAL) + { if (soap_send_raw(soap, ">", 1) + || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; + } +#endif + soap->level--; /* decrement level just before /> */ + if (soap_send_raw(soap, "/>", 2)) + return soap->error; + return SOAP_OK; + } + return soap_send_raw(soap, ">", 1); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_end_out(struct soap *soap, const char *tag) +{ if (*tag == '-') + return SOAP_OK; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element ending tag='%s'\n", tag)); +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { if (soap->dom->prnt) + soap->dom = soap->dom->prnt; + return SOAP_OK; + } +#endif +#ifndef WITH_LEAN + if (soap->mode & SOAP_XML_CANONICAL) + soap_pop_ns(soap); + if (soap->mode & SOAP_XML_INDENT) + { if (!soap->body) + { if (soap_send_raw(soap, soap_indent, soap->level < sizeof(soap_indent) ? soap->level : sizeof(soap_indent) - 1)) + return soap->error; + } + soap->body = 0; + } +#endif +#ifdef WITH_XMLNS + { const char *s = strchr(tag, ':'); + if (s && strncmp(tag, "SOAP-ENV", s - tag)) + { soap_pop_ns(soap); + tag = s + 1; + } + } +#endif + if (soap_send_raw(soap, "error; + soap->level--; /* decrement level just before > */ + return soap_send_raw(soap, ">", 1); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_ref(struct soap *soap, const char *tag, int id, int href) +{ register int n = 0; + if (soap->version == 2) + n = 1; + sprintf(soap->href, "#_%d", href); + return soap_element_href(soap, tag, id, "href" + n, soap->href + n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_href(struct soap *soap, const char *tag, int id, const char *ref, const char *val) +{ DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element '%s' reference %s='%s'\n", tag, ref, val)); + if (soap_element(soap, tag, id, NULL) + || soap_attribute(soap, ref, val) + || soap_element_start_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_null(struct soap *soap, const char *tag, int id, const char *type) +{ struct soap_attribute *tp; + for (tp = soap->attributes; tp; tp = tp->next) + if (tp->visible) + break; + if (tp || (soap->version == 2 && soap->position > 0) || id > 0 || (soap->mode & SOAP_XML_NIL)) + { if (soap_element(soap, tag, id, type)) + return soap->error; + if (soap->part != SOAP_IN_HEADER && soap->encodingStyle) + if (soap_attribute(soap, "xsi:nil", "true")) + return soap->error; + return soap_element_start_end_out(soap, tag); + } + soap->null = 1; + soap->position = 0; + soap->mustUnderstand = 0; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_id(struct soap *soap, const char *tag, int id, const void *p, const struct soap_array *a, int n, const char *type, int t) +{ if (!p || (a && !a->__ptr)) + { soap_element_null(soap, tag, id, type); + return -1; + } +#ifndef WITH_NOIDREF + if (soap->mode & SOAP_XML_TREE) + return 0; + if (id < 0) + { struct soap_plist *pp; + if (a) + id = soap_array_pointer_lookup(soap, p, a, n, t, &pp); + else + id = soap_pointer_lookup(soap, p, t, &pp); + if (id) + { if (soap_is_embedded(soap, pp)) + { soap_element_ref(soap, tag, 0, id); + return -1; + } + if (soap_is_single(soap, pp)) + return 0; + soap_set_embedded(soap, pp); + } + } + return id; +#else + return 0; +#endif +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_result(struct soap *soap, const char *tag) +{ if (soap->version == 2 && soap->encodingStyle) + if (soap_element(soap, "SOAP-RPC:result", 0, NULL) + || soap_attribute(soap, "xmlns:SOAP-RPC", soap_rpc) + || soap_element_start_end_out(soap, NULL) + || soap_string_out(soap, tag, 0) + || soap_element_end_out(soap, "SOAP-RPC:result")) + return soap->error; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_check_result(struct soap *soap, const char *tag) +{ if (soap->version == 2 && soap->encodingStyle) + { soap_instring(soap, ":result", NULL, NULL, 0, 2, -1, -1); + /* should compare tag to element's QName value? */ + } +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_attribute(struct soap *soap, const char *name, const char *value) +{ +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && !(soap->mode & SOAP_XML_CANONICAL) && soap->dom) + { register struct soap_dom_attribute *a = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute)); + a->next = soap->dom->atts; + a->nstr = NULL; + a->name = soap_strdup(soap, name); + a->data = soap_strdup(soap, value); + a->wide = NULL; + a->soap = soap; + soap->dom->atts = a; + return SOAP_OK; + } +#endif +#ifndef WITH_LEAN + if (soap->mode & SOAP_XML_CANONICAL) + { /* TODO: consider using this code to handle default namespace bindings + if (!strncmp(name, "xmlns", 5) && (name[5] == ':' || name[5] == '\0')) + { if (name[5] == ':') + soap_push_ns(soap, name + 6, value, 0); + else + soap_push_ns(soap, "", value, 0); + } + */ + if (!strncmp(name, "xmlns:", 6)) + soap_push_ns(soap, name + 6, value, 0); + else if (soap_set_attr(soap, name, value)) + return soap->error; + } + else +#endif + { if (soap_send(soap, " ") || soap_send(soap, name)) + return soap->error; + if (value) + if (soap_send_raw(soap, "=\"", 2) + || soap_string_out(soap, value, 1) + || soap_send_raw(soap, "\"", 1)) + return soap->error; + } + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_begin_in(struct soap *soap, const char *tag, int nillable, const char *type) +{ if (!soap_peek_element(soap)) + { if (soap->other) + return soap->error = SOAP_TAG_MISMATCH; + if (tag && *tag == '-') + return SOAP_OK; + if (!(soap->error = soap_match_tag(soap, soap->tag, tag))) + { soap->peeked = 0; + if (soap->body) + soap->level++; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Begin element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag?tag:"" )); + if (!nillable && soap->null && (soap->mode & SOAP_XML_STRICT)) + return soap->error = SOAP_NULL; + if (type && *soap->type && soap_match_tag(soap, soap->type, type)) + return soap->error = SOAP_TYPE; + } + } + else if (soap->error == SOAP_NO_TAG && tag && *tag == '-') + soap->error = SOAP_OK; + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_element_end_in(struct soap *soap, const char *tag) +{ register soap_wchar c; + register char *s; + register const char *t; + register int n = 0; + if (tag && *tag == '-') + return SOAP_OK; + soap->level--; + soap_pop_namespace(soap); +#ifdef WITH_DOM + /* this whitespace or mixed content is not insignificant for DOM */ + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { if (!soap->peeked && !soap_string_in(soap, 3, -1, -1)) + return soap->error; + if (soap->dom->prnt) + soap->dom = soap->dom->prnt; + } +#endif + if (soap->peeked) + { if (soap->error == SOAP_NO_TAG) + soap->error = SOAP_OK; + if (*soap->tag) + n++; + soap->peeked = 0; + } + do + { while (((c = soap_get(soap)) != SOAP_TT)) + { if ((int)c == EOF) + return soap->error = SOAP_EOF; + if (c == SOAP_LT) + n++; + else if (c == '/') + { c = soap_get(soap); + if (c == SOAP_GT) + n--; + else + soap_unget(soap, c); + } + } + } while (n--); + s = soap->tag; + while (soap_notblank(c = soap_get(soap))) + *s++ = (char)c; + *s = '\0'; + if ((int)c == EOF) + return soap->error = SOAP_EOF; + while (soap_blank(c)) + c = soap_get(soap); + if (c != SOAP_GT) + return soap->error = SOAP_SYNTAX_ERROR; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element found (level=%u) '%s'='%s'\n", soap->level, soap->tag, tag?tag:"")); + if (!tag || !*tag) + return SOAP_OK; + if ((s = strchr(soap->tag, ':'))) + s++; + else + s = soap->tag; + if ((t = strchr(tag, ':'))) + t++; + else + t = tag; + if (!SOAP_STRCMP(s, t)) + return SOAP_OK; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End element tag name does not match\n")); + return soap->error = SOAP_SYNTAX_ERROR; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char * +SOAP_FMAC2 +soap_attr_value(struct soap *soap, const char *name, int flag) +{ register struct soap_attribute *tp; + for (tp = soap->attributes; tp; tp = tp->next) + { if (tp->visible && !soap_match_tag(soap, tp->name, name)) + break; + } + if (tp) + { if (flag == 2 && (soap->mode & SOAP_XML_STRICT)) + soap->error = SOAP_PROHIBITED; + else + return tp->value; + } + else if (flag == 1 && (soap->mode & SOAP_XML_STRICT)) + soap->error = SOAP_REQUIRED; + return NULL; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_set_attr(struct soap *soap, const char *name, const char *value) +{ register struct soap_attribute *tp; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set attribute %s='%s'\n", name, value?value:"")); + for (tp = soap->attributes; tp; tp = tp->next) + { if (!strcmp(tp->name, name)) + break; + } + if (!tp) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute %s\n", name)); + if (!(tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + strlen(name)))) + return soap->error = SOAP_EOM; + tp->ns = NULL; +#ifndef WITH_LEAN + if (soap->mode & SOAP_XML_CANONICAL) + { struct soap_attribute **tpp = &soap->attributes; + const char *s = strchr(name, ':'); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inserting attribute %s for c14n\n", name)) + if (!strncmp(name, "xmlns", 5)) + { for (; *tpp; tpp = &(*tpp)->next) + if (strncmp((*tpp)->name, "xmlns", 5) || strcmp((*tpp)->name + 5, name + 5) > 0) + break; + } + else if (!s) + { for (; *tpp; tpp = &(*tpp)->next) + if (strncmp((*tpp)->name, "xmlns", 5) && ((*tpp)->ns || strcmp((*tpp)->name, name) > 0)) + break; + } + else + { int k; + for (; *tpp; tpp = &(*tpp)->next) + { if (!strncmp((*tpp)->name, "xmlns:", 6) && !strncmp((*tpp)->name + 6, name, s - name) && !(*tpp)->name[6 + s - name]) + { if (!tp->ns) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Canonicalization: prefix %s=%p (%s)\n", name, (*tpp)->ns, (*tpp)->ns)); + tp->ns = (*tpp)->ns; + } + } + else if (strncmp((*tpp)->name, "xmlns", 5) && (*tpp)->ns && tp->ns && ((k = strcmp((*tpp)->ns, tp->ns)) > 0 || (!k && strcmp((*tpp)->name, name) > 0))) + break; + } + } + tp->next = *tpp; + *tpp = tp; + } + else +#endif + { tp->next = soap->attributes; + soap->attributes = tp; + } + strcpy(tp->name, name); + tp->value = NULL; + } + else if (tp->visible) + { return SOAP_OK; + } + else if (value && tp->value && tp->size <= strlen(value)) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Free attribute value of %s (free %p)\n", name, tp->value)); + SOAP_FREE(soap, tp->value); + tp->value = NULL; + tp->ns = NULL; + } + if (value) + { if (!tp->value) + { tp->size = strlen(value) + 1; + if (!(tp->value = (char*)SOAP_MALLOC(soap, tp->size))) + return soap->error = SOAP_EOM; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Allocate attribute value of %s (%p)\n", tp->name, tp->value)); + } + strcpy(tp->value, value); + if (!strncmp(tp->name, "xmlns:", 6)) + tp->ns = tp->value; + tp->visible = 2; +#ifndef WITH_LEAN + if (!strcmp(name, "wsu:Id")) + { soap->part = SOAP_BEGIN_SECURITY; + strncpy(soap->id, value, sizeof(soap->id)); + soap->id[sizeof(soap->id)-1] = '\0'; + } +#endif + } + else + tp->visible = 1; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_clr_attr(struct soap *soap) +{ register struct soap_attribute *tp; +#ifndef WITH_LEAN + if ((soap->mode & SOAP_XML_CANONICAL)) + { while (soap->attributes) + { tp = soap->attributes->next; + SOAP_FREE(soap, soap->attributes->value); + SOAP_FREE(soap, soap->attributes); + soap->attributes = tp; + } + } + else +#endif + { for (tp = soap->attributes; tp; tp = tp->next) + tp->visible = 0; + } +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +static int +soap_getattrval(struct soap *soap, char *s, size_t n, soap_wchar d) +{ register size_t i; + for (i = 0; i < n; i++) + { register soap_wchar c = soap_get(soap); + switch (c) + { + case SOAP_TT: + *s++ = '<'; + soap_unget(soap, '/'); + break; + case SOAP_LT: + *s++ = '<'; + break; + case SOAP_GT: + if (d == ' ') + { soap_unget(soap, c); + *s = '\0'; + return SOAP_OK; + } + *s++ = '>'; + break; + case SOAP_QT: + if (c == d) + { *s = '\0'; + return SOAP_OK; + } + *s++ = '"'; + break; + case SOAP_AP: + if (c == d) + { *s = '\0'; + return SOAP_OK; + } + *s++ = '\''; + break; + case '\t': + case '\n': + case '\r': + case ' ': + case '/': + if (d == ' ') + { soap_unget(soap, c); + *s = '\0'; + return SOAP_OK; + } + default: + if ((int)c == EOF) + return soap->error = SOAP_EOF; + *s++ = (char)c; + } + } + return soap->error = SOAP_EOM; +} +#endif + +/******************************************************************************/ +#ifdef WITH_FAST +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_store_lab(struct soap *soap, const char *s, size_t n) +{ soap->labidx = 0; + return soap_append_lab(soap, s, n); +} +#endif +#endif + +/******************************************************************************/ +#ifdef WITH_FAST +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_append_lab(struct soap *soap, const char *s, size_t n) +{ if (soap->labidx + n >= soap->lablen) + { register char *t = soap->labbuf; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Enlarging look-aside buffer to append data, old size=%lu", (unsigned long)soap->lablen)); + if (soap->lablen == 0) + soap->lablen = SOAP_LABLEN; + while (soap->labidx + n >= soap->lablen) + soap->lablen <<= 1; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, ", new size=%lu\n", (unsigned long)soap->lablen)); + soap->labbuf = (char*)SOAP_MALLOC(soap, soap->lablen); + if (!soap->labbuf) + { if (t) + SOAP_FREE(soap, t); + return soap->error = SOAP_EOM; + } + if (t) + { memcpy(soap->labbuf, t, soap->labidx); + SOAP_FREE(soap, t); + } + } + if (s) + { memcpy(soap->labbuf + soap->labidx, s, n); + soap->labidx += n; + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_peek_element(struct soap *soap) +{ +#ifdef WITH_DOM + register struct soap_dom_attribute **att = NULL; + register char *lead = NULL; +#endif + register struct soap_attribute *tp; + const char *t; + register char *s; + register soap_wchar c; + register int i; + if (soap->peeked) + { if (!*soap->tag) + return soap->error = SOAP_NO_TAG; + return SOAP_OK; + } + soap->peeked = 1; + c = soap_getutf8(soap); +#ifdef WITH_DOM + /* whitespace leading to start tag is not insignificant for DOM */ + if (soap_blank(c)) + { soap->labidx = 0; + do + { if (soap_append_lab(soap, NULL, 0)) + return SOAP_EOM; + s = soap->labbuf + soap->labidx; + i = soap->lablen - soap->labidx; + soap->labidx = soap->lablen; + while (soap_blank(c) && i--) + { *s++ = c; + c = soap_getutf8(soap); + } + } + while (soap_blank(c)); + *s = '\0'; + lead = soap_strdup(soap, soap->labbuf); + } +#else + while (soap_blank(c)) + c = soap_getutf8(soap); +#endif + if (c != SOAP_LT) + { *soap->tag = '\0'; + if ((int)c == EOF) + return soap->error = SOAP_EOF; + soap_unget(soap, c); +#ifdef WITH_DOM + /* whitespace leading to end tag is not insignificant for DOM */ + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + soap->dom->tail = soap_strdup(soap, lead); +#endif + return soap->error = SOAP_NO_TAG; + } + s = soap->tag; + do c = soap_get1(soap); + while (soap_blank(c)); + i = sizeof(soap->tag); + while (c != '>' && c != '/' && soap_notblank(c) && (int)c != EOF) + { if (--i > 0) + *s++ = (char)c; + c = soap_get1(soap); + } + while (soap_blank(c)) + c = soap_get1(soap); + *s = '\0'; + soap->id[0] = '\0'; + soap->href[0] = '\0'; + soap->type[0] = '\0'; + soap->arrayType[0] = '\0'; + soap->arraySize[0] = '\0'; + soap->arrayOffset[0] = '\0'; + soap->other = 0; + soap->root = -1; + soap->position = 0; + soap->null = 0; + soap->mustUnderstand = 0; +#ifdef WITH_DOM + if (soap->mode & SOAP_XML_DOM) + { register struct soap_dom_element *elt; + elt = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element)); + if (!elt) + return soap->error = SOAP_EOM; + elt->next = NULL; + elt->nstr = NULL; + elt->name = soap_strdup(soap, soap->tag); + elt->prnt = soap->dom; + elt->elts = NULL; + elt->atts = NULL; + elt->data = NULL; + elt->wide = NULL; + elt->type = 0; + elt->node = NULL; + elt->head = lead; + elt->tail = NULL; + elt->soap = soap; + if (soap->dom) + { struct soap_dom_element *p = soap->dom->elts; + if (p) + { while (p->next) + p = p->next; + p->next = elt; + } + else + soap->dom->elts = elt; + } + soap->dom = elt; + att = &elt->atts; + } +#endif + for (tp = soap->attributes; tp; tp = tp->next) + tp->visible = 0; + while ((int)c != EOF && c != '>' && c != '/') + { s = soap->tmpbuf; + i = sizeof(soap->tmpbuf); + while (c != '=' && c != '>' && c != '/' && soap_notblank(c) && (int)c != EOF) + { if (--i > 0) + *s++ = (char)c; + c = soap_get1(soap); + } + *s = '\0'; + if (i == sizeof(soap->tmpbuf)) + return soap->error = SOAP_SYNTAX_ERROR; +#ifdef WITH_DOM + /* add attribute name to dom */ + if (att) + { *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute)); + if (!*att) + return soap->error = SOAP_EOM; + (*att)->next = NULL; + (*att)->nstr = NULL; + (*att)->name = soap_strdup(soap, soap->tmpbuf); + (*att)->data = NULL; + (*att)->wide = NULL; + (*att)->soap = soap; + } +#endif + if (!strncmp(soap->tmpbuf, "xmlns", 5)) + { if (soap->tmpbuf[5] == ':') + { soap->tmpbuf[5] = '\0'; + t = soap->tmpbuf + 6; + } + else if (soap->tmpbuf[5]) + t = NULL; + else + t = SOAP_STR_EOS; + } + else + t = NULL; + for (tp = soap->attributes; tp; tp = tp->next) + { if (!SOAP_STRCMP(tp->name, soap->tmpbuf)) + break; + } + if (!tp) + { tp = (struct soap_attribute*)SOAP_MALLOC(soap, sizeof(struct soap_attribute) + strlen(soap->tmpbuf)); + if (!tp) + return soap->error = SOAP_EOM; + strcpy(tp->name, soap->tmpbuf); + tp->value = NULL; + tp->size = 0; + tp->next = soap->attributes; + soap->attributes = tp; + } + while (soap_blank(c)) + c = soap_get1(soap); + if (c == '=') + { do c = soap_getutf8(soap); + while (soap_blank(c)); + if (c != SOAP_QT && c != SOAP_AP) + { soap_unget(soap, c); + c = ' '; /* blank delimiter */ + } + if (soap_getattrval(soap, tp->value, tp->size, c)) + { +#ifdef WITH_FAST + if (soap->error != SOAP_EOM) + return soap->error; + soap->error = SOAP_OK; + if (soap_store_lab(soap, tp->value, tp->size)) + return soap->error; + if (tp->value) + SOAP_FREE(soap, tp->value); + for (;;) + { if (soap_getattrval(soap, soap->labbuf + soap->labidx, soap->lablen - soap->labidx, c)) + { if (soap->error != SOAP_EOM) + return soap->error; + soap->error = SOAP_OK; + soap->labidx = soap->lablen; + if (soap_append_lab(soap, NULL, 0)) + return soap->error; + } + else + break; + } + if (soap->labidx) + tp->size = soap->lablen; + else + { tp->size = strlen(soap->labbuf) + 1; + if (tp->size < SOAP_LABLEN) + tp->size = SOAP_LABLEN; + } + if (!(tp->value = (char*)SOAP_MALLOC(soap, tp->size))) + return soap->error = SOAP_EOM; + strcpy(tp->value, soap->labbuf); +#else + size_t n; + if (soap->error != SOAP_EOM) + return soap->error; + soap->error = SOAP_OK; + if (soap_new_block(soap)) + return soap->error; + for (;;) + { if (!(s = (char*)soap_push_block(soap, SOAP_BLKLEN))) + return soap->error; + if (soap_getattrval(soap, s, SOAP_BLKLEN, c)) + { if (soap->error != SOAP_EOM) + return soap->error; + soap->error = SOAP_OK; + } + else + break; + } + n = tp->size + soap->blist->size; + if (!(s = (char*)SOAP_MALLOC(soap, n))) + return soap->error = SOAP_EOM; + if (tp->value) + { memcpy(s, tp->value, tp->size); + SOAP_FREE(soap, tp->value); + } + soap_save_block(soap, s + tp->size, 0); + tp->value = s; + tp->size = n; +#endif + } + do c = soap_get1(soap); + while (soap_blank(c)); + tp->visible = 2; /* seen this attribute w/ value */ +#ifdef WITH_DOM + if (att) + (*att)->data = soap_strdup(soap, tp->value); +#endif + } + else + tp->visible = 1; /* seen this attribute w/o value */ +#ifdef WITH_DOM + if (att) + att = &(*att)->next; +#endif + if (t && tp->value) + { if (soap_push_namespace(soap, t, tp->value)) + return soap->error; + tp->visible = 0; + } + } +#ifdef WITH_DOM + if (att) + { soap->dom->nstr = soap_current_namespace(soap, soap->tag); + for (att = &soap->dom->atts; *att; att = &(*att)->next) + (*att)->nstr = soap_current_namespace(soap, (*att)->name); + } +#endif + if ((int)c == EOF) + return soap->error = SOAP_EOF; + if (!(soap->body = (c != '/'))) + do c = soap_get1(soap); + while (soap_blank(c)); +#ifdef WITH_DOM + if (soap->mode & SOAP_XML_DOM) + { if (!soap->body && soap->dom->prnt) + soap->dom = soap->dom->prnt; + } +#endif + for (tp = soap->attributes; tp; tp = tp->next) + { if (tp->visible && tp->value) + { if (!strcmp(tp->name, "id")) + { *soap->id = '#'; + strncpy(soap->id + 1, tp->value, sizeof(soap->id) - 2); + soap->id[sizeof(soap->id)-1] = '\0'; + } + else if (!strcmp(tp->name, "href")) + { strncpy(soap->href, tp->value, sizeof(soap->href) - 1); + soap->href[sizeof(soap->href)-1] = '\0'; + } + else if ((soap->version == 2 || (soap->mode & SOAP_XML_GRAPH)) && !strcmp(tp->name, "ref")) + { *soap->href = '#'; + strncpy(soap->href + 1, tp->value, sizeof(soap->href) - 2); + soap->href[sizeof(soap->href)-1] = '\0'; + } + else if (!soap_match_tag(soap, tp->name, "xsi:type")) + { strncpy(soap->type, tp->value, sizeof(soap->type) - 1); + soap->type[sizeof(soap->type)-1] = '\0'; + } + else if (soap->version == 1 && !soap_match_tag(soap, tp->name, "SOAP-ENC:arrayType")) + { s = soap_strrchr(tp->value, '['); + if (s && (size_t)(s - tp->value) < sizeof(soap->arrayType)) + { strncpy(soap->arrayType, tp->value, s - tp->value); + soap->arrayType[s - tp->value] = '\0'; + strncpy(soap->arraySize, s, sizeof(soap->arraySize) - 1); + } + else + strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType) - 1); + soap->arraySize[sizeof(soap->arrayType)-1] = '\0'; + soap->arrayType[sizeof(soap->arrayType)-1] = '\0'; + } + else if (soap->version == 2 && !soap_match_tag(soap, tp->name, "SOAP-ENC:itemType")) + strncpy(soap->arrayType, tp->value, sizeof(soap->arrayType) - 1); + else if (soap->version == 2 && !soap_match_tag(soap, tp->name, "SOAP-ENC:arraySize")) + strncpy(soap->arraySize, tp->value, sizeof(soap->arraySize) - 1); + else if (soap->version == 1 && !soap_match_tag(soap, tp->name, "SOAP-ENC:offset")) + strncpy(soap->arrayOffset, tp->value, sizeof(soap->arrayOffset)); + else if (soap->version == 1 && !soap_match_tag(soap, tp->name, "SOAP-ENC:position")) + soap->position = soap_getposition(tp->value, soap->positions); + else if (soap->version == 1 && !soap_match_tag(soap, tp->name, "SOAP-ENC:root")) + soap->root = ((!strcmp(tp->value, "1") || !strcmp(tp->value, "true"))); + else if ((soap->version == 1 && !soap_match_tag(soap, tp->name, "SOAP-ENV:actor")) + || (soap->version == 2 && !soap_match_tag(soap, tp->name, "SOAP-ENV:role"))) + { if ((!soap->actor || strcmp(soap->actor, tp->value)) + && strcmp(tp->value, "http://schemas.xmlsoap.org/soap/actor/next") + && strcmp(tp->value, "http://www.w3.org/2003/05/soap-envelope/role/next")) + soap->other = 1; + } + else if (!soap_match_tag(soap, tp->name, "SOAP-ENV:mustUnderstand") + && (!strcmp(tp->value, "1") || !strcmp(tp->value, "true"))) + soap->mustUnderstand = 1; + else if ((!soap_match_tag(soap, tp->name, "xsi:null") + || !soap_match_tag(soap, tp->name, "xsi:nil")) + && (!strcmp(tp->value, "1") + || !strcmp(tp->value, "true"))) + soap->null = 1; + } + } + return soap->error = SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_retry(struct soap *soap) +{ soap->error = SOAP_OK; + soap_revert(soap); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_revert(struct soap *soap) +{ if (!soap->peeked) + { soap->peeked = 1; + if (soap->body) + soap->level--; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Reverting last element (level=%u)\n", soap->level)); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_string_out(struct soap *soap, const char *s, int flag) +{ register const char *t; + register soap_wchar c; + register soap_wchar mask = 0xFFFFFF80UL; +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { soap->dom->data = soap_strdup(soap, s); + return SOAP_OK; + } +#endif + if (soap->mode & SOAP_C_UTFSTRING) + mask = 0; + t = s; + while ((c = *t++)) + { switch (c) + { + case 9: + if (flag) + { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, " ", 5)) + return soap->error; + s = t; + } + break; + case 10: + if (flag || !(soap->mode & SOAP_XML_CANONICAL)) + { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, " ", 5)) + return soap->error; + s = t; + } + break; + case 13: + if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, " ", 5)) + return soap->error; + s = t; + break; + case '&': + if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "&", 5)) + return soap->error; + s = t; + break; + case '<': + if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, "<", 4)) + return soap->error; + s = t; + break; + case '>': + if (!flag) + { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, ">", 4)) + return soap->error; + s = t; + } + break; + case '"': + if (flag) + { if (soap_send_raw(soap, s, t - s - 1) || soap_send_raw(soap, """, 6)) + return soap->error; + s = t; + } + break; + default: +#ifndef WITH_LEANER +#ifdef HAVE_MBTOWC + if (soap->mode & SOAP_C_MBSTRING) + { wchar_t wc; + register int m = mbtowc(&wc, t - 1, MB_CUR_MAX); + if (m > 0 && wc != c) + { if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, wc)) + return soap->error; + s = t += m - 1; + continue; + } + } +#endif +#endif + if (c & mask) + { if (soap_send_raw(soap, s, t - s - 1) || soap_pututf8(soap, (unsigned char)c)) + return soap->error; + s = t; + } + } + } + return soap_send_raw(soap, s, t - s - 1); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_string_in(struct soap *soap, int flag, long minlen, long maxlen) +{ register char *s; + char *t = NULL; + register size_t i; + register long l = 0; + register int n = 0; + register int m = 0; + register soap_wchar c; +#if !defined(WITH_LEANER) && defined(HAVE_WCTOMB) + char buf[MB_LEN_MAX > 8 ? MB_LEN_MAX : 8]; +#else + char buf[8]; +#endif + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Reading string content\n")); + if (soap->peeked) + { if (!soap->body) + return NULL; + if (*soap->tag) + { n = 1; + soap->peeked = 0; +#ifndef WITH_LEAN + t = soap->tmpbuf; + t[0] = '<'; + strncpy(t + 1, soap->tag, sizeof(soap->tmpbuf) - 1); + strncat(t, ">", sizeof(soap->tmpbuf)); + m = strlen(soap->tag) + 2; +#endif + } + } +#ifdef WITH_CDATA + if (!flag) + { register int state = 0; +#ifdef WITH_FAST + soap->labidx = 0; /* use look-aside buffer */ +#else + if (soap_new_block(soap)) + return NULL; +#endif + for (;;) + { +#ifdef WITH_FAST + register size_t k; + if (soap_append_lab(soap, NULL, 0)) /* allocate more space in look-aside buffer if necessary */ + return NULL; + s = soap->labbuf + soap->labidx; /* space to populate */ + k = soap->lablen - soap->labidx; /* number of bytes available */ + soap->labidx = soap->lablen; /* claim this space */ +#else + register size_t k = SOAP_BLKLEN; + if (!(s = (char*)soap_push_block(soap, k))) + return NULL; +#endif + for (i = 0; i < k; i++) + { if (m > 0) + { *s++ = *t++; /* copy multibyte characters */ + m--; + continue; + } + c = soap_getchar(soap); + if ((int)c == EOF) + goto end; + if (c >= 0x80 && !(soap->mode & SOAP_ENC_LATIN)) + { soap_unget(soap, c); + c = soap_getutf8(soap); + if (soap->mode & SOAP_C_UTFSTRING) + { if ((c & 0x80000000) && c >= -0x7FFFFF80 && c < SOAP_AP) + { c &= 0x7FFFFFFF; + t = buf; + if (c < 0x0800) + *t++ = (char)(0xC0 | ((c >> 6) & 0x1F)); + else + { if (c < 0x010000) + *t++ = (char)(0xE0 | ((c >> 12) & 0x0F)); + else + { if (c < 0x200000) + *t++ = (char)(0xF0 | ((c >> 18) & 0x07)); + else + { if (c < 0x04000000) + *t++ = (char)(0xF8 | ((c >> 24) & 0x03)); + else + { *t++ = (char)(0xFC | ((c >> 30) & 0x01)); + *t++ = (char)(0x80 | ((c >> 24) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 18) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 12) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 6) & 0x3F)); + } + *t++ = (char)(0x80 | (c & 0x3F)); + m = (int)(t - buf) - 1; + t = buf; + *s++ = *t++; + continue; + } + } + } + switch (state) + { case 1: + if (c == ']') + state = 4; + *s++ = c; + continue; + case 2: + if (c == '-') + state = 6; + *s++ = c; + continue; + case 3: + if (c == '?') + state = 8; + *s++ = c; + continue; + /* CDATA */ + case 4: + if (c == ']') + state = 5; + else + state = 1; + *s++ = c; + continue; + case 5: + if (c == '>') + state = 0; + else + state = 1; + *s++ = c; + continue; + /* comment */ + case 6: + if (c == '-') + state = 7; + else + state = 2; + *s++ = c; + continue; + case 7: + if (c == '>') + state = 0; + else + state = 2; + *s++ = c; + continue; + /* PI */ + case 8: + if (c == '>') + state = 0; + else + state = 3; + *s++ = c; + continue; + } + switch (c) + { + case '/': + if (n > 0) + { c = soap_getchar(soap); + if (c == '>') + n--; + soap_unget(soap, c); + } + *s++ = '/'; + break; + case '<': + c = soap_getchar(soap); + if (c == '/') + { if (n == 0) + { c = SOAP_TT; + goto end; + } + n--; + } + else if (c == '!') + { c = soap_getchar(soap); + if (c == '[') + { do c = soap_getchar(soap); + while ((int)c != EOF && c != '['); + if ((int)c == EOF) + goto end; + t = (char*)"![CDATA["; + m = 8; + state = 1; + } + else if (c == '-') + { if ((c = soap_getchar(soap)) == '-') + state = 2; + t = (char*)"!-"; + m = 2; + soap_unget(soap, c); + } + else + { t = (char*)"!"; + m = 1; + soap_unget(soap, c); + } + *s++ = '<'; + break; + } + else if (c == '?') + state = 3; + else + n++; + soap_unget(soap, c); + *s++ = '<'; + break; + case '>': + *s++ = '>'; + break; + case '"': + *s++ = '"'; + break; + default: +#ifndef WITH_LEANER +#ifdef HAVE_WCTOMB + if (soap->mode & SOAP_C_MBSTRING) + { m = wctomb(buf, c & 0x7FFFFFFF); + if (m >= 1 && m <= (int)MB_CUR_MAX) + { t = buf; + *s++ = *t++; + m--; + } + else + { *s++ = SOAP_UNKNOWN_CHAR; + m = 0; + } + } + else +#endif +#endif + *s++ = (char)(c & 0xFF); + } + l++; + if ((soap->mode & SOAP_XML_STRICT) && maxlen >= 0 && l > maxlen) + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen)); + soap->error = SOAP_LENGTH; + return NULL; + } + } + } + } +#endif +#ifdef WITH_FAST + soap->labidx = 0; /* use look-aside buffer */ +#else + if (soap_new_block(soap)) + return NULL; +#endif + for (;;) + { +#ifdef WITH_FAST + register size_t k; + if (soap_append_lab(soap, NULL, 0)) /* allocate more space in look-aside buffer if necessary */ + return NULL; + s = soap->labbuf + soap->labidx; /* space to populate */ + k = soap->lablen - soap->labidx; /* number of bytes available */ + soap->labidx = soap->lablen; /* claim this space */ +#else + register size_t k = SOAP_BLKLEN; + if (!(s = (char*)soap_push_block(soap, k))) + return NULL; +#endif + for (i = 0; i < k; i++) + { if (m > 0) + { *s++ = *t++; /* copy multibyte characters */ + m--; + continue; + } + if (soap->mode & SOAP_C_UTFSTRING) + { if (((c = soap_get(soap)) & 0x80000000) && c >= -0x7FFFFF80 && c < SOAP_AP) + { c &= 0x7FFFFFFF; + t = buf; + if (c < 0x0800) + *t++ = (char)(0xC0 | ((c >> 6) & 0x1F)); + else + { if (c < 0x010000) + *t++ = (char)(0xE0 | ((c >> 12) & 0x0F)); + else + { if (c < 0x200000) + *t++ = (char)(0xF0 | ((c >> 18) & 0x07)); + else + { if (c < 0x04000000) + *t++ = (char)(0xF8 | ((c >> 24) & 0x03)); + else + { *t++ = (char)(0xFC | ((c >> 30) & 0x01)); + *t++ = (char)(0x80 | ((c >> 24) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 18) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 12) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 6) & 0x3F)); + } + *t++ = (char)(0x80 | (c & 0x3F)); + m = (int)(t - buf) - 1; + t = buf; + *s++ = *t++; + continue; + } + } + else + c = soap_getutf8(soap); + switch (c) + { + case SOAP_TT: + if (n == 0) + goto end; + n--; + *s++ = '<'; + t = (char*)"/"; + m = 1; + break; + case SOAP_LT: + n++; + *s++ = '<'; + break; + case SOAP_GT: + *s++ = '>'; + break; + case SOAP_QT: + *s++ = '"'; + break; + case SOAP_AP: + *s++ = '\''; + break; + case '/': + if (n > 0) + { c = soap_get(soap); + if (c == SOAP_GT) + n--; + soap_unget(soap, c); + } + *s++ = '/'; + break; + case '<' | 0x80000000: + if (flag) + *s++ = '<'; + else + { *s++ = '&'; + t = (char*)"lt;"; + m = 3; + } + break; + case '>' | 0x80000000: + if (flag) + *s++ = '>'; + else + { *s++ = '&'; + t = (char*)"gt;"; + m = 3; + } + break; + case '&' | 0x80000000: + if (flag) + *s++ = '&'; + else + { *s++ = '&'; + t = (char*)"amp;"; + m = 4; + } + break; + case '"' | 0x80000000: + if (flag) + *s++ = '"'; + else + { *s++ = '&'; + t = (char*)"quot;"; + m = 5; + } + break; + case '\'' | 0x80000000: + if (flag) + *s++ = '\''; + else + { *s++ = '&'; + t = (char*)"apos;"; + m = 5; + } + break; + default: + if ((int)c == EOF) + goto end; +#ifndef WITH_LEANER +#ifdef HAVE_WCTOMB + if (soap->mode & SOAP_C_MBSTRING) + { m = wctomb(buf, c & 0x7FFFFFFF); + if (m >= 1 && m <= (int)MB_CUR_MAX) + { t = buf; + *s++ = *t++; + m--; + } + else + { *s++ = SOAP_UNKNOWN_CHAR; + m = 0; + } + } + else +#endif +#endif + *s++ = (char)(c & 0xFF); + } + l++; + if ((soap->mode & SOAP_XML_STRICT) && maxlen >= 0 && l > maxlen) + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen)); + soap->error = SOAP_LENGTH; + return NULL; + } + } + } +end: + soap_unget(soap, c); + *s = '\0'; +#ifdef WITH_FAST + t = soap_strdup(soap, soap->labbuf); +#else + soap_size_block(soap, i+1); + t = soap_save_block(soap, NULL, 0); +#endif + if ((soap->mode & SOAP_XML_STRICT) && l < minlen) + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too short: %ld chars, minlen=%ld\n", l, minlen)); + soap->error = SOAP_LENGTH; + return NULL; + } +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { if (flag == 3) + soap->dom->tail = t; + else + soap->dom->data = t; + } +#endif + if (flag == 2) + if (soap_s2QName(soap, t, &t)) + return NULL; + return t; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_wstring_out(struct soap *soap, const wchar_t *s, int flag) +{ const char *t; + char tmp; + register soap_wchar c; +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + { wchar_t *r = (wchar_t*)s; + int n = 1; + while (*r++) + n++; + soap->dom->wide = r = (wchar_t*)soap_malloc(soap, n * sizeof(wchar_t)); + while (n--) + *r++ = *s++; + return SOAP_OK; + } +#endif + while ((c = *s++)) + { switch (c) + { + case 9: + if (flag) + t = " "; + else + t = "\t"; + break; + case 10: + if (flag || !(soap->mode & SOAP_XML_CANONICAL)) + t = " "; + else + t = "\n"; + break; + case 13: + t = " "; + break; + case '&': + t = "&"; + break; + case '<': + t = "<"; + break; + case '>': + if (flag) + t = ">"; + else + t = ">"; + break; + case '"': + if (flag) + t = """; + else + t = "\""; + break; + default: + if (c > 0 && c < 0x80) + { tmp = (char)c; + if (soap_send_raw(soap, &tmp, 1)) + return soap->error; + } + else if (soap_pututf8(soap, (unsigned long)c)) + return soap->error; + continue; + } + if (soap_send(soap, t)) + return soap->error; + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_2 +SOAP_FMAC1 +wchar_t * +SOAP_FMAC2 +soap_wstring_in(struct soap *soap, int flag, long minlen, long maxlen) +{ wchar_t *s; + register int i, n = 0; + register long l = 0; + register soap_wchar c; + const char *t = NULL; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Reading wide string content\n")); + if (soap->peeked) + { if (!soap->body) + return NULL; + if (*soap->tag) + { n = 1; + soap->peeked = 0; + } + } + if (soap_new_block(soap)) + return NULL; + for (;;) + { if (!(s = (wchar_t*)soap_push_block(soap, sizeof(wchar_t)*SOAP_BLKLEN))) + return NULL; + for (i = 0; i < SOAP_BLKLEN; i++) + { if (t) + { *s++ = (wchar_t)*t++; + if (!*t) + t = NULL; + continue; + } + c = soap_getutf8(soap); + switch (c) + { + case SOAP_TT: + if (n == 0) + goto end; + n--; + *s++ = '<'; + soap_unget(soap, '/'); + break; + case SOAP_LT: + n++; + *s++ = '<'; + break; + case SOAP_GT: + *s++ = '>'; + break; + case SOAP_QT: + *s++ = '"'; + break; + case SOAP_AP: + *s++ = '\''; + break; + case '/': + if (n > 0) + { c = soap_getutf8(soap); + if (c == SOAP_GT) + n--; + soap_unget(soap, c); + } + *s++ = '/'; + break; + case '<': + if (flag) + *s++ = (soap_wchar)'<'; + else + { *s++ = (soap_wchar)'&'; + t = "lt;"; + } + break; + case '>': + if (flag) + *s++ = (soap_wchar)'>'; + else + { *s++ = (soap_wchar)'&'; + t = "gt;"; + } + break; + case '"': + if (flag) + *s++ = (soap_wchar)'"'; + else + { *s++ = (soap_wchar)'&'; + t = "quot;"; + } + break; + default: + if ((int)c == EOF) + goto end; + *s++ = (wchar_t)c & 0x7FFFFFFF; + } + l++; + if ((soap->mode & SOAP_XML_STRICT) && maxlen >= 0 && l > maxlen) + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too long: maxlen=%ld\n", maxlen)); + soap->error = SOAP_LENGTH; + return NULL; + } + } + } +end: + soap_unget(soap, c); + *s = '\0'; + soap_size_block(soap, sizeof(wchar_t) * (i + 1)); + if ((soap->mode & SOAP_XML_STRICT) && l < minlen) + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "String too short: %ld chars, minlen=%ld\n", l, minlen)); + soap->error = SOAP_LENGTH; + return NULL; + } + s = (wchar_t*)soap_save_block(soap, NULL, 0); +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + soap->dom->wide = s; +#endif + return s; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_int2s(struct soap *soap, int n) +{ return soap_long2s(soap, (long)n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outint(struct soap *soap, const char *tag, int id, const int *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_long2s(soap, (long)*p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2int(struct soap *soap, const char *s, int *p) +{ if (s) + { char *r; +#ifndef WITH_NOIO +#ifndef WITH_LEAN + soap_reset_errno; +#endif +#endif + *p = (int)soap_strtol(s, &r, 10); + if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r +#ifndef WITH_NOIO +#ifndef WITH_LEAN + || soap_errno == SOAP_ERANGE +#endif +#endif + ) + soap->error = SOAP_TYPE; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int * +SOAP_FMAC2 +soap_inint(struct soap *soap, const char *tag, int *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":int") + && soap_match_tag(soap, soap->type, ":short") + && soap_match_tag(soap, soap->type, ":byte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } +#endif + p = (int*)soap_id_enter(soap, soap->id, p, t, sizeof(int), 0, NULL, NULL, NULL); + if (*soap->href) + p = (int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(int), 0, NULL); + else if (p) + { if (soap_s2int(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_long2s(struct soap *soap, long n) +{ sprintf(soap->tmpbuf, "%ld", n); + return soap->tmpbuf; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outlong(struct soap *soap, const char *tag, int id, const long *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_long2s(soap, *p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2long(struct soap *soap, const char *s, long *p) +{ if (s) + { char *r; +#ifndef WITH_NOIO +#ifndef WITH_LEAN + soap_reset_errno; +#endif +#endif + *p = soap_strtol(s, &r, 10); + if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r +#ifndef WITH_NOIO +#ifndef WITH_LEAN + || soap_errno == SOAP_ERANGE +#endif +#endif + ) + soap->error = SOAP_TYPE; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +long * +SOAP_FMAC2 +soap_inlong(struct soap *soap, const char *tag, long *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":int") + && soap_match_tag(soap, soap->type, ":short") + && soap_match_tag(soap, soap->type, ":byte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } +#endif + p = (long*)soap_id_enter(soap, soap->id, p, t, sizeof(long), 0, NULL, NULL, NULL); + if (*soap->href) + p = (long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(long), 0, NULL); + else if (p) + { if (soap_s2long(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_LONG642s(struct soap *soap, LONG64 n) +{ sprintf(soap->tmpbuf, SOAP_LONG_FORMAT, n); + return soap->tmpbuf; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outLONG64(struct soap *soap, const char *tag, int id, const LONG64 *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_LONG642s(soap, *p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2LONG64(struct soap *soap, const char *s, LONG64 *p) +{ if (s) + { +#ifdef HAVE_STRTOLL + char *r; +#ifndef WITH_NOIO +#ifndef WITH_LEAN + soap_reset_errno; +#endif +#endif + *p = strtoll(s, &r, 10); + if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r +#ifndef WITH_NOIO +#ifndef WITH_LEAN + || soap_errno == SOAP_ERANGE +#endif +#endif + ) +#else +# ifdef HAVE_SSCANF + if (sscanf(s, SOAP_LONG_FORMAT, p) != 1) +# endif +#endif + soap->error = SOAP_TYPE; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +LONG64 * +SOAP_FMAC2 +soap_inLONG64(struct soap *soap, const char *tag, LONG64 *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":integer") + && soap_match_tag(soap, soap->type, ":positiveInteger") + && soap_match_tag(soap, soap->type, ":negativeInteger") + && soap_match_tag(soap, soap->type, ":nonPositiveInteger") + && soap_match_tag(soap, soap->type, ":nonNegativeInteger") + && soap_match_tag(soap, soap->type, ":long") + && soap_match_tag(soap, soap->type, ":int") + && soap_match_tag(soap, soap->type, ":short") + && soap_match_tag(soap, soap->type, ":byte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } +#endif + p = (LONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(LONG64), 0, NULL, NULL, NULL); + if (*soap->href) + p = (LONG64*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(LONG64), 0, NULL); + else if (p) + { if (soap_s2LONG64(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_byte2s(struct soap *soap, char n) +{ return soap_long2s(soap, (long)n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outbyte(struct soap *soap, const char *tag, int id, const char *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_long2s(soap, (long)*p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2byte(struct soap *soap, const char *s, char *p) +{ if (s) + { long n; + char *r; + n = soap_strtol(s, &r, 10); + if (s == r || *r || n < -128 || n > 127) + soap->error = SOAP_TYPE; + *p = (char)n; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_inbyte(struct soap *soap, const char *tag, char *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":byte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } +#endif + p = (char*)soap_id_enter(soap, soap->id, p, t, sizeof(char), 0, NULL, NULL, NULL); + if (*soap->href) + p = (char*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(char), 0, NULL); + else if (p) + { if (soap_s2byte(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_short2s(struct soap *soap, short n) +{ return soap_long2s(soap, (long)n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outshort(struct soap *soap, const char *tag, int id, const short *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_long2s(soap, (long)*p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2short(struct soap *soap, const char *s, short *p) +{ if (s) + { long n; + char *r; + n = soap_strtol(s, &r, 10); + if (s == r || *r || n < -32768 || n > 32767) + soap->error = SOAP_TYPE; + *p = (short)n; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +short * +SOAP_FMAC2 +soap_inshort(struct soap *soap, const char *tag, short *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":short") + && soap_match_tag(soap, soap->type, ":byte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } +#endif + p = (short*)soap_id_enter(soap, soap->id, p, t, sizeof(short), 0, NULL, NULL, NULL); + if (*soap->href) + p = (short*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(short), 0, NULL); + else if (p) + { if (soap_s2short(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_float2s(struct soap *soap, float n) +{ char *s; + if (soap_isnan((double)n)) + s = "NaN"; + else if (soap_ispinff(n)) + s = "INF"; + else if (soap_isninff(n)) + s = "-INF"; + else + { char *t; + s = soap->tmpbuf; + sprintf(soap->tmpbuf, soap->float_format, n); + t = strchr(s, ','); /* convert decimal comma to DP */ + if (t) + *t = '.'; + } + return s; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outfloat(struct soap *soap, const char *tag, int id, const float *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_float2s(soap, *p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2float(struct soap *soap, const char *s, float *p) +{ if (s) + { if (!*s) + return soap->error = SOAP_TYPE; + if (!soap_tag_cmp(s, "INF")) + *p = FLT_PINFTY; + else if (!soap_tag_cmp(s, "+INF")) + *p = FLT_PINFTY; + else if (!soap_tag_cmp(s, "-INF")) + *p = FLT_NINFTY; + else if (!soap_tag_cmp(s, "NaN")) + *p = FLT_NAN; + else + { +/* On some systems, strtof appears to be broken or doesn't link: use with caution */ +#if defined(HAVE_STRTOF) + char *r; + *p = strtof((char*)s, &r); + if (*r) +#elif defined(HAVE_STRTOD) + char *r; + *p = (float)strtod(s, &r); + if (*r) +#endif +#ifdef HAVE_SSCANF + if (sscanf(s, "%g", p) != 1) + soap->error = SOAP_TYPE; +#else + soap->error = SOAP_TYPE; +#endif + } + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +static int soap_isnumeric(struct soap *soap, const char *type) +{ if (soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":float") + && soap_match_tag(soap, soap->type, ":double") + && soap_match_tag(soap, soap->type, ":decimal") + && soap_match_tag(soap, soap->type, ":integer") + && soap_match_tag(soap, soap->type, ":positiveInteger") + && soap_match_tag(soap, soap->type, ":negativeInteger") + && soap_match_tag(soap, soap->type, ":nonPositiveInteger") + && soap_match_tag(soap, soap->type, ":nonNegativeInteger") + && soap_match_tag(soap, soap->type, ":long") + && soap_match_tag(soap, soap->type, ":int") + && soap_match_tag(soap, soap->type, ":short") + && soap_match_tag(soap, soap->type, ":byte") + && soap_match_tag(soap, soap->type, ":unsignedLong") + && soap_match_tag(soap, soap->type, ":unsignedInt") + && soap_match_tag(soap, soap->type, ":unsignedShort") + && soap_match_tag(soap, soap->type, ":unsignedByte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return SOAP_ERR; + } + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +float * +SOAP_FMAC2 +soap_infloat(struct soap *soap, const char *tag, float *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type != '\0' && soap_isnumeric(soap, type)) + return NULL; +#endif + p = (float*)soap_id_enter(soap, soap->id, p, t, sizeof(float), 0, NULL, NULL, NULL); + if (*soap->href) + p = (float*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(float), 0, NULL); + else if (p) + { if (soap_s2float(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_double2s(struct soap *soap, double n) +{ char *s; + if (soap_isnan(n)) + s = "NaN"; + else if (soap_ispinfd(n)) + s = "INF"; + else if (soap_isninfd(n)) + s = "-INF"; + else + { char *t; + s = soap->tmpbuf; + sprintf(soap->tmpbuf, soap->double_format, n); + t = strchr(s, ','); /* convert decimal comma to DP */ + if (t) + *t = '.'; + } + return s; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outdouble(struct soap *soap, const char *tag, int id, const double *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_double2s(soap, *p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2double(struct soap *soap, const char *s, double *p) +{ if (s) + { if (!*s) + return soap->error = SOAP_TYPE; + if (!soap_tag_cmp(s, "INF")) + *p = DBL_PINFTY; + else if (!soap_tag_cmp(s, "+INF")) + *p = DBL_PINFTY; + else if (!soap_tag_cmp(s, "-INF")) + *p = DBL_NINFTY; + else if (!soap_tag_cmp(s, "NaN")) + *p = DBL_NAN; + else + { +#ifdef HAVE_STRTOD + char *r; + *p = strtod(s, &r); + if (*r) +#endif +#ifdef HAVE_SSCANF + if (sscanf(s, "%lg", p) != 1) + soap->error = SOAP_TYPE; +#else + soap->error = SOAP_TYPE; +#endif + } + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +double * +SOAP_FMAC2 +soap_indouble(struct soap *soap, const char *tag, double *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type != '\0' && soap_isnumeric(soap, type)) + return NULL; +#endif + p = (double*)soap_id_enter(soap, soap->id, p, t, sizeof(double), 0, NULL, NULL, NULL); + if (*soap->href) + p = (double*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(double), 0, NULL); + else if (p) + { if (soap_s2double(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_unsignedByte2s(struct soap *soap, unsigned char n) +{ return soap_unsignedLong2s(soap, (unsigned long)n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outunsignedByte(struct soap *soap, const char *tag, int id, const unsigned char *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2unsignedByte(struct soap *soap, const char *s, unsigned char *p) +{ if (s) + { unsigned long n; + char *r; + n = soap_strtoul(s, &r, 10); + if (s == r || *r || n > 255) + soap->error = SOAP_TYPE; + *p = (unsigned char)n; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +unsigned char * +SOAP_FMAC2 +soap_inunsignedByte(struct soap *soap, const char *tag, unsigned char *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":unsignedByte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } +#endif + p = (unsigned char*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned char), 0, NULL, NULL, NULL); + if (*soap->href) + p = (unsigned char*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned char), 0, NULL); + else if (p) + { if (soap_s2unsignedByte(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_unsignedShort2s(struct soap *soap, unsigned short n) +{ return soap_unsignedLong2s(soap, (unsigned long)n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outunsignedShort(struct soap *soap, const char *tag, int id, const unsigned short *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2unsignedShort(struct soap *soap, const char *s, unsigned short *p) +{ if (s) + { unsigned long n; + char *r; + n = soap_strtoul(s, &r, 10); + if (s == r || *r || n > 65535) + soap->error = SOAP_TYPE; + *p = (unsigned short)n; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +unsigned short * +SOAP_FMAC2 +soap_inunsignedShort(struct soap *soap, const char *tag, unsigned short *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":unsignedShort") + && soap_match_tag(soap, soap->type, ":unsignedByte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } +#endif + p = (unsigned short*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned short), 0, NULL, NULL, NULL); + if (*soap->href) + p = (unsigned short*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned short), 0, NULL); + else if (p) + { if (soap_s2unsignedShort(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_unsignedInt2s(struct soap *soap, unsigned int n) +{ return soap_unsignedLong2s(soap, (unsigned long)n); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outunsignedInt(struct soap *soap, const char *tag, int id, const unsigned int *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_unsignedLong2s(soap, (unsigned long)*p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2unsignedInt(struct soap *soap, const char *s, unsigned int *p) +{ if (s) + { char *r; +#ifndef WITH_NOIO +#ifndef WITH_LEAN + soap_reset_errno; +#endif +#endif + *p = (unsigned int)soap_strtoul(s, &r, 10); + if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r +#ifndef WITH_NOIO +#ifndef WITH_LEAN + || soap_errno == SOAP_ERANGE +#endif +#endif + ) + soap->error = SOAP_TYPE; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +unsigned int * +SOAP_FMAC2 +soap_inunsignedInt(struct soap *soap, const char *tag, unsigned int *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":unsignedInt") + && soap_match_tag(soap, soap->type, ":unsignedShort") + && soap_match_tag(soap, soap->type, ":unsignedByte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } +#endif + p = (unsigned int*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned int), 0, NULL, NULL, NULL); + if (*soap->href) + p = (unsigned int*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned int), 0, NULL); + else if (p) + { if (soap_s2unsignedInt(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_unsignedLong2s(struct soap *soap, unsigned long n) +{ sprintf(soap->tmpbuf, "%lu", n); + return soap->tmpbuf; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outunsignedLong(struct soap *soap, const char *tag, int id, const unsigned long *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_unsignedLong2s(soap, *p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2unsignedLong(struct soap *soap, const char *s, unsigned long *p) +{ if (s) + { char *r; +#ifndef WITH_NOIO +#ifndef WITH_LEAN + soap_reset_errno; +#endif +#endif + *p = soap_strtoul(s, &r, 10); + if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r +#ifndef WITH_NOIO +#ifndef WITH_LEAN + || soap_errno == SOAP_ERANGE +#endif +#endif + ) + soap->error = SOAP_TYPE; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +unsigned long * +SOAP_FMAC2 +soap_inunsignedLong(struct soap *soap, const char *tag, unsigned long *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; +#ifndef WITH_LEAN + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":unsignedInt") + && soap_match_tag(soap, soap->type, ":unsignedShort") + && soap_match_tag(soap, soap->type, ":unsignedByte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } +#endif + p = (unsigned long*)soap_id_enter(soap, soap->id, p, t, sizeof(unsigned long), 0, NULL, NULL, NULL); + if (*soap->href) + p = (unsigned long*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(unsigned long), 0, NULL); + else if (p) + { if (soap_s2unsignedLong(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_ULONG642s(struct soap *soap, ULONG64 n) +{ sprintf(soap->tmpbuf, SOAP_ULONG_FORMAT, n); + return soap->tmpbuf; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outULONG64(struct soap *soap, const char *tag, int id, const ULONG64 *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_ULONG642s(soap, *p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2ULONG64(struct soap *soap, const char *s, ULONG64 *p) +{ if (s) + { +#ifdef HAVE_STRTOULL + char *r; +#ifndef WITH_NOIO +#ifndef WITH_LEAN + soap_reset_errno; +#endif +#endif + *p = strtoull(s, &r, 10); + if ((s == r && (soap->mode & SOAP_XML_STRICT)) || *r +#ifndef WITH_NOIO +#ifndef WITH_LEAN + || soap_errno == SOAP_ERANGE +#endif +#endif + ) +#else +# ifdef HAVE_SSCANF + if (sscanf(s, SOAP_ULONG_FORMAT, p) != 1) +# endif +#endif + soap->error = SOAP_TYPE; + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +ULONG64 * +SOAP_FMAC2 +soap_inULONG64(struct soap *soap, const char *tag, ULONG64 *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":positiveInteger") + && soap_match_tag(soap, soap->type, ":nonNegativeInteger") + && soap_match_tag(soap, soap->type, ":unsignedLong") + && soap_match_tag(soap, soap->type, ":unsignedInt") + && soap_match_tag(soap, soap->type, ":unsignedShort") + && soap_match_tag(soap, soap->type, ":unsignedByte")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } + p = (ULONG64*)soap_id_enter(soap, soap->id, p, t, sizeof(ULONG64), 0, NULL, NULL, NULL); + if (*soap->href) + p = (ULONG64*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(ULONG64), 0, NULL); + else if (p) + { if (soap_s2ULONG64(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2string(struct soap *soap, const char *s, char **t) +{ *t = NULL; + if (s) + { if (!(*t = soap_strdup(soap, s))) + return soap->error = SOAP_EOM; + if (!(soap->mode & (SOAP_ENC_LATIN | SOAP_C_UTFSTRING))) + { /* TODO: consider truncating UTF8 to ASCII for regular XML attribute strings? */ + } + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2QName(struct soap *soap, const char *s, char **t) +{ if (s) + { struct soap_nlist *np; + const char *p; + if (!strncmp(s, "xml:", 4)) + { *t = soap_strdup(soap, s); + return SOAP_OK; + } + np = soap->nlist; + p = strchr(s, ':'); + if (p) + { register int n = p - s; + while (np && (strncmp(np->id, s, n) || np->id[n])) + np = np->next; + p++; + } + else + { while (np && *np->id) + np = np->next; + p = s; + } + if (np) + { if (np->index >= 0 && soap->local_namespaces) + { register const char *q = soap->local_namespaces[np->index].id; + if (q) + { if ((*t = (char*)soap_malloc(soap, strlen(p) + strlen(q) + 2))) + sprintf(*t, "%s:%s", q, p); + return SOAP_OK; + } + } + if (np->ns) + { if ((*t = (char*)soap_malloc(soap, strlen(p) + strlen(np->ns) + 4))) + sprintf(*t, "\"%s\":%s", np->ns, p); + return SOAP_OK; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Namespace prefix of '%s' not defined (index=%d, URI=%s)\n", s, np->index, np->ns?np->ns:"")); + return soap->error = SOAP_NAMESPACE; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Namespace prefix of '%s' not defined, assuming empty namespace\n", s)); + if ((*t = (char*)soap_malloc(soap, strlen(p) + 4))) + sprintf(*t, "\"\":%s", p); + } + else + *t = NULL; + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_QName2s(struct soap *soap, const char *s) +{ struct Namespace *p; + char *t; + int n; + if (!s || *s != '"') + { +#ifndef WITH_LEAN + if (s && (soap->mode & SOAP_XML_CANONICAL)) + { t = (char*)strchr(s, ':'); + if (t) + soap_utilize_ns(soap, s, t - s); + } +#endif + return s; + } + s++; + if ((p = soap->local_namespaces)) + { for (; p->id; p++) + { if (p->ns) + if (!soap_tag_cmp(s, p->ns)) + break; + if (p->in) + if (!soap_tag_cmp(s, p->in)) + break; + } + if (p && p->id) + { s = strchr(s, '"'); + if (s) + { t = (char*)soap_malloc(soap, strlen(p->id) + strlen(s)); + strcpy(t, p->id); + strcat(t, s + 1); + return t; + } + } + } + t = (char*)strchr(s, '"'); + if (t) + n = t - s; + else + n = 0; + t = soap_strdup(soap, s); + t[n] = '\0'; + sprintf(soap->tmpbuf, "xmlns:_%d", soap->idnum++); + soap_set_attr(soap, soap->tmpbuf, t); + s = strchr(s, '"'); + if (s) + { t = (char*)soap_malloc(soap, strlen(soap->tmpbuf) + strlen(s) - 6); + strcpy(t, soap->tmpbuf + 6); + strcat(t, s + 1); + } + return t; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2wchar(struct soap *soap, const char *s, wchar_t **t) +{ wchar_t *r; + if (!s) + *t = NULL; + else + { *t = r = (wchar_t*)soap_malloc(soap, sizeof(wchar_t) * (strlen(s) + 1)); + if (!r) + return soap->error; + if (soap->mode & SOAP_ENC_LATIN) + { while (*s) + *r++ = (wchar_t)*s++; + } + else + { /* Convert UTF8 to wchar */ + while (*s) + { register soap_wchar c, c1, c2, c3, c4; + c = *s++; + if (c < 0x80) + *r++ = (wchar_t)c; + else + { c1 = (soap_wchar)*s++ & 0x3F; + if (c < 0xE0) + *r++ = (wchar_t)(((soap_wchar)(c & 0x1F) << 6) | c1); + else + { c2 = (soap_wchar)*s++ & 0x3F; + if (c < 0xF0) + *r++ = (wchar_t)(((soap_wchar)(c & 0x0F) << 12) | (c1 << 6) | c2); + else + { c3 = (soap_wchar)*s++ & 0x3F; + if (c < 0xF8) + *r++ = (wchar_t)(((soap_wchar)(c & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3); + else + { c4 = (soap_wchar)*s++ & 0x3F; + if (c < 0xFC) + *r++ = (wchar_t)(((soap_wchar)(c & 0x03) << 24) | (c1 << 18) | (c2 << 12) | (c3 << 6) | c4); + else + *r++ = (wchar_t)(((soap_wchar)(c & 0x01) << 30) | (c1 << 24) | (c2 << 18) | (c3 << 12) | (c4 << 6) | (soap_wchar)(*s++ & 0x3F)); + } + } + } + } + } + } + *r = L'\0'; + } + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_wchar2s(struct soap *soap, const wchar_t *s) +{ register soap_wchar c; + register char *r, *t; + const wchar_t *q = s; + size_t n = 0; + while ((c = *q++)) + { if (c > 0 && c < 0x80) + n++; + else + n += 6; + } + r = t = (char*)soap_malloc(soap, n + 1); + if (r) + { /* Convert wchar to UTF8 */ + while ((c = *s++)) + { if (c > 0 && c < 0x80) + *t++ = (char)c; + else + { if (c < 0x0800) + *t++ = (char)(0xC0 | ((c >> 6) & 0x1F)); + else + { if (c < 0x010000) + *t++ = (char)(0xE0 | ((c >> 12) & 0x0F)); + else + { if (c < 0x200000) + *t++ = (char)(0xF0 | ((c >> 18) & 0x07)); + else + { if (c < 0x04000000) + *t++ = (char)(0xF8 | ((c >> 24) & 0x03)); + else + { *t++ = (char)(0xFC | ((c >> 30) & 0x01)); + *t++ = (char)(0x80 | ((c >> 24) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 18) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 12) & 0x3F)); + } + *t++ = (char)(0x80 | ((c >> 6) & 0x3F)); + } + *t++ = (char)(0x80 | (c & 0x3F)); + } + } + *t = '\0'; + } + return r; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outstring(struct soap *soap, const char *tag, int id, char *const*p, const char *type, int n) +{ id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n); + if (id < 0) + return soap->error; + if (!**p && (soap->mode & SOAP_C_NILSTRING)) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, id, type) + || soap_string_out(soap, *p, 0) + || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +char ** +SOAP_FMAC2 +soap_instring(struct soap *soap, const char *tag, char **p, const char *type, int t, int flag, long minlen, long maxlen) +{ if (soap_element_begin_in(soap, tag, 1, NULL)) + { if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG) + return NULL; + soap->error = SOAP_OK; + } + if (!p) + if (!(p = (char**)soap_malloc(soap, sizeof(char*)))) + return NULL; + if (soap->body) + { *p = soap_string_in(soap, flag, minlen, maxlen); + if (!*p || !(char*)soap_id_enter(soap, soap->id, *p, t, sizeof(char*), 0, NULL, NULL, NULL)) + return NULL; + } + else if (soap->null) + *p = NULL; + else + *p = (char*)SOAP_STR_EOS; + if (*soap->href) + p = (char**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(char**), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outwstring(struct soap *soap, const char *tag, int id, wchar_t *const*p, const char *type, int n) +{ id = soap_element_id(soap, tag, id, *p, NULL, 0, type, n); + if (id < 0) + return soap->error; + if (!**p && (soap->mode & SOAP_C_NILSTRING)) + return soap_element_null(soap, tag, id, type); + if (soap_element_begin_out(soap, tag, id, type) + || soap_wstring_out(soap, *p, 0) + || soap_element_end_out(soap, tag)) + return soap->error; + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_2 +SOAP_FMAC1 +wchar_t ** +SOAP_FMAC2 +soap_inwstring(struct soap *soap, const char *tag, wchar_t **p, const char *type, int t, long minlen, long maxlen) +{ if (soap_element_begin_in(soap, tag, 1, NULL)) + { if (!tag || *tag != '-' || soap->error != SOAP_NO_TAG) + return NULL; + soap->error = SOAP_OK; + } + if (!p) + if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*)))) + return NULL; + if (soap->body) + { *p = soap_wstring_in(soap, 1, minlen, maxlen); + if (!*p || !(wchar_t*)soap_id_enter(soap, soap->id, *p, t, sizeof(wchar_t*), 0, NULL, NULL, NULL)) + return NULL; + } + else if (soap->null) + *p = NULL; + else + *p = (wchar_t*)SOAP_STR_EOS; + if (*soap->href) + p = (wchar_t**)soap_id_lookup(soap, soap->href, (void**)p, t, sizeof(wchar_t**), 0); + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +static time_t +soap_timegm(struct tm *T) +{ +#if defined(HAVE_TIMEGM) + return timegm(T); +#else + time_t t, g, z; +#ifdef HAVE_GMTIME_R + struct tm tm, *tmp = &tm; +#else + struct tm *tmp; +#endif + t = mktime(T); + if (t == -1) + return -1; +#ifdef HAVE_GMTIME_R + gmtime_r(&t, tmp); +#else + tmp = gmtime(&t); +#endif + tmp->tm_isdst = 0; + g = mktime(tmp); + if (g == -1) + return -1; + z = g - t; + return t - z; +#endif +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_dateTime2s(struct soap *soap, time_t n) +{ struct tm T, *pT = &T; +#if defined(HAVE_GMTIME_R) + if (gmtime_r(&n, pT)) + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT); + /* The following defines were added for VxWorks*/ +#elif defined(HAVE_PGMTIME_R) + if (gmtime_r(&n, pT)) + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT); +#elif defined(HAVE_PGMTIME) + if (gmtime(&n, pT)) + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT); +#elif defined(HAVE_GMTIME) + if ((pT = gmtime(&n))) + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%SZ", pT); +#elif defined(HAVE_GETTIMEOFDAY) + struct timezone tz; + memset((void*)&tz, 0, sizeof(tz)); +# if defined(HAVE_LOCALTIME_R) + if (localtime_r(&n, pT)) + { struct timeval tv; + gettimeofday(&tv, &tz); + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT); + sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60); + } +# else + if ((pT = localtime(&n))) + { struct timeval tv; + gettimeofday(&tv, &tz); + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT); + sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -tz.tz_minuteswest/60+(pT->tm_isdst!=0), abs(tz.tz_minuteswest)%60); + } +#endif +#elif defined(HAVE_FTIME) + struct timeb t; + memset((void*)&t, 0, sizeof(t)); +# if defined(HAVE_LOCALTIME_R) + if (localtime_r(&n, pT)) + { ftime(&t); + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT); + sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60); + } + /* The following defines were added for VxWorks*/ +# elif defined(HAVE_PLOCALTIME_R) + if (localtime_r(&n, pT)) + { strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT); + sprintf(soap->tmpbuf+strlen(soap->tmpbuf), "%+03d:%02d", t.timezone/60, abs(t.timezone)%60); + } +# else + if ((pT = localtime(&n))) + { ftime(&t); + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT); + sprintf(soap->tmpbuf + strlen(soap->tmpbuf), "%+03d:%02d", -t.timezone/60+(pT->tm_isdst!=0), abs(t.timezone)%60); + } +# endif +#elif defined(HAVE_LOCALTIME_R) + if (localtime_r(&n, pT)) + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT); + /* The following defines were added for VxWorks*/ +#elif defined(HAVE_PLOCALTIME_R) + if (localtime_r(&n, pT)) + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT); +#else + if ((pT = localtime(&n))) + strftime(soap->tmpbuf, sizeof(soap->tmpbuf), "%Y-%m-%dT%H:%M:%S", pT); +#endif + else + strcpy(soap->tmpbuf, "1969-12-31T23:59:59Z"); + return soap->tmpbuf; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outdateTime(struct soap *soap, const char *tag, int id, const time_t *p, const char *type, int n) +{ if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, p, n), type) + || soap_string_out(soap, soap_dateTime2s(soap, *p), 0)) + return soap->error; + return soap_element_end_out(soap, tag); +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_s2dateTime(struct soap *soap, const char *s, time_t *p) +{ if (s) + { struct tm T; + char zone[32]; + const char *t; + memset((void*)&T, 0, sizeof(T)); + zone[sizeof(zone)-1] = '\0'; + if (strchr(s, '-')) + t = "%d-%d-%dT%d:%d:%d%31s"; + else if (strchr(s, ':')) + t = "%4d%2d%2dT%d:%d:%d%31s"; + else /* parse non-XSD-standard alternative ISO 8601 format */ + t = "%4d%2d%2dT%2d%2d%2d%31s"; + sscanf(s, t, &T.tm_year, &T.tm_mon, &T.tm_mday, &T.tm_hour, &T.tm_min, &T.tm_sec, zone); + if (T.tm_year == 1) + T.tm_year = 70; + else + T.tm_year -= 1900; + T.tm_mon--; + if (*zone) + { if (*zone == '.') + { for (s = zone + 1; *s; s++) + if (*s < '0' || *s > '9') + break; + } + else + s = zone; + if (*s == '+' || *s == '-') + { int h = 0, m = 0; + if (s[3] == ':') + { sscanf(s, "%d:%d", &h, &m); + if (h < 0) + m = -m; + } + else + { m = (int)atol(s); + h = m / 100; + m = m % 100; + } + T.tm_hour -= h; + T.tm_min -= m; + } + T.tm_isdst = 0; + *p = soap_timegm(&T); + } + else + { T.tm_isdst = -1; + *p = mktime(&T); /* no time zone: suppose it is localtime? */ + } + } + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +time_t * +SOAP_FMAC2 +soap_indateTime(struct soap *soap, const char *tag, time_t *p, const char *type, int t) +{ if (soap_element_begin_in(soap, tag, 0, NULL)) + return NULL; + if (*soap->type + && soap_match_tag(soap, soap->type, type) + && soap_match_tag(soap, soap->type, ":dateTime")) + { soap->error = SOAP_TYPE; + soap_revert(soap); + return NULL; + } + p = (time_t*)soap_id_enter(soap, soap->id, p, t, sizeof(time_t), 0, NULL, NULL, NULL); + if (*soap->href) + p = (time_t*)soap_id_forward(soap, soap->href, p, 0, t, 0, sizeof(time_t), 0, NULL); + else if (p) + { if (soap_s2dateTime(soap, soap_value(soap), p)) + return NULL; + } + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outliteral(struct soap *soap, const char *tag, char *const*p, const char *type) +{ int i; + const char *t = NULL; + if (tag && *tag != '-') + { if (soap->local_namespaces && (t = strchr(tag, ':'))) + { strncpy(soap->tmpbuf, tag, t-tag); + soap->tmpbuf[t-tag] = '\0'; + for (i = 0; soap->local_namespaces[i].id; i++) + if (!strcmp(soap->tmpbuf, soap->local_namespaces[i].id)) + break; + t++; + if (soap_element(soap, t, 0, type) + || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS) + || soap_element_start_end_out(soap, NULL)) + return soap->error; + } + else + { t = tag; + if (soap_element_begin_out(soap, t, 0, type)) + return soap->error; + } + } + if (p && *p) + { if (soap_send(soap, *p)) + return soap->error; + } + if (t) + return soap_element_end_out(soap, t); + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +char ** +SOAP_FMAC2 +soap_inliteral(struct soap *soap, const char *tag, char **p) +{ if (soap_element_begin_in(soap, tag, 1, NULL)) + { if (soap->error != SOAP_NO_TAG || soap_unget(soap, soap_get(soap)) == SOAP_TT) + return NULL; + soap->error = SOAP_OK; + } + if (!p) + if (!(p = (char**)soap_malloc(soap, sizeof(char*)))) + return NULL; + if (soap->body) + *p = soap_string_in(soap, 0, -1, -1); + else if (soap->null) + *p = NULL; + else + *p = (char*)SOAP_STR_EOS; + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_outwliteral(struct soap *soap, const char *tag, wchar_t *const*p, const char *type) +{ int i; + const char *t = NULL; + if (tag && *tag != '-') + { if (soap->local_namespaces && (t = strchr(tag, ':'))) + { strncpy(soap->tmpbuf, tag, t-tag); + soap->tmpbuf[t-tag] = '\0'; + for (i = 0; soap->local_namespaces[i].id; i++) + if (!strcmp(soap->tmpbuf, soap->local_namespaces[i].id)) + break; + t++; + if (soap_element(soap, t, 0, type) + || soap_attribute(soap, "xmlns", soap->local_namespaces[i].ns ? soap->local_namespaces[i].ns : SOAP_STR_EOS) + || soap_element_start_end_out(soap, NULL)) + return soap->error; + } + else + { t = tag; + if (soap_element_begin_out(soap, t, 0, type)) + return soap->error; + } + if (soap_send(soap, soap->tmpbuf)) + return soap->error; + } + if (p) + { wchar_t c; + const wchar_t *s = *p; + while ((c = *s++)) + { if (soap_pututf8(soap, (unsigned long)c)) + return soap->error; + } + } + if (t) + return soap_element_end_out(soap, t); + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_2 +SOAP_FMAC1 +wchar_t ** +SOAP_FMAC2 +soap_inwliteral(struct soap *soap, const char *tag, wchar_t **p) +{ if (soap_element_begin_in(soap, tag, 1, NULL)) + { if (soap->error != SOAP_NO_TAG || soap_unget(soap, soap_get(soap)) == SOAP_TT) + return NULL; + soap->error = SOAP_OK; + } + if (!p) + if (!(p = (wchar_t**)soap_malloc(soap, sizeof(wchar_t*)))) + return NULL; + if (soap->body) + *p = soap_wstring_in(soap, 0, -1, -1); + else if (soap->null) + *p = NULL; + else + *p = (wchar_t*)SOAP_STR_EOS; + if (soap->body && soap_element_end_in(soap, tag)) + return NULL; + return p; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +const char * +SOAP_FMAC2 +soap_value(struct soap *soap) +{ register size_t i; + register soap_wchar c = 0; + register char *s = soap->tmpbuf; + if (!soap->body) + return SOAP_STR_EOS; + do c = soap_get(soap); + while (soap_blank(c)); + for (i = 0; i < sizeof(soap->tmpbuf) - 1; i++) + { if (c == SOAP_TT || (int)c == EOF) + break; + *s++ = (char)c; + c = soap_get(soap); + } + for (s--; i > 0; i--, s--) + { if (!soap_blank(*s)) + break; + } + s[1] = '\0'; + if ((int)c == EOF || c == SOAP_TT) + soap_unget(soap, c); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Element content value='%s'\n", soap->tmpbuf)); +#ifdef WITH_DOM + if ((soap->mode & SOAP_XML_DOM) && soap->dom) + soap->dom->data = soap_strdup(soap, soap->tmpbuf); +#endif + return soap->tmpbuf; /* return non-null pointer */ +} +#endif + +/******************************************************************************/ +#if !defined(WITH_LEANER) || !defined(WITH_NOHTTP) +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getline(struct soap *soap, char *s, int len) +{ int i = len; + soap_wchar c = 0; + for (;;) + { while (--i > 0) + { c = soap_getchar(soap); + if (c == '\r' || c == '\n') + break; + if ((int)c == EOF) + return soap->error = SOAP_EOF; + *s++ = (char)c; + } + if (c != '\n') + c = soap_getchar(soap); /* got \r, now get \n */ + if (c == '\n') + { *s = '\0'; + if (i+1 == len) /* empty line: end of HTTP/MIME header */ + break; + c = soap_unget(soap, soap_getchar(soap)); + if (c != ' ' && c != '\t') /* HTTP line continuation? */ + break; + } + else if ((int)c == EOF) + return soap->error = SOAP_EOF; + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +static size_t +soap_count_attachments(struct soap *soap) +{ +#ifndef WITH_LEANER + register struct soap_multipart *content; + register size_t count = soap->count; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the message size with attachments, current count=%lu\n", (unsigned long)count)); + if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM)) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the size of DIME attachments\n")); + for (content = soap->dime.first; content; content = content->next) + { count += 12 + ((content->size+3)&(~3)); + if (content->id) + count += ((strlen(content->id)+3)&(~3)); + if (content->type) + count += ((strlen(content->type)+3)&(~3)); + if (content->options) + count += ((((unsigned char)content->options[2] << 8) | ((unsigned char)content->options[3]))+7)&(~3); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of DIME attachment content is %lu bytes\n", (unsigned long)content->size)); + } + } + if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary) + { register size_t n = strlen(soap->mime.boundary); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Calculating the size of MIME attachments\n")); + for (content = soap->mime.first; content; content = content->next) + { register const char *s; + /* count \r\n--boundary\r\n */ + count += 6 + n; + /* count Content-Type: ...\r\n */ + if (content->type) + count += 16 + strlen(content->type); + /* count Content-Transfer-Encoding: ...\r\n */ + s = soap_code_str(mime_codes, content->encoding); + if (s) + count += 29 + strlen(s); + /* count Content-ID: ...\r\n */ + if (content->id) + count += 14 + strlen(content->id); + /* count Content-Location: ...\r\n */ + if (content->location) + count += 20 + strlen(content->location); + /* count Content-Description: ...\r\n */ + if (content->description) + count += 23 + strlen(content->description); + /* count \r\n...content */ + count += 2 + content->size; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Size of MIME attachment content is %lu bytes\n", (unsigned long)content->size)); + } + /* count \r\n--boundary-- */ + count += 6 + n; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "New count is %lu bytes\n", (unsigned long)count)); + return count; +#else + return soap->count; +#endif +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +static int +soap_putdimefield(struct soap *soap, const char *s, size_t n) +{ if (soap_send_raw(soap, s, n)) + return soap->error; + return soap_send_raw(soap, SOAP_STR_PADDING, -(long)n&3); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_dime_option(struct soap *soap, unsigned short optype, const char *option) +{ size_t n; + char *s = NULL; + if (option) + { n = strlen(option); + s = (char*)soap_malloc(soap, n + 5); + if (s) + { s[0] = optype >> 8; + s[1] = optype & 0xFF; + s[2] = n >> 8; + s[3] = n & 0xFF; + strcpy(s + 4, option); + } + } + return s; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_putdimehdr(struct soap *soap) +{ unsigned char tmp[12]; + size_t optlen = 0, idlen = 0, typelen = 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Put DIME header id='%s'\n", soap->dime.id?soap->dime.id:"")); + if (soap->dime.options) + optlen = (((unsigned char)soap->dime.options[2] << 8) | ((unsigned char)soap->dime.options[3])) + 4; + if (soap->dime.id) + idlen = strlen(soap->dime.id); + if (soap->dime.type) + typelen = strlen(soap->dime.type); + tmp[0] = SOAP_DIME_VERSION | (soap->dime.flags & 0x7); + tmp[1] = soap->dime.flags & 0xF0; + tmp[2] = optlen >> 8; + tmp[3] = optlen & 0xFF; + tmp[4] = idlen >> 8; + tmp[5] = idlen & 0xFF; + tmp[6] = typelen >> 8; + tmp[7] = typelen & 0xFF; + tmp[8] = soap->dime.size >> 24; + tmp[9] = (soap->dime.size >> 16) & 0xFF; + tmp[10] = (soap->dime.size >> 8) & 0xFF; + tmp[11] = soap->dime.size & 0xFF; + if (soap_send_raw(soap, (char*)tmp, 12) + || soap_putdimefield(soap, soap->dime.options, optlen) + || soap_putdimefield(soap, soap->dime.id, idlen) + || soap_putdimefield(soap, soap->dime.type, typelen)) + return soap->error; + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_putdime(struct soap *soap) +{ struct soap_multipart *content; + if (!(soap->mode & SOAP_ENC_DIME)) + return SOAP_OK; + for (content = soap->dime.first; content; content = content->next) + { void *handle; + soap->dime.size = content->size; + soap->dime.id = content->id; + soap->dime.type = content->type; + soap->dime.options = content->options; + soap->dime.flags = SOAP_DIME_VERSION | SOAP_DIME_MEDIA; + if (soap->fdimereadopen && ((handle = soap->fdimereadopen(soap, (void*)content->ptr, content->id, content->type, content->options)) || soap->error)) + { size_t size = content->size; + if (!handle) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadopen failed\n")); + return soap->error; + } + if (!size && ((soap->mode & SOAP_ENC_XML) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE)) + { size_t chunksize = sizeof(soap->tmpbuf); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming DIME\n")); + do + { size = soap->fdimeread(soap, handle, soap->tmpbuf, chunksize); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread returned %lu bytes\n", (unsigned long)size)); + if (size < chunksize) + { soap->dime.flags &= ~SOAP_DIME_CF; + if (!content->next) + soap->dime.flags |= SOAP_DIME_ME; + } + else + soap->dime.flags |= SOAP_DIME_CF; + soap->dime.size = size; + if (soap_putdimehdr(soap) + || soap_putdimefield(soap, soap->tmpbuf, size)) + break; + if (soap->dime.id) + { soap->dime.flags &= ~(SOAP_DIME_MB | SOAP_DIME_MEDIA); + soap->dime.id = NULL; + soap->dime.type = NULL; + soap->dime.options = NULL; + } + } while (size >= chunksize); + } + else + { if (!content->next) + soap->dime.flags |= SOAP_DIME_ME; + if (soap_putdimehdr(soap)) + return soap->error; + do + { size_t bufsize; + if (size < sizeof(soap->tmpbuf)) + bufsize = size; + else + bufsize = sizeof(soap->tmpbuf); + if (!(bufsize = soap->fdimeread(soap, handle, soap->tmpbuf, bufsize))) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size)); + soap->error = SOAP_EOF; + break; + } + if (soap_send_raw(soap, soap->tmpbuf, bufsize)) + break; + size -= bufsize; + } while (size); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadclose\n")); + soap_send_raw(soap, SOAP_STR_PADDING, -(long)soap->dime.size&3); + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fdimereadclose\n")); + if (soap->fdimereadclose) + soap->fdimereadclose(soap, handle); + } + else + { if (!content->next) + soap->dime.flags |= SOAP_DIME_ME; + if (soap_putdimehdr(soap) + || soap_putdimefield(soap, (char*)content->ptr, content->size)) + return soap->error; + } + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +static char * +soap_getdimefield(struct soap *soap, size_t n) +{ register soap_wchar c; + register int i; + register char *s; + char *p = NULL; + if (n) + { p = (char*)soap_malloc(soap, n + 1); + if (p) + { s = p; + for (i = n; i > 0; i--) + { if ((int)(c = soap_get1(soap)) == EOF) + { soap->error = SOAP_EOF; + return NULL; + } + *s++ = (char)c; + } + *s = '\0'; + if ((soap->error = soap_move(soap, -(long)n&3))) + return NULL; + } + else + soap->error = SOAP_EOM; + } + return p; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getdimehdr(struct soap *soap) +{ register soap_wchar c; + register char *s; + register int i; + unsigned char tmp[12]; + size_t optlen, idlen, typelen; + if (!(soap->mode & SOAP_ENC_DIME)) + return soap->error = SOAP_DIME_END; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get DIME header\n")); + if (soap->dime.buflen || soap->dime.chunksize) + { if (soap_move(soap, (long)(soap->dime.size - soap_tell(soap)))) + return soap->error = SOAP_EOF; + soap_unget(soap, soap_getchar(soap)); /* skip padding and get hdr */ + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "... From chunked\n")); + return SOAP_OK; + } + s = (char*)tmp; + for (i = 12; i > 0; i--) + { if ((int)(c = soap_getchar(soap)) == EOF) + return soap->error = SOAP_EOF; + *s++ = (char)c; + } + if ((tmp[0] & 0xF8) != SOAP_DIME_VERSION) + return soap->error = SOAP_DIME_MISMATCH; + soap->dime.flags = (tmp[0] & 0x7) | (tmp[1] & 0xF0); + optlen = (tmp[2] << 8) | tmp[3]; + idlen = (tmp[4] << 8) | tmp[5]; + typelen = (tmp[6] << 8) | tmp[7]; + soap->dime.size = (tmp[8] << 24) | (tmp[9] << 16) | (tmp[10] << 8) | tmp[11]; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME size=%lu flags=0x%X\n", (unsigned long)soap->dime.size, soap->dime.flags)); + if (!(soap->dime.options = soap_getdimefield(soap, optlen)) && soap->error) + return soap->error; + if (!(soap->dime.id = soap_getdimefield(soap, idlen)) && soap->error) + return soap->error; + if (!(soap->dime.type = soap_getdimefield(soap, typelen)) && soap->error) + return soap->error; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DIME id=%s, type=%s, options=%s\n", soap->dime.id?soap->dime.id:"", soap->dime.type?soap->dime.type:"", soap->dime.options?soap->dime.options+4:"")); + if (soap->dime.flags & SOAP_DIME_ME) + soap->mode &= ~SOAP_ENC_DIME; + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getdime(struct soap *soap) +{ while (soap->dime.flags & SOAP_DIME_CF) + { if (soap_getdimehdr(soap)) + return soap->error; + if (soap_move(soap, soap->dime.size)) + return soap->error = SOAP_EOF; + } + if (soap_move(soap, ((soap->dime.size+3)&(~3))-soap_tell(soap))) + return soap->error = SOAP_EOF; + for (;;) + { register struct soap_multipart *content; + if (soap_getdimehdr(soap)) + break; + if (soap->fdimewriteopen && ((soap->dime.ptr = (char*)soap->fdimewriteopen(soap, soap->dime.id, soap->dime.type, soap->dime.options)) || soap->error)) + { const char *id, *type, *options; + size_t size, n; + if (!soap->dime.ptr) + return soap->error; + id = soap->dime.id; + type = soap->dime.type; + options = soap->dime.options; + for (;;) + { size = soap->dime.size; + for (;;) + { n = soap->buflen - soap->bufidx; + if (size < n) + n = size; + if ((soap->error = soap->fdimewrite(soap, (void*)soap->dime.ptr, soap->buf + soap->bufidx, n))) + break; + size -= n; + if (!size) + { soap->bufidx += n; + break; + } + if (soap_recv(soap)) + { soap->error = SOAP_EOF; + goto end; + } + } + if (soap_move(soap, -(long)soap->dime.size&3)) + { soap->error = SOAP_EOF; + break; + } + if (!(soap->dime.flags & SOAP_DIME_CF)) + break; + if (soap_getdimehdr(soap)) + break; + } +end: + if (soap->fdimewriteclose) + soap->fdimewriteclose(soap, (void*)soap->dime.ptr); + soap->dime.size = 0; + soap->dime.id = id; + soap->dime.type = type; + soap->dime.options = options; + } + else if (soap->dime.flags & SOAP_DIME_CF) + { const char *id, *type, *options; + register soap_wchar c; + register char *s; + register int i; + id = soap->dime.id; + type = soap->dime.type; + options = soap->dime.options; + if (soap_new_block(soap)) + return SOAP_EOM; + for (;;) + { s = (char*)soap_push_block(soap, soap->dime.size); + if (!s) + return soap->error = SOAP_EOM; + for (i = soap->dime.size; i > 0; i--) + { if ((int)(c = soap_get1(soap)) == EOF) + return soap->error = SOAP_EOF; + *s++ = (char)c; + } + if (soap_move(soap, -(long)soap->dime.size&3)) + return soap->error = SOAP_EOF; + if (!(soap->dime.flags & SOAP_DIME_CF)) + break; + if (soap_getdimehdr(soap)) + return soap->error; + } + soap->dime.size = soap->blist->size++; /* allocate one more for '\0' */ + if (!(soap->dime.ptr = soap_save_block(soap, NULL, 0))) + return soap->error; + soap->dime.ptr[soap->dime.size] = '\0'; /* force 0-terminated */ + soap->dime.id = id; + soap->dime.type = type; + soap->dime.options = options; + } + else + soap->dime.ptr = soap_getdimefield(soap, soap->dime.size); + content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, soap->dime.ptr, soap->dime.size); + if (!content) + return soap->error = SOAP_EOM; + content->id = soap->dime.id; + content->type = soap->dime.type; + content->options = soap->dime.options; + if (soap->error) + return soap->error; + soap_resolve_attachment(soap, content); + } + if (soap->error != SOAP_DIME_END) + return soap->error; + return soap->error = SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getmimehdr(struct soap *soap) +{ struct soap_multipart *content; + do + { if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf))) + return soap->error; + } + while (!*soap->msgbuf); + if (soap->msgbuf[0] == '-' && soap->msgbuf[1] == '-') + { char *s = soap->msgbuf + strlen(soap->msgbuf) - 1; + /* remove white space */ + while (soap_blank(*s)) + s--; + s[1] = '\0'; + if (soap->mime.boundary) + { if (strcmp(soap->msgbuf + 2, soap->mime.boundary)) + return soap->error = SOAP_MIME_ERROR; + } + else + soap->mime.boundary = soap_strdup(soap, soap->msgbuf + 2); + if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf))) + return soap->error; + } + if (soap_set_mime_attachment(soap, NULL, 0, SOAP_MIME_NONE, NULL, NULL, NULL, NULL)) + return soap->error = SOAP_EOM; + content = soap->mime.last; + for (;;) + { register char *key = soap->msgbuf; + register char *val; + if (!*key) + break; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "MIME header: %s\n", key)); + val = strchr(soap->msgbuf, ':'); + if (val) + { *val = '\0'; + do val++; + while (*val && *val <= 32); + if (!soap_tag_cmp(key, "Content-ID")) + content->id = soap_strdup(soap, val); + else if (!soap_tag_cmp(key, "Content-Location")) + content->location = soap_strdup(soap, val); + else if (!soap_tag_cmp(key, "Content-Disposition")) + content->id = soap_strdup(soap, soap_get_header_attribute(soap, val, "name")); + else if (!soap_tag_cmp(key, "Content-Type")) + content->type = soap_strdup(soap, val); + else if (!soap_tag_cmp(key, "Content-Description")) + content->description = soap_strdup(soap, val); + else if (!soap_tag_cmp(key, "Content-Transfer-Encoding")) + content->encoding = (enum soap_mime_encoding)soap_code_int(mime_codes, val, (long)SOAP_MIME_NONE); + } + if (soap_getline(soap, key, sizeof(soap->msgbuf))) + return soap->error; + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getmime(struct soap *soap) +{ while (soap_get_mime_attachment(soap, NULL)) + ; + return soap->error; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_post_check_mime_attachments(struct soap *soap) +{ soap->imode |= SOAP_MIME_POSTCHECK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_check_mime_attachments(struct soap *soap) +{ if (soap->mode & SOAP_MIME_POSTCHECK) + return soap_get_mime_attachment(soap, NULL) != NULL; + return 0; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +struct soap_multipart * +SOAP_FMAC2 +soap_get_mime_attachment(struct soap *soap, void *handle) +{ register soap_wchar c = 0; + register size_t i, m = 0; + register char *s, *t = NULL; + register struct soap_multipart *content; + register short flag = 0; + if (!(soap->mode & SOAP_ENC_MIME)) + return NULL; + content = soap->mime.last; + if (!content) + { if (soap_getmimehdr(soap)) + return NULL; + content = soap->mime.last; + } + else if (content != soap->mime.first) + { if (soap->fmimewriteopen && ((content->ptr = (char*)soap->fmimewriteopen(soap, (void*)handle, content->id, content->type, content->description, content->encoding)) || soap->error)) + { if (!content->ptr) + return NULL; + } + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Parsing MIME content id=%s type=%s\n", content->id?content->id:"", content->type?content->type:"")); + if (!content->ptr && soap_new_block(soap)) + { soap->error = SOAP_EOM; + return NULL; + } + for (;;) + { if (content->ptr) + s = soap->tmpbuf; + else if (!(s = (char*)soap_push_block(soap, sizeof(soap->tmpbuf)))) + { soap->error = SOAP_EOM; + return NULL; + } + for (i = 0; i < sizeof(soap->tmpbuf); i++) + { if (m > 0) + { *s++ = *t++; + m--; + } + else + { if (!flag) + { c = soap_get1(soap); + if ((int)c == EOF) + { soap->error = SOAP_EOF; + return NULL; + } + } + if (flag || c == '\r') + { t = soap->msgbuf; + memset(t, 0, sizeof(soap->msgbuf)); + strcpy(t, "\n--"); + if (soap->mime.boundary) + strncat(t, soap->mime.boundary, sizeof(soap->msgbuf)-4); + do c = soap_getchar(soap); + while (c == *t++); + if ((int)c == EOF) + { soap->error = SOAP_EOF; + return NULL; + } + if (!*--t) + goto end; + *t = (char)c; + flag = (c == '\r'); + m = t - soap->msgbuf + 1 - flag; + t = soap->msgbuf; + c = '\r'; + } + *s++ = (char)c; + } + } + if (content->ptr && soap->fmimewrite) + { if ((soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i))) + break; + } + } +end: + *s = '\0'; /* force 0-terminated */ + if (content->ptr) + { if (!soap->error && soap->fmimewrite) + soap->error = soap->fmimewrite(soap, (void*)content->ptr, soap->tmpbuf, i); + if (soap->fmimewriteclose) + soap->fmimewriteclose(soap, (void*)content->ptr); + if (soap->error) + return NULL; + } + else + { content->size = soap_size_block(soap, i+1)-1; + content->ptr = soap_save_block(soap, NULL, 0); + } + soap_resolve_attachment(soap, content); + if (c == '-' && soap_getchar(soap) == '-') + { soap->mode &= ~SOAP_ENC_MIME; + if ((soap->mode & SOAP_MIME_POSTCHECK) && soap_end_recv(soap)) + return NULL; + } + else + { while (c != '\r' && (int)c != EOF && soap_blank(c)) + c = soap_getchar(soap); + if (c != '\r' || soap_getchar(soap) != '\n') + { soap->error = SOAP_MIME_ERROR; + return NULL; + } + if (soap_getmimehdr(soap)) + return NULL; + } + return content; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_match_cid(struct soap *soap, const char *s, const char *t) +{ register size_t n; + if (!s) + return 1; + if (!strcmp(s, t)) + return 0; + if (!strncmp(s, "cid:", 4)) + s += 4; + n = strlen(t); + if (*t == '<') + { t++; + n -= 2; + } + if (!strncmp(s, t, n) && !s[n]) + return 0; + soap_decode(soap->tmpbuf, sizeof(soap->tmpbuf), s, SOAP_STR_EOS); + if (!strncmp(soap->tmpbuf, t, n) && !soap->tmpbuf[n]) + return 0; + return 1; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +static void +soap_resolve_attachment(struct soap *soap, struct soap_multipart *content) +{ if (content->id) + { register struct soap_xlist **xp = &soap->xlist; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Resolving attachment data for id=%s\n", content->id)); + while (*xp) + { register struct soap_xlist *xq = *xp; + if (!soap_match_cid(soap, xq->id, content->id)) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Found matching attachment %s for content id=%s\n", xq->id, content->id)); + *xp = xq->next; + *xq->ptr = (unsigned char*)content->ptr; + *xq->size = (int)content->size; + *xq->type = (char*)content->type; + if (content->options) + *xq->options = (char*)content->options; + else + *xq->options = (char*)content->description; + SOAP_FREE(soap, xq); + } + else + xp = &(*xp)->next; + } + } +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_putmimehdr(struct soap *soap, struct soap_multipart *content) +{ const char *s; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "MIME attachment type=%s\n", content->type?content->type:"")); + if (soap_send3(soap, "\r\n--", soap->mime.boundary, "\r\n")) + return soap->error; + if (content->type && soap_send3(soap, "Content-Type: ", content->type, "\r\n")) + return soap->error; + s = soap_code_str(mime_codes, content->encoding); + if (s && soap_send3(soap, "Content-Transfer-Encoding: ", s, "\r\n")) + return soap->error; + if (content->id && soap_send3(soap, "Content-ID: ", content->id, "\r\n")) + return soap->error; + if (content->location && soap_send3(soap, "Content-Location: ", content->location, "\r\n")) + return soap->error; + if (content->description && soap_send3(soap, "Content-Description: ", content->description, "\r\n")) + return soap->error; + return soap_send_raw(soap, "\r\n", 2); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_putmime(struct soap *soap) +{ struct soap_multipart *content; + if (!(soap->mode & SOAP_ENC_MIME) || !soap->mime.boundary) + return SOAP_OK; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending MIME attachments\n")); + for (content = soap->mime.first; content; content = content->next) + { void *handle; + if (soap->fmimereadopen && ((handle = soap->fmimereadopen(soap, (void*)content->ptr, content->id, content->type, content->description)) || soap->error)) + { size_t size = content->size; + if (!handle) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimereadopen failed\n")); + return soap->error; + } + if (soap_putmimehdr(soap, content)) + return soap->error; + if (!size) + { if ((soap->mode & SOAP_ENC_XML) || (soap->mode & SOAP_IO) == SOAP_IO_CHUNK || (soap->mode & SOAP_IO) == SOAP_IO_STORE) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked streaming MIME\n")); + do + { size = soap->fmimeread(soap, handle, soap->tmpbuf, sizeof(soap->tmpbuf)); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread returned %lu bytes\n", (unsigned long)size)); + if (soap_send_raw(soap, soap->tmpbuf, size)) + break; + } while (size); + } + else + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error: cannot chunk streaming MIME (no HTTP chunking)\n")); + } + } + else + { do + { size_t bufsize; + if (size < sizeof(soap->tmpbuf)) + bufsize = size; + else + bufsize = sizeof(soap->tmpbuf); + if (!(bufsize = soap->fmimeread(soap, handle, soap->tmpbuf, bufsize))) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "fmimeread failed: insufficient data (%lu bytes remaining from %lu bytes)\n", (unsigned long)size, (unsigned long)content->size)); + soap->error = SOAP_EOF; + break; + } + if (soap_send_raw(soap, soap->tmpbuf, bufsize)) + break; + size -= bufsize; + } while (size); + } + if (soap->fmimereadclose) + soap->fmimereadclose(soap, handle); + } + else + { if (soap_putmimehdr(soap, content) + || soap_send_raw(soap, content->ptr, content->size)) + return soap->error; + } + } + return soap_send3(soap, "\r\n--", soap->mime.boundary, "--"); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_set_dime(struct soap *soap) +{ soap->omode |= SOAP_ENC_DIME; + soap->dime.first = NULL; + soap->dime.last = NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_set_mime(struct soap *soap, const char *boundary, const char *start) +{ soap->omode |= SOAP_ENC_MIME; + soap->mime.first = NULL; + soap->mime.last = NULL; + soap->mime.boundary = soap_strdup(soap, boundary); + soap->mime.start = soap_strdup(soap, start); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_clr_dime(struct soap *soap) +{ soap->omode &= ~SOAP_ENC_DIME; + soap->dime.first = NULL; + soap->dime.last = NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_clr_mime(struct soap *soap) +{ soap->omode &= ~SOAP_ENC_MIME; + soap->mime.first = NULL; + soap->mime.last = NULL; + soap->mime.boundary = NULL; + soap->mime.start = NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +static struct soap_multipart* +soap_new_multipart(struct soap *soap, struct soap_multipart **first, struct soap_multipart **last, char *ptr, size_t size) +{ struct soap_multipart *content; + content = (struct soap_multipart*)soap_malloc(soap, sizeof(struct soap_multipart)); + if (content) + { content->next = NULL; + content->ptr = ptr; + content->size = size; + content->id = NULL; + content->type = NULL; + content->options = NULL; + content->encoding = SOAP_MIME_NONE; + content->location = NULL; + content->description = NULL; + if (!*first) + *first = content; + if (*last) + (*last)->next = content; + *last = content; + } + return content; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_set_dime_attachment(struct soap *soap, char *ptr, size_t size, const char *type, const char *id, unsigned short optype, const char *option) +{ struct soap_multipart *content = soap_new_multipart(soap, &soap->dime.first, &soap->dime.last, ptr, size); + if (!content) + return SOAP_EOM; + content->id = soap_strdup(soap, id); + content->type = soap_strdup(soap, type); + content->options = soap_dime_option(soap, optype, option); + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_set_mime_attachment(struct soap *soap, char *ptr, size_t size, enum soap_mime_encoding encoding, const char *type, const char *id, const char *location, const char *description) +{ struct soap_multipart *content = soap_new_multipart(soap, &soap->mime.first, &soap->mime.last, ptr, size); + if (!content) + return SOAP_EOM; + content->id = soap_strdup(soap, id); + content->type = soap_strdup(soap, type); + content->encoding = encoding; + content->location = soap_strdup(soap, location); + content->description = soap_strdup(soap, description); + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +SOAP_FMAC1 +struct soap_multipart* +SOAP_FMAC2 +soap_next_multipart(struct soap_multipart *content) +{ if (content) + return content->next; + return NULL; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +static void +soap_select_mime_boundary(struct soap *soap) +{ while (!soap->mime.boundary || soap_valid_mime_boundary(soap)) + { register char *s = soap->mime.boundary; + register size_t n = 0; + if (s) + n = strlen(s); + if (n < 16) + { n = 64; + s = soap->mime.boundary = (char*)soap_malloc(soap, n + 1); + if (!s) + return; + } + strcpy(s, "=="); + s += 2; + n -= 4; + while (n) + { *s++ = soap_base64o[soap_random & 0x3F]; + n--; + } + strcpy(s, "=="); + } + if (!soap->mime.start) + soap->mime.start = ""; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_LEANER +#ifndef PALM_1 +static int +soap_valid_mime_boundary(struct soap *soap) +{ register struct soap_multipart *content; + register size_t k; + if (soap->fmimeread) + return SOAP_OK; + k = strlen(soap->mime.boundary); + for (content = soap->mime.first; content; content = content->next) + { if (content->ptr && content->size >= k) + { register const char *p = (const char*)content->ptr; + register size_t i; + for (i = 0; i < content->size - k; i++, p++) + { if (!strncmp(p, soap->mime.boundary, k)) + return SOAP_ERR; + } + } + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************\ + * + * HTTP cookie handling + * +\******************************************************************************/ + +#ifdef WITH_COOKIES +/******************************************************************************/ +SOAP_FMAC1 +size_t +SOAP_FMAC2 +soap_encode_cookie(const char *s, char *t, size_t len) +{ register int c; + register size_t n = len; + while ((c = *s++) && --n > 0) + { if (c > ' ' && c < 128 && !strchr("()<>@,;:\\\"/[]?={}", c)) + *t++ = c; + else if (n > 2) + { *t++ = '%'; + *t++ = (c >> 4) + (c > 159 ? '7' : '0'); + c &= 0xF; + *t++ = c + (c > 9 ? '7' : '0'); + n -= 2; + } + else + break; + } + *t = '\0'; + return len - n; +} + +/******************************************************************************/ +SOAP_FMAC1 +struct soap_cookie* +SOAP_FMAC2 +soap_cookie(struct soap *soap, const char *name, const char *domain, const char *path) +{ struct soap_cookie *p; + size_t n; + if (!domain) + domain = soap->cookie_domain; + if (!path) + path = soap->cookie_path; + if (*path == '/') + path++; + n = strlen(path); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Search cookie %s domain=%s path=%s\n", name, domain?domain:"(null)", path?path:"(null)")); + for (p = soap->cookies; p; p = p->next) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie in database: %s=%s domain=%s path=%s env=%hd\n", p->name, p->value?p->value:"(null)", p->domain?p->domain:"(null)", p->path?p->path:"(null)", p->env)); + if (!strcmp(p->name, name) + && p->domain + && p->path + && !strcmp(p->domain, domain) + && !strncmp(p->path, path, n)) + break; + } + return p; +} + +/******************************************************************************/ +SOAP_FMAC1 +struct soap_cookie* +SOAP_FMAC2 +soap_set_cookie(struct soap *soap, const char *name, const char *value, const char *domain, const char *path) +{ struct soap_cookie **p, *q; + int n; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set cookie: %s=%s domain=%s path=%s\n", name, value?value:"(null)", domain?domain:"(null)", path?path:"(null)")); + if (!domain) + domain = soap->cookie_domain; + if (!path) + path = soap->cookie_path; + if (!path) + { soap_set_receiver_error(soap, "Cookie path not set", NULL, SOAP_HTTP_ERROR); + return NULL; + } + if (*path == '/') + path++; + q = soap_cookie(soap, name, domain, path); + if (!q) + { if ((q = (struct soap_cookie*)SOAP_MALLOC(soap, sizeof(struct soap_cookie)))) + { if ((q->name = (char*)SOAP_MALLOC(soap, strlen(name)+1))) + strcpy(q->name, name); + q->value = NULL; + q->domain = NULL; + q->path = NULL; + q->expire = -1; + q->maxage = -1; + q->version = 0; + q->secure = 0; + q->modified = 0; + for (p = &soap->cookies, n = soap->cookie_max; *p && n; p = &(*p)->next, n--) + if (!strcmp((*p)->name, name) && (*p)->path && strcmp((*p)->path, path) < 0) + break; + if (n) + { q->next = *p; + *p = q; + } + else + { SOAP_FREE(soap, q->name); + SOAP_FREE(soap, q); + q = NULL; + } + } + } + else + q->modified = 1; + if (q) + { if (q->value) + { SOAP_FREE(soap, q->value); + q->value = NULL; + } + if (q->domain) + { SOAP_FREE(soap, q->domain); + q->domain = NULL; + } + if (q->path) + { SOAP_FREE(soap, q->path); + q->path = NULL; + } + if (value && *value && (q->value = (char*)SOAP_MALLOC(soap, strlen(value)+1))) + strcpy(q->value, value); + if (domain && (q->domain = (char*)SOAP_MALLOC(soap, strlen(domain)+1))) + strcpy(q->domain, domain); + if (path && (q->path = (char*)SOAP_MALLOC(soap, strlen(path)+1))) + strcpy(q->path, path); + q->session = 1; + q->env = 0; + } + return q; +} + +/******************************************************************************/ +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_clr_cookie(struct soap *soap, const char *name, const char *domain, const char *path) +{ struct soap_cookie **p, *q; + if (!domain) + domain = soap->cookie_domain; + if (!domain) + { soap_set_receiver_error(soap, "Cookie domain not set", NULL, SOAP_HTTP_ERROR); + return; + } + if (!path) + path = soap->cookie_path; + if (!path) + { soap_set_receiver_error(soap, "Cookie path not set", NULL, SOAP_HTTP_ERROR); + return; + } + if (*path == '/') + path++; + for (p = &soap->cookies, q = *p; q; q = *p) + if (!strcmp(q->name, name) && !strcmp(q->domain, domain) && !strncmp(q->path, path, strlen(q->path))) + { if (q->value) + SOAP_FREE(soap, q->value); + if (q->domain) + SOAP_FREE(soap, q->domain); + if (q->path) + SOAP_FREE(soap, q->path); + *p = q->next; + SOAP_FREE(soap, q); + } + else + p = &q->next; +} + +/******************************************************************************/ +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_cookie_value(struct soap *soap, const char *name, const char *domain, const char *path) +{ struct soap_cookie *p; + if ((p = soap_cookie(soap, name, domain, path))) + return p->value; + return NULL; +} + +/******************************************************************************/ +SOAP_FMAC1 +char * +SOAP_FMAC2 +soap_env_cookie_value(struct soap *soap, const char *name, const char *domain, const char *path) +{ struct soap_cookie *p; + if ((p = soap_cookie(soap, name, domain, path)) && p->env) + return p->value; + return NULL; +} + +/******************************************************************************/ +SOAP_FMAC1 +time_t +SOAP_FMAC2 +soap_cookie_expire(struct soap *soap, const char *name, const char *domain, const char *path) +{ struct soap_cookie *p; + if ((p = soap_cookie(soap, name, domain, path))) + return p->expire; + return -1; +} + +/******************************************************************************/ +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_set_cookie_expire(struct soap *soap, const char *name, long expire, const char *domain, const char *path) +{ struct soap_cookie *p; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set cookie expiration max-age %ld: %s domain=%s path=%s\n", expire, name, domain?domain:"(null)", path?path:"(null)")); + if ((p = soap_cookie(soap, name, domain, path))) + { p->maxage = expire; + p->modified = 1; + return SOAP_OK; + } + return SOAP_ERR; +} + +/******************************************************************************/ +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_set_cookie_session(struct soap *soap, const char *name, const char *domain, const char *path) +{ struct soap_cookie *p; + if ((p = soap_cookie(soap, name, domain, path))) + { p->session = 1; + p->modified = 1; + return SOAP_OK; + } + return SOAP_ERR; +} + +/******************************************************************************/ +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_clr_cookie_session(struct soap *soap, const char *name, const char *domain, const char *path) +{ struct soap_cookie *p; + if ((p = soap_cookie(soap, name, domain, path))) + { p->session = 0; + p->modified = 1; + return SOAP_OK; + } + return SOAP_ERR; +} + +/******************************************************************************/ +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_putsetcookies(struct soap *soap) +{ struct soap_cookie *p; + char *s, tmp[4096]; + const char *t; + for (p = soap->cookies; p; p = p->next) + { if (p->modified || !p->env) + { s = tmp; + if (p->name) + s += soap_encode_cookie(p->name, s, tmp-s+4064); + if (p->value && *p->value) + { *s++ = '='; + s += soap_encode_cookie(p->value, s, tmp-s+4064); + } + if (p->domain && (int)strlen(p->domain) < tmp-s+4064) + sprintf(s, ";Domain=\"%s\"", p->domain); + else if (soap->cookie_domain && (int)strlen(soap->cookie_domain) < tmp-s+4064) + sprintf(s, ";Domain=\"%s\"", soap->cookie_domain); + strcat(s, ";Path=/"); + if (p->path) + t = p->path; + else + t = soap->cookie_path; + if (t) + { if (*t == '/') + t++; + if ((int)strlen(t) < tmp-s+4064) + strcat(s, t); + } + s += strlen(s); + if (p->version > 0 && s-tmp < 4060) + { sprintf(s, ";Version=%u", p->version); + s += strlen(s); + } + if (p->maxage >= 0 && s-tmp < 4060) + { sprintf(s, ";Max-Age=%ld", p->maxage); + s += strlen(s); + } + if (p->secure && s-tmp < 4073) + strcpy(s, ";Secure"); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Set-Cookie: %s\n", tmp)); + if ((soap->error = soap->fposthdr(soap, "Set-Cookie", tmp))) + return soap->error; + } + } + return SOAP_OK; +} + +/******************************************************************************/ +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_putcookies(struct soap *soap, const char *domain, const char *path, int secure) +{ struct soap_cookie **p, *q; + unsigned int version = 0; + time_t now = time(NULL); + char *s, tmp[4096]; + p = &soap->cookies; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Sending cookies for domain=%s path=%s\n", domain, path)); + if (*path == '/') + path++; + while ((q = *p)) + { if (q->expire && now > q->expire) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie %s expired\n", q->name)); + SOAP_FREE(soap, q->name); + if (q->value) + SOAP_FREE(soap, q->value); + if (q->domain) + SOAP_FREE(soap, q->domain); + if (q->path) + SOAP_FREE(soap, q->path); + *p = q->next; + SOAP_FREE(soap, q); + } + else + { size_t domlen = 0; + if (q->domain) + { const char *s = strchr(q->domain, ':'); + if (s) + domlen = s - q->domain; + else + domlen = strlen(q->domain); + } + if ((!q->domain || !strncmp(q->domain, domain, domlen)) + && (!q->path || !strncmp(q->path, path, strlen(q->path))) + && (!q->secure || secure)) + { s = tmp; + if (q->version != version) + { sprintf(s, "$Version=%u;", q->version); + version = q->version; + } + if (q->name) + s += soap_encode_cookie(q->name, s, tmp-s+4080); + if (q->value && *q->value) + { *s++ = '='; + s += soap_encode_cookie(q->value, s, tmp-s+4080); + } + if (q->path && (int)strlen(q->path) < tmp-s+4080) + { sprintf(s, ";$Path=\"/%s\"", (*q->path == '/' ? q->path + 1 : q->path)); + s += strlen(s); + } + if (q->domain && (int)strlen(q->domain) < tmp-s+4080) + sprintf(s, ";$Domain=\"%s\"", q->domain); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Cookie: %s\n", tmp)); + if ((soap->error = soap->fposthdr(soap, "Cookie", tmp))) + return soap->error; + } + p = &q->next; + } + } + return SOAP_OK; +} + +/******************************************************************************/ +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_getcookies(struct soap *soap, const char *val) +{ struct soap_cookie *p = NULL, *q; + const char *s; + char *t, tmp[4096]; /* cookie size is up to 4096 bytes [RFC2109] */ + char *domain = NULL; + char *path = NULL; + unsigned int version = 0; + time_t now = time(NULL); + if (!val) + return; + s = val; + while (*s) + { s = soap_decode_key(tmp, sizeof(tmp), s); + if (!soap_tag_cmp(tmp, "$Version")) + { if ((s = soap_decode_val(tmp, sizeof(tmp), s))) + { if (p) + p->version = (int)atol(tmp); + else + version = (int)atol(tmp); + } + } + else if (!soap_tag_cmp(tmp, "$Path")) + { s = soap_decode_val(tmp, sizeof(tmp), s); + if (*tmp) + { if ((t = (char*)SOAP_MALLOC(soap, strlen(tmp)+1))) + strcpy(t, tmp); + } + else + t = NULL; + if (p) + { if (p->path) + SOAP_FREE(soap, p->path); + p->path = t; + } + else + { if (path) + SOAP_FREE(soap, path); + path = t; + } + } + else if (!soap_tag_cmp(tmp, "$Domain")) + { s = soap_decode_val(tmp, sizeof(tmp), s); + if (*tmp) + { if ((t = (char*)SOAP_MALLOC(soap, strlen(tmp)+1))) + strcpy(t, tmp); + } + else + t = NULL; + if (p) + { if (p->domain) + SOAP_FREE(soap, p->domain); + p->domain = t; + } + else + { if (domain) + SOAP_FREE(soap, domain); + domain = t; + } + } + else if (p && !soap_tag_cmp(tmp, "Path")) + { if (p->path) + SOAP_FREE(soap, p->path); + s = soap_decode_val(tmp, sizeof(tmp), s); + if (*tmp) + { if ((p->path = (char*)SOAP_MALLOC(soap, strlen(tmp)+1))) + strcpy(p->path, tmp); + } + else + p->path = NULL; + } + else if (p && !soap_tag_cmp(tmp, "Domain")) + { if (p->domain) + SOAP_FREE(soap, p->domain); + s = soap_decode_val(tmp, sizeof(tmp), s); + if (*tmp) + { if ((p->domain = (char*)SOAP_MALLOC(soap, strlen(tmp)+1))) + strcpy(p->domain, tmp); + } + else + p->domain = NULL; + } + else if (p && !soap_tag_cmp(tmp, "Version")) + { s = soap_decode_val(tmp, sizeof(tmp), s); + p->version = (unsigned int)atol(tmp); + } + else if (p && !soap_tag_cmp(tmp, "Max-Age")) + { s = soap_decode_val(tmp, sizeof(tmp), s); + p->expire = now + atol(tmp); + } + else if (p && !soap_tag_cmp(tmp, "Expires")) + { struct tm T; + char a[3]; + static const char mns[] = "anebarprayunulugepctovec"; + s = soap_decode_val(tmp, sizeof(tmp), s); + if (strlen(tmp) > 20) + { memset((void*)&T, 0, sizeof(T)); + a[0] = tmp[4]; + a[1] = tmp[5]; + a[2] = '\0'; + T.tm_mday = (int)atol(a); + a[0] = tmp[8]; + a[1] = tmp[9]; + T.tm_mon = (strstr(mns, a) - mns) / 2; + a[0] = tmp[11]; + a[1] = tmp[12]; + T.tm_year = 100 + (int)atol(a); + a[0] = tmp[13]; + a[1] = tmp[14]; + T.tm_hour = (int)atol(a); + a[0] = tmp[16]; + a[1] = tmp[17]; + T.tm_min = (int)atol(a); + a[0] = tmp[19]; + a[1] = tmp[20]; + T.tm_sec = (int)atol(a); + p->expire = soap_timegm(&T); + } + } + else if (p && !soap_tag_cmp(tmp, "Secure")) + p->secure = 1; + else + { if (p) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Got environment cookie %s=%s domain=%s path=%s expire=%ld secure=%d\n", p->name, p->value?p->value:"(null)", p->domain?p->domain:"(null)", p->path?p->path:"(null)", p->expire, p->secure)); + if ((q = soap_set_cookie(soap, p->name, p->value, p->domain, p->path))) + { q->version = p->version; + q->expire = p->expire; + q->secure = p->secure; + q->env = 1; + } + if (p->name) + SOAP_FREE(soap, p->name); + if (p->value) + SOAP_FREE(soap, p->value); + if (p->domain) + SOAP_FREE(soap, p->domain); + if (p->path) + SOAP_FREE(soap, p->path); + SOAP_FREE(soap, p); + } + if ((p = (struct soap_cookie*)SOAP_MALLOC(soap, sizeof(struct soap_cookie)))) + { p->name = (char*)SOAP_MALLOC(soap, strlen(tmp)+1); + strcpy(p->name, tmp); + s = soap_decode_val(tmp, sizeof(tmp), s); + if (*tmp) + { p->value = (char*)SOAP_MALLOC(soap, strlen(tmp)+1); + strcpy(p->value, tmp); + } + else + p->value = NULL; + p->domain = domain; + p->path = path; + p->expire = 0; + p->secure = 0; + p->version = version; + } + } + } + if (p) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Got environment cookie %s=%s domain=%s path=%s expire=%ld secure=%d\n", p->name, p->value?p->value:"(null)", p->domain?p->domain:"(null)", p->path?p->path:"(null)", p->expire, p->secure)); + if ((q = soap_set_cookie(soap, p->name, p->value, p->domain, p->path))) + { q->version = p->version; + q->expire = p->expire; + q->secure = p->secure; + q->env = 1; + } + if (p->name) + SOAP_FREE(soap, p->name); + if (p->value) + SOAP_FREE(soap, p->value); + if (p->domain) + SOAP_FREE(soap, p->domain); + if (p->path) + SOAP_FREE(soap, p->path); + SOAP_FREE(soap, p); + } + if (domain) + SOAP_FREE(soap, domain); + if (path) + SOAP_FREE(soap, path); +} + +/******************************************************************************/ +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_getenv_cookies(struct soap *soap) +{ struct soap_cookie *p; + const char *s; + char key[4096], val[4096]; /* cookie size is up to 4096 bytes [RFC2109] */ + if (!(s = getenv("HTTP_COOKIE"))) + return SOAP_ERR; + do + { s = soap_decode_key(key, sizeof(key), s); + s = soap_decode_val(val, sizeof(val), s); + p = soap_set_cookie(soap, key, val, NULL, NULL); + if (p) + p->env = 1; + } while (*s); + return SOAP_OK; +} + +/******************************************************************************/ +SOAP_FMAC1 +struct soap_cookie* +SOAP_FMAC2 +soap_copy_cookies(struct soap *copy, struct soap *soap) +{ struct soap_cookie *p, **q, *r; + q = &r; + for (p = soap->cookies; p; p = p->next) + { if (!(*q = (struct soap_cookie*)SOAP_MALLOC(copy, sizeof(struct soap_cookie)))) + return r; + **q = *p; + if (p->name) + { if (((*q)->name = (char*)SOAP_MALLOC(copy, strlen(p->name)+1))) + strcpy((*q)->name, p->name); + } + if (p->value) + { if (((*q)->value = (char*)SOAP_MALLOC(copy, strlen(p->value)+1))) + strcpy((*q)->value, p->value); + } + if (p->domain) + { if (((*q)->domain = (char*)SOAP_MALLOC(copy, strlen(p->domain)+1))) + strcpy((*q)->domain, p->domain); + } + if (p->path) + { if (((*q)->path = (char*)SOAP_MALLOC(copy, strlen(p->path)+1))) + strcpy((*q)->path, p->path); + } + q = &(*q)->next; + } + *q = NULL; + return r; +} + +/******************************************************************************/ +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_free_cookies(struct soap *soap) +{ struct soap_cookie *p; + for (p = soap->cookies; p; p = soap->cookies) + { soap->cookies = p->next; + SOAP_FREE(soap, p->name); + if (p->value) + SOAP_FREE(soap, p->value); + if (p->domain) + SOAP_FREE(soap, p->domain); + if (p->path) + SOAP_FREE(soap, p->path); + SOAP_FREE(soap, p); + } +} + +/******************************************************************************/ +#endif /* WITH_COOKIES */ + +/******************************************************************************/ +#ifdef WITH_GZIP +#ifndef PALM_1 +static int +soap_getgziphdr(struct soap *soap) +{ int i; + soap_wchar c, f = 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Get gzip header\n")); + for (i = 0; i < 9; i++) + { if ((int)(c = soap_get1(soap) == EOF)) + return soap->error = SOAP_EOF; + if (i == 2) + f = c; + } + if (f & 0x04) /* FEXTRA */ + { for (i = soap_get1(soap) | (soap_get1(soap) << 8); i; i--) + { if ((int)soap_get1(soap) == EOF) + return soap->error = SOAP_EOF; + } + } + if (f & 0x08) /* FNAME */ + { do + c = soap_get1(soap); + while (c && (int)c != EOF); + } + if ((int)c != EOF && (f & 0x10)) /* FCOMMENT */ + { do + c = soap_get1(soap); + while (c && (int)c != EOF); + } + if ((int)c != EOF && (f & 0x01)) /* FHCRC */ + { if ((int)(c = soap_get1(soap)) != EOF) + c = soap_get1(soap); + } + if ((int)c == EOF) + return soap->error = SOAP_EOF; + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_begin_recv(struct soap *soap) +{ soap_wchar c; + soap->error = SOAP_OK; + soap_free(soap); + soap_set_local_namespaces(soap); + soap->version = 0; /* don't assume we're parsing SOAP content by default */ +#ifndef WITH_NOIDREF + soap_free_iht(soap); +#endif + if ((soap->imode & SOAP_IO) == SOAP_IO_CHUNK) + soap->omode |= SOAP_IO_CHUNK; + soap->imode &= ~SOAP_IO; + soap->mode = soap->imode; + if (!soap->keep_alive) + { soap->buflen = 0; + soap->bufidx = 0; + } + if (!(soap->mode & SOAP_IO_KEEPALIVE)) + soap->keep_alive = 0; + soap->ahead = 0; + soap->peeked = 0; + soap->level = 0; + soap->part = SOAP_BEGIN; + soap->alloced = 0; + soap->count = 0; + soap->length = 0; + soap->cdata = 0; + *soap->endpoint = '\0'; + soap->action = NULL; +#ifndef WITH_LEANER + soap->dom = NULL; + soap->dime.chunksize = 0; + soap->dime.buflen = 0; + soap->dime.list = NULL; + soap->dime.first = NULL; + soap->dime.last = NULL; + soap->mime.list = NULL; + soap->mime.first = NULL; + soap->mime.last = NULL; + soap->mime.boundary = NULL; + soap->mime.start = NULL; + soap->xlist = NULL; +#endif +#ifdef WIN32 +#ifndef UNDER_CE +#ifndef WITH_FASTCGI + if (!soap_valid_socket(soap->socket)) +#ifdef __BORLANDC__ + setmode((SOAP_SOCKET)soap->recvfd, O_BINARY); +#else + _setmode((SOAP_SOCKET)soap->recvfd, _O_BINARY); +#endif +#endif +#endif +#endif +#ifdef WITH_ZLIB + soap->mode &= ~SOAP_ENC_ZLIB; + soap->zlib_in = SOAP_ZLIB_NONE; + soap->zlib_out = SOAP_ZLIB_NONE; + soap->d_stream.next_in = Z_NULL; + soap->d_stream.avail_in = 0; + soap->d_stream.next_out = (Byte*)soap->buf; + soap->d_stream.avail_out = SOAP_BUFLEN; + soap->z_ratio_in = 1.0; +#endif +#ifndef WITH_LEANER + if (soap->fprepareinit) + soap->fprepareinit(soap); +#endif + c = soap_getchar(soap); +#ifdef WITH_GZIP + if (c == 0x1F) + { if (soap_getgziphdr(soap)) + return soap->error; + if (inflateInit2(&soap->d_stream, -MAX_WBITS) != Z_OK) + return soap->error = SOAP_ZLIB_ERROR; + soap->zlib_state = SOAP_ZLIB_INFLATE; + soap->mode |= SOAP_ENC_ZLIB; + soap->zlib_in = SOAP_ZLIB_GZIP; + soap->z_crc = crc32(0L, NULL, 0); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n")); + memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN); + /* should not chunk over plain transport, so why bother to check? */ + /* if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) */ + /* soap->z_buflen = soap->bufidx; */ + /* else */ + soap->d_stream.next_in = (Byte*)(soap->z_buf + soap->bufidx); + soap->d_stream.avail_in = soap->buflen - soap->bufidx; + soap->z_buflen = soap->buflen; + soap->buflen = soap->bufidx; + c = soap_getchar(soap); + } +#endif +#ifndef WITH_LEANER + if (c == '-' && soap_get0(soap) == '-') + soap->mode |= SOAP_ENC_MIME; + else if ((c & 0xFFFC) == (SOAP_DIME_VERSION | SOAP_DIME_MB) && (soap_get0(soap) & 0xFFF0) == 0x20) + soap->mode |= SOAP_ENC_DIME; + else +#endif + { while (soap_blank(c)) + c = soap_getchar(soap); + } + if ((int)c == EOF) + return soap->error = SOAP_EOF; + soap_unget(soap, c); +#ifndef WITH_NOHTTP + /* if not XML or (start of)BOM or MIME/DIME/ZLIB, assume HTTP header */ + if (c != '<' && c != 0xEF && !(soap->mode & (SOAP_ENC_MIME | SOAP_ENC_DIME | SOAP_ENC_ZLIB))) + { soap->mode &= ~SOAP_IO; + soap->error = soap->fparse(soap); + if (soap->error && soap->error < SOAP_STOP) + { soap->keep_alive = 0; /* force close later */ + return soap->error; + } + if ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK) + { soap->chunkbuflen = soap->buflen; + soap->buflen = soap->bufidx; + soap->chunksize = 0; + } +#ifndef WITH_LEANER + else if (soap->fpreparerecv && soap->buflen != soap->bufidx) + soap->fpreparerecv(soap, soap->buf + soap->bufidx, soap->buflen - soap->bufidx); +#endif +#ifdef WITH_ZLIB + if (soap->zlib_in != SOAP_ZLIB_NONE) + { /* fparse should not use soap_unget to push back last char */ +#ifdef WITH_GZIP + c = soap_get1(soap); + if (c == 0x1F) + { if (soap_getgziphdr(soap)) + return soap->error; + if (inflateInit2(&soap->d_stream, -MAX_WBITS) != Z_OK) + return soap->error = SOAP_ZLIB_ERROR; + soap->zlib_state = SOAP_ZLIB_INFLATE; + soap->z_crc = crc32(0L, NULL, 0); + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "gzip initialized\n")); + } + else + { soap_revget1(soap); +#else + { +#endif + if (inflateInit(&soap->d_stream) != Z_OK) + return soap->error = SOAP_ZLIB_ERROR; + soap->zlib_state = SOAP_ZLIB_INFLATE; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Inflate initialized\n")); + } + soap->mode |= SOAP_ENC_ZLIB; + memcpy(soap->z_buf, soap->buf, SOAP_BUFLEN); + soap->d_stream.next_in = (Byte*)(soap->z_buf + soap->bufidx); + soap->d_stream.avail_in = soap->buflen - soap->bufidx; + soap->z_buflen = soap->buflen; + soap->buflen = soap->bufidx; + } +#endif + if (soap->error) + { if (soap->error == SOAP_FORM && soap->fform) + { soap->error = soap->fform(soap); + if (soap->error == SOAP_OK) + soap->error = SOAP_STOP; /* prevents further processing */ + } + return soap->error; + } + } +#endif +#ifndef WITH_LEANER + if (soap->mode & SOAP_ENC_MIME) + { if (soap_getmimehdr(soap)) + return soap->error; + if (soap_get_header_attribute(soap, soap->mime.first->type, "application/dime")) + soap->mode |= SOAP_ENC_DIME; + } + if (soap->mode & SOAP_ENC_DIME) + { if (soap_getdimehdr(soap)) + return soap->error; + if (soap->dime.flags & SOAP_DIME_CF) + { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Chunked DIME SOAP message\n")); + soap->dime.chunksize = soap->dime.size; + if (soap->buflen - soap->bufidx >= soap->dime.chunksize) + { soap->dime.buflen = soap->buflen; + soap->buflen = soap->bufidx + soap->dime.chunksize; + } + else + soap->dime.chunksize -= soap->buflen - soap->bufidx; + } + soap->count = soap->buflen - soap->bufidx; + } +#endif + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static int +http_parse(struct soap *soap) +{ char header[SOAP_HDRLEN], *s; + unsigned short get = 0, status = 0, k = 0; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Waiting for HTTP request/response...\n")); + *soap->endpoint = '\0'; + soap->length = 0; + soap->userid = NULL; + soap->passwd = NULL; + soap->action = NULL; + soap->authrealm = NULL; + do + { if (soap_getline(soap, soap->msgbuf, sizeof(soap->msgbuf))) + return soap->error; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP status: %s\n", soap->msgbuf)); + for (;;) + { if (soap_getline(soap, header, SOAP_HDRLEN)) + { if (soap->error == SOAP_EOF) + { soap->error = SOAP_OK; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "EOF in HTTP header, continue anyway\n")); + break; + } + return soap->error; + } + if (!*header) + break; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP header: %s\n", header)); + s = strchr(header, ':'); + if (s) + { *s = '\0'; + do s++; + while (*s && *s <= 32); + if ((soap->error = soap->fparsehdr(soap, header, s))) + { if (soap->error < SOAP_STOP) + return soap->error; + status = soap->error; + soap->error = SOAP_OK; + } + } + } + if ((s = strchr(soap->msgbuf, ' '))) + { k = (unsigned short)soap_strtoul(s, &s, 10); + if (!soap_blank(*s)) + k = 0; + } + else + k = 0; + } while (k == 100); + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Finished HTTP header parsing\n")); + s = strstr(soap->msgbuf, "HTTP/"); + if (s && s[7] != '1') + { if (soap->keep_alive == 1) + soap->keep_alive = 0; + if (k == 0 && (soap->omode & SOAP_IO) == SOAP_IO_CHUNK) /* k == 0 for HTTP request */ + { soap->imode |= SOAP_IO_CHUNK; + soap->omode = (soap->omode & ~SOAP_IO) | SOAP_IO_STORE; + } + } + if (soap->keep_alive < 0) + soap->keep_alive = 1; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Keep alive connection = %d\n", soap->keep_alive)); + if (s && (((get = !strncmp(soap->msgbuf, "GET ", 4))) || !strncmp(soap->msgbuf, "POST ", 5))) + { size_t m = strlen(soap->endpoint); + size_t n = m + (s - soap->msgbuf) - 5 - (!get); + if (n >= sizeof(soap->endpoint)) + n = sizeof(soap->endpoint) - 1; + strncpy(soap->path, soap->msgbuf + 4 + (!get), n - m); + soap->path[n - m] = '\0'; + strcat(soap->endpoint, soap->path); + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Target endpoint='%s'\n", soap->endpoint)); + if (get) + { soap->error = soap->fget(soap); + if (soap->error == SOAP_OK) + soap->error = SOAP_STOP; /* prevents further processing */ + return soap->error; + } + if (status) + return soap->error = status; + return SOAP_OK; + } + if (k == 0 || k == 200 || k == 400 || k == 500 || (k >= 201 && k <= 299 && ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK || soap->length))) + return SOAP_OK; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "HTTP error %d\n", k)); + return soap_set_receiver_error(soap, "HTTP error", soap->msgbuf, k); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static int +http_parse_header(struct soap *soap, const char *key, const char *val) +{ if (!soap_tag_cmp(key, "Host")) + { +#ifdef WITH_OPENSSL + if (soap->imode & SOAP_ENC_SSL) + strcpy(soap->endpoint, "https://"); + else +#endif + strcpy(soap->endpoint, "http://"); + strncat(soap->endpoint, val, sizeof(soap->endpoint) - 8); + soap->endpoint[sizeof(soap->endpoint) - 1] = '\0'; + } +#ifndef WITH_LEANER + else if (!soap_tag_cmp(key, "Content-Type")) + { soap->http_content = soap_strdup(soap, val); + if (soap_get_header_attribute(soap, val, "application/dime")) + soap->mode |= SOAP_ENC_DIME; + else if (soap_get_header_attribute(soap, val, "multipart/related") + || soap_get_header_attribute(soap, val, "multipart/form-data")) + { soap->mime.boundary = soap_strdup(soap, soap_get_header_attribute(soap, val, "boundary")); + soap->mime.start = soap_strdup(soap, soap_get_header_attribute(soap, val, "start")); + soap->mode |= SOAP_ENC_MIME; + } + } +#endif + else if (!soap_tag_cmp(key, "Content-Length")) + soap->length = soap_strtoul(val, NULL, 10); + else if (!soap_tag_cmp(key, "Content-Encoding")) + { if (!soap_tag_cmp(val, "deflate")) +#ifdef WITH_ZLIB + soap->zlib_in = SOAP_ZLIB_DEFLATE; +#else + return SOAP_ZLIB_ERROR; +#endif + else if (!soap_tag_cmp(val, "gzip")) +#ifdef WITH_GZIP + soap->zlib_in = SOAP_ZLIB_GZIP; +#else + return SOAP_ZLIB_ERROR; +#endif + } +#ifdef WITH_ZLIB + else if (!soap_tag_cmp(key, "Accept-Encoding")) + { +#ifdef WITH_GZIP + if (strchr(val, '*') || soap_get_header_attribute(soap, val, "gzip")) + soap->zlib_out = SOAP_ZLIB_GZIP; + else +#endif + if (strchr(val, '*') || soap_get_header_attribute(soap, val, "deflate")) + soap->zlib_out = SOAP_ZLIB_DEFLATE; + else + soap->zlib_out = SOAP_ZLIB_NONE; + } +#endif + else if (!soap_tag_cmp(key, "Transfer-Encoding")) + { soap->mode &= ~SOAP_IO; + if (!soap_tag_cmp(val, "chunked")) + soap->mode |= SOAP_IO_CHUNK; + } + else if (!soap_tag_cmp(key, "Connection")) + { if (!soap_tag_cmp(val, "keep-alive")) + soap->keep_alive = -soap->keep_alive; + else if (!soap_tag_cmp(val, "close")) + soap->keep_alive = 0; + } +#ifndef WITH_LEAN + else if (!soap_tag_cmp(key, "Authorization")) + { if (!soap_tag_cmp(val, "Basic *")) + { int n; + char *s; + soap_base642s(soap, val + 6, soap->tmpbuf, sizeof(soap->tmpbuf) - 1, &n); + soap->tmpbuf[n] = '\0'; + if ((s = strchr(soap->tmpbuf, ':'))) + { *s = '\0'; + soap->userid = soap_strdup(soap, soap->tmpbuf); + soap->passwd = soap_strdup(soap, s + 1); + } + } + } + else if (!soap_tag_cmp(key, "WWW-Authenticate")) + soap->authrealm = soap_strdup(soap, soap_get_header_attribute(soap, val + 6, "realm")); + else if (!soap_tag_cmp(key, "Expect")) + { if (!soap_tag_cmp(val, "100-continue")) + { if ((soap->error = soap->fposthdr(soap, "HTTP/1.1 100 Continue", NULL)) + || (soap->error = soap->fposthdr(soap, NULL, NULL))) + return soap->error; + } + } +#endif + else if (!soap_tag_cmp(key, "SOAPAction")) + { if (*val == '"') + { soap->action = soap_strdup(soap, val + 1); + soap->action[strlen(soap->action) - 1] = '\0'; + } + } + else if (!soap_tag_cmp(key, "Location")) + { strncpy(soap->endpoint, val, sizeof(soap->endpoint)); + soap->endpoint[sizeof(soap->endpoint) - 1] = '\0'; + } +#ifdef WITH_COOKIES + else if (!soap_tag_cmp(key, "Cookie") || !soap_tag_cmp(key, "Set-Cookie")) + soap_getcookies(soap, val); +#endif + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER) +#ifndef PALM_1 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_get_header_attribute(struct soap *soap, const char *line, const char *key) +{ register const char *s = line; + if (s) + { while (*s) + { register short flag; + s = soap_decode_key(soap->tmpbuf, sizeof(soap->tmpbuf), s); + flag = soap_tag_cmp(soap->tmpbuf, key); + s = soap_decode_val(soap->tmpbuf, sizeof(soap->tmpbuf), s); + if (!flag) + return soap->tmpbuf; + } + } + return NULL; +} +#endif +#endif + +/******************************************************************************/ +#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER) +#ifndef PALM_1 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_decode_key(char *buf, size_t len, const char *val) +{ return soap_decode(buf, len, val, "=,;"); +} +#endif +#endif + +/******************************************************************************/ +#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER) +#ifndef PALM_1 +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_decode_val(char *buf, size_t len, const char *val) +{ if (*val != '=') + { *buf = '\0'; + return val; + } + return soap_decode(buf, len, val + 1, ",;"); +} +#endif +#endif + +/******************************************************************************/ +#if !defined(WITH_NOHTTP) || !defined(WITH_LEANER) +#ifndef PALM_1 +static const char* +soap_decode(char *buf, size_t len, const char *val, const char *sep) +{ const char *s; + char *t = buf; + for (s = val; *s; s++) + if (*s != ' ' && *s != '\t' && !strchr(sep, *s)) + break; + if (*s == '"') + { s++; + while (*s && *s != '"' && --len) + *t++ = *s++; + } + else + { while (soap_notblank(*s) && !strchr(sep, *s) && --len) + { if (*s == '%') + { *t++ = ((s[1] >= 'A' ? (s[1] & 0x7) + 9 : s[1] - '0') << 4) + + (s[2] >= 'A' ? (s[2] & 0x7) + 9 : s[2] - '0'); + s += 3; + } + else + *t++ = *s++; + } + } + *t = '\0'; + while (*s && !strchr(sep, *s)) + s++; + return s; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_envelope_begin_out(struct soap *soap) +{ +#ifndef WITH_LEANER + size_t n = 0; + if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary && soap->mime.start) + { const char *s; + if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM)) + s = "application/dime"; + else if (soap->version == 2) + { if (soap->mode & SOAP_ENC_MTOM) + s = "application/xop+xml; charset=utf-8; type=application/soap+xml"; + else + s = "application/soap+xml; charset=utf-8"; + } + else + s = "text/xml; charset=utf-8"; + sprintf(soap->tmpbuf, "--%s\r\nContent-Type: %s\r\nContent-Transfer-Encoding: binary\r\nContent-ID: %s\r\n\r\n", soap->mime.boundary, s, soap->mime.start); + n = strlen(soap->tmpbuf); + if (soap_send_raw(soap, soap->tmpbuf, n)) + return soap->error; + } + if (soap->mode & SOAP_IO_LENGTH) + soap->dime.size = soap->count; /* DIME in MIME correction */ + if (!(soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME)) + { if (soap_putdimehdr(soap)) + return soap->error; + } +#endif + soap->part = SOAP_IN_ENVELOPE; + return soap_element_begin_out(soap, "SOAP-ENV:Envelope", 0, NULL); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_envelope_end_out(struct soap *soap) +{ if (soap_element_end_out(soap, "SOAP-ENV:Envelope")) + return soap->error; +#ifndef WITH_LEANER + if ((soap->mode & SOAP_IO_LENGTH) && (soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM)) + { soap->dime.size = soap->count - soap->dime.size; /* DIME in MIME correction */ + sprintf(soap->id, soap->dime_id_format, 0); + soap->dime.id = soap->id; + if (soap->local_namespaces) + { if (soap->local_namespaces[0].out) + soap->dime.type = (char*)soap->local_namespaces[0].out; + else + soap->dime.type = (char*)soap->local_namespaces[0].ns; + } + soap->dime.options = NULL; + soap->dime.flags = SOAP_DIME_MB | SOAP_DIME_ABSURI; + if (!soap->dime.first) + soap->dime.flags |= SOAP_DIME_ME; + soap->count += 12 + ((strlen(soap->dime.id)+3)&(~3)) + (soap->dime.type ? ((strlen(soap->dime.type)+3)&(~3)) : 0); + } + if ((soap->mode & SOAP_ENC_DIME) && !(soap->mode & SOAP_ENC_MTOM)) + return soap_send_raw(soap, SOAP_STR_PADDING, -(long)soap->dime.size&3); +#endif + soap->part = SOAP_END_ENVELOPE; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_envelope_begin_in(struct soap *soap) +{ register struct Namespace *p; + soap->part = SOAP_IN_ENVELOPE; + if (soap_element_begin_in(soap, "SOAP-ENV:Envelope", 0, NULL)) + return soap->error = SOAP_VERSIONMISMATCH; + p = soap->local_namespaces; + if (p) + { const char *ns = p[0].out; + if (!ns) + ns = p[0].ns; + if (!strcmp(ns, soap_env1)) + { soap->version = 1; /* make sure we use SOAP 1.1 */ + if (p[1].out) + SOAP_FREE(soap, p[1].out); + if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc1)))) + strcpy(p[1].out, soap_enc1); + } + else if (!strcmp(ns, soap_env2)) + { soap->version = 2; /* make sure we use SOAP 1.2 */ + if (p[1].out) + SOAP_FREE(soap, p[1].out); + if ((p[1].out = (char*)SOAP_MALLOC(soap, sizeof(soap_enc2)))) + strcpy(p[1].out, soap_enc2); + } + } + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_envelope_end_in(struct soap *soap) +{ soap->part = SOAP_END_ENVELOPE; + return soap_element_end_in(soap, "SOAP-ENV:Envelope"); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_body_begin_out(struct soap *soap) +{ soap->part = SOAP_IN_BODY; + if (soap->version == 1) + soap->encoding = 1; +#ifndef WITH_LEAN + if ((soap->mode & SOAP_XML_SEC) && soap_set_attr(soap, "wsu:Id", "Body")) + return soap->error; +#endif + if (soap_element(soap, "SOAP-ENV:Body", 0, NULL)) + return soap->error; + return soap_element_start_end_out(soap, NULL); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_body_end_out(struct soap *soap) +{ if (soap_element_end_out(soap, "SOAP-ENV:Body")) + return soap->error; + soap->part = SOAP_END_BODY; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_body_begin_in(struct soap *soap) +{ soap->part = SOAP_IN_BODY; + if (soap_element_begin_in(soap, "SOAP-ENV:Body", 0, NULL)) + return soap->error; + if (!soap->body) + soap->part = SOAP_NO_BODY; + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_body_end_in(struct soap *soap) +{ if (soap->part == SOAP_NO_BODY) + return SOAP_OK; + soap->part = SOAP_END_BODY; + return soap_element_end_in(soap, "SOAP-ENV:Body"); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_recv_header(struct soap *soap) +{ if (soap_getheader(soap) && soap->error == SOAP_TAG_MISMATCH) + soap->error = SOAP_OK; + else if (soap->error == SOAP_OK && soap->fheader) + soap->error = soap->fheader(soap); + return soap->error; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_set_endpoint(struct soap *soap, const char *endpoint) +{ register const char *s; + register size_t i, n; + soap->endpoint[0] = '\0'; + soap->host[0] = '\0'; + soap->path[0] = '/'; + soap->path[1] = '\0'; + soap->port = 80; + if (!endpoint || !*endpoint) + return; +#ifdef WITH_OPENSSL + if (!soap_tag_cmp(endpoint, "https:*")) + soap->port = 443; +#endif + strncpy(soap->endpoint, endpoint, sizeof(soap->endpoint) - 1); + s = strchr(endpoint, ':'); + if (s && s[1] == '/' && s[2] == '/') + s += 3; + else + s = endpoint; + n = strlen(s); + if (n >= sizeof(soap->host)) + n = sizeof(soap->host) - 1; +#ifdef WITH_IPV6 + if (s[0] == '[') + { s++; + for (i = 0; i < n; i++) + { soap->host[i] = s[i]; + if (s[i] == ']') + { s++; + break; + } + } + } + else + { for (i = 0; i < n; i++) + { soap->host[i] = s[i]; + if (s[i] == '/' || s[i] == ':') + break; + } + } +#else + for (i = 0; i < n; i++) + { soap->host[i] = s[i]; + if (s[i] == '/' || s[i] == ':') + break; + } +#endif + soap->host[i] = '\0'; + if (s[i] == ':') + { soap->port = (int)atol(s + i + 1); + for (i++; i < n; i++) + if (s[i] == '/') + break; + } + if (s[i]) + { strncpy(soap->path, s + i, sizeof(soap->path)); + soap->path[sizeof(soap->path) - 1] = '\0'; + } +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_connect(struct soap *soap, const char *endpoint, const char *action) +{ return soap_connect_command(soap, SOAP_POST, endpoint, action); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_connect_command(struct soap *soap, int http_command, const char *endpoint, const char *action) +{ char host[sizeof(soap->host)]; + int port; + size_t count; + soap->error = SOAP_OK; + strcpy(host, soap->host); /* save to compare */ + port = soap->port; /* save to compare */ + soap_set_endpoint(soap, endpoint); +#ifndef WITH_LEANER + if (soap->fconnect) + { if ((soap->error = soap->fconnect(soap, endpoint, soap->host, soap->port))) + return soap->error; + } + else +#endif + if (soap->fopen && *soap->host) + { soap->status = http_command; + if (!soap->keep_alive || !soap_valid_socket(soap->socket) || strcmp(soap->host, host) || soap->port != port || !soap->fpoll || soap->fpoll(soap)) + { soap->keep_alive = 0; /* to force close */ + soap->omode &= ~SOAP_IO_UDP; /* to force close */ + soap_closesock(soap); + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Connect/reconnect to host='%s' path='%s' port=%d\n", soap->host, soap->path, soap->port)); +#ifdef WITH_UDP + if (!strncmp(endpoint, "soap.udp:", 9)) + soap->omode |= SOAP_IO_UDP; +#endif + soap->socket = soap->fopen(soap, endpoint, soap->host, soap->port); + if (soap->error) + return soap->error; + soap->keep_alive = ((soap->omode & SOAP_IO_KEEPALIVE) != 0); + } + } + count = soap_count_attachments(soap); + if (soap_begin_send(soap)) + return soap->error; +#ifndef WITH_NOHTTP + soap->action = soap_strdup(soap, action); + if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_XML) && endpoint) + { unsigned int k = soap->mode; + soap->mode &= ~(SOAP_IO | SOAP_ENC_ZLIB); + if ((k & SOAP_IO) != SOAP_IO_FLUSH) + soap->mode |= SOAP_IO_BUFFER; + if ((soap->error = soap->fpost(soap, endpoint, soap->host, soap->port, soap->path, action, count))) + return soap->error; +#ifndef WITH_LEANER + if ((k & SOAP_IO) == SOAP_IO_CHUNK) + { if (soap_flush(soap)) + return soap->error; + } +#endif + soap->mode = k; + } + if (http_command != SOAP_POST) + return soap_end_send(soap); +#endif + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +char* +SOAP_FMAC2 +soap_s2base64(struct soap *soap, const unsigned char *s, char *t, int n) +{ register int i; + register unsigned long m; + register char *p; + if (!t) + t = (char*)soap_malloc(soap, (n + 2) / 3 * 4 + 1); + if (!t) + { soap->error = SOAP_EOM; + return NULL; + } + p = t; + t[0] = '\0'; + if (!s) + return p; + for (; n > 2; n -= 3, s += 3) + { m = s[0]; + m = (m << 8) | s[1]; + m = (m << 8) | s[2]; + for (i = 4; i > 0; m >>= 6) + t[--i] = soap_base64o[m & 0x3F]; + t += 4; + } + t[0] = '\0'; + if (n > 0) + { m = 0; + for (i = 0; i < n; i++) + m = (m << 8) | *s++; + for (; i < 3; i++) + m <<= 8; + for (i++; i > 0; m >>= 6) + t[--i] = soap_base64o[m & 0x3F]; + for (i = 3; i > n; i--) + t[i] = '='; + t[4] = '\0'; + } + return p; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_base642s(struct soap *soap, const char *s, char *t, size_t l, int *n) +{ register int i, j, c; + register unsigned long m; + register const char *p; + if (!s || !*s) + { if (n) + *n = 0; + if (soap->error) + return NULL; + return SOAP_NON_NULL; + } + if (!t) + { l = (strlen(s) + 3) / 4 * 3; + t = (char*)soap_malloc(soap, l); + } + if (!t) + { soap->error = SOAP_EOM; + return NULL; + } + p = t; + if (n) + *n = 0; + for (;;) + { for (i = 0; i < SOAP_BLKLEN; i++) + { m = 0; + j = 0; + while (j < 4) + { c = *s++; + if (c == '=' || !c) + { i *= 3; + switch (j) + { case 2: + *t++ = (char)((m >> 4) & 0xFF); + i++; + break; + case 3: + *t++ = (char)((m >> 10) & 0xFF); + *t++ = (char)((m >> 2) & 0xFF); + i += 2; + } + if (n) + *n += i; + return p; + } + c -= '+'; + if (c >= 0 && c <= 79) + { m = (m << 6) + soap_base64i[c]; + j++; + } + } + *t++ = (char)((m >> 16) & 0xFF); + *t++ = (char)((m >> 8) & 0xFF); + *t++ = (char)(m & 0xFF); + if (l < 3) + { if (n) + *n += i; + return p; + } + l -= 3; + } + if (n) + *n += 3 * SOAP_BLKLEN; + } +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +char* +SOAP_FMAC2 +soap_s2hex(struct soap *soap, const unsigned char *s, char *t, int n) +{ register char *p; + if (!t) + t = (char*)soap_malloc(soap, 2 * n + 1); + if (!t) + { soap->error = SOAP_EOM; + return NULL; + } + p = t; + t[0] = '\0'; + if (s) + { for (; n > 0; n--) + { register int m = *s++; + *t++ = (char)((m >> 4) + (m > 159 ? 'a' - 10 : '0')); + m &= 0x0F; + *t++ = (char)(m + (m > 9 ? 'a' - 10 : '0')); + } + } + *t++ = '\0'; + return p; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +SOAP_FMAC1 +const char* +SOAP_FMAC2 +soap_hex2s(struct soap *soap, const char *s, char *t, size_t l, int *n) +{ register const char *p; + if (!s || !*s) + { if (n) + *n = 0; + if (soap->error) + return NULL; + return SOAP_NON_NULL; + } + if (!t) + { l = strlen(s) / 2; + t = (char*)soap_malloc(soap, l); + } + if (!t) + { soap->error = SOAP_EOM; + return NULL; + } + p = t; + while (l) + { register int d1, d2; + d1 = *s++; + if (!d1) + break; + d2 = *s++; + if (!d2) + break; + *t++ = ((d1 >= 'A' ? (d1 & 0x7) + 9 : d1 - '0') << 4) + (d2 >= 'A' ? (d2 & 0x7) + 9 : d2 - '0'); + l--; + } + if (n) + *n = t - p; + return p; +} +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_puthttphdr(struct soap *soap, int status, size_t count) +{ register const char *s = NULL; + register int err = SOAP_OK; +#ifndef WITH_LEANER + register const char *r = NULL; +#endif + if (status == SOAP_FILE && soap->http_content) + s = soap->http_content; + else if (status == SOAP_HTML) + s = "text/html; charset=utf-8"; + else if (count || ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK)) + { if (soap->version == 2) + s = "application/soap+xml; charset=utf-8"; + else + s = "text/xml; charset=utf-8"; + } +#ifndef WITH_LEANER + if (soap->mode & (SOAP_ENC_DIME | SOAP_ENC_MTOM)) + { if (soap->mode & SOAP_ENC_MTOM) + { r = s; + s = "application/xop+xml; charset=utf-8"; + } + else + s = "application/dime"; + } + if ((soap->mode & SOAP_ENC_MIME) && soap->mime.boundary && soap->status != SOAP_GET) + { register const char *t = strchr(s, ';'); + sprintf(soap->tmpbuf, "multipart/related; boundary=\"%s\"; type=\"", soap->mime.boundary); + if (t) + strncat(soap->tmpbuf, s, t - s); + else + strcat(soap->tmpbuf, s); + if (soap->mime.start) + { strcat(soap->tmpbuf, "\"; start=\""); + strcat(soap->tmpbuf, soap->mime.start); + } + strcat(soap->tmpbuf, "\""); + if (r) + { strcat(soap->tmpbuf, "; start-info=\""); + strcat(soap->tmpbuf, r); + strcat(soap->tmpbuf, "\""); + } + s = soap->tmpbuf; + } +#endif + if (s && (err = soap->fposthdr(soap, "Content-Type", s))) + return err; +#ifdef WITH_ZLIB + if (soap->omode & SOAP_ENC_ZLIB) + { +#ifdef WITH_GZIP + err = soap->fposthdr(soap, "Content-Encoding", "gzip"); +#else + err = soap->fposthdr(soap, "Content-Encoding", "deflate"); +#endif + if (err) + return err; + } +#endif +#ifndef WITH_LEANER + if ((soap->omode & SOAP_IO) == SOAP_IO_CHUNK) + err = soap->fposthdr(soap, "Transfer-Encoding", "chunked"); + else +#endif + if (s && soap->status != SOAP_GET) + { sprintf(soap->tmpbuf, "%lu", (unsigned long)count); + err = soap->fposthdr(soap, "Content-Length", soap->tmpbuf); + } + if (err) + return err; + return soap->fposthdr(soap, "Connection", soap->keep_alive ? "keep-alive" : "close"); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static int +http_get(struct soap *soap) +{ return SOAP_GET_METHOD; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static int +http_post(struct soap *soap, const char *endpoint, const char *host, int port, const char *path, const char *action, size_t count) +{ register const char *s; + register int err; + if (soap->status == SOAP_GET) + s = "GET"; + else + s = "POST"; +#ifdef PALM + if (!endpoint || (soap_tag_cmp(endpoint, "http:*") && soap_tag_cmp(endpoint, "https:*") && strncmp(endpoint, "httpg:", 6)) && strncmp(endpoint, "_beam:", 6) && strncmp(endpoint, "_local:", 7) && strncmp(endpoint, "_btobex:", 8)) +#else + if (!endpoint || (soap_tag_cmp(endpoint, "http:*") && soap_tag_cmp(endpoint, "https:*") && strncmp(endpoint, "httpg:", 6))) +#endif + return SOAP_OK; + if (soap->proxy_host && soap_tag_cmp(endpoint, "https:*")) + sprintf(soap->tmpbuf, "%s %s HTTP/%s", s, endpoint, soap->http_version); + else + sprintf(soap->tmpbuf, "%s /%s HTTP/%s", s, (*path == '/' ? path + 1 : path), soap->http_version); + if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL))) + return err; + if (port != 80) + sprintf(soap->tmpbuf, "%s:%d", host, port); + else + strcpy(soap->tmpbuf, host); + if ((err = soap->fposthdr(soap, "Host", soap->tmpbuf)) + || (err = soap->fposthdr(soap, "User-Agent", "gSOAP/2.7")) + || (err = soap_puthttphdr(soap, SOAP_OK, count))) + return err; +#ifdef WITH_ZLIB +#ifdef WITH_GZIP + if ((err = soap->fposthdr(soap, "Accept-Encoding", "gzip, deflate"))) +#else + if ((err = soap->fposthdr(soap, "Accept-Encoding", "deflate"))) +#endif + return err; +#endif +#ifndef WITH_LEAN + if (soap->userid && soap->passwd && strlen(soap->userid) + strlen(soap->passwd) < 761) + { sprintf(soap->tmpbuf + 262, "%s:%s", soap->userid, soap->passwd); + strcpy(soap->tmpbuf, "Basic "); + soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, strlen(soap->tmpbuf + 262)); + if ((err = soap->fposthdr(soap, "Authorization", soap->tmpbuf))) + return err; + } + if (soap->proxy_userid && soap->proxy_passwd && strlen(soap->proxy_userid) + strlen(soap->proxy_passwd) < 761) + { sprintf(soap->tmpbuf + 262, "%s:%s", soap->proxy_userid, soap->proxy_passwd); + strcpy(soap->tmpbuf, "Basic "); + soap_s2base64(soap, (const unsigned char*)(soap->tmpbuf + 262), soap->tmpbuf + 6, strlen(soap->tmpbuf + 262)); + if ((err = soap->fposthdr(soap, "Proxy-Authorization", soap->tmpbuf))) + return err; + } +#endif +#ifdef WITH_COOKIES +#ifdef WITH_OPENSSL + if (soap_putcookies(soap, host, path, soap->ssl != NULL)) + return soap->error; +#else + if (soap_putcookies(soap, host, path, 0)) + return soap->error; +#endif +#endif + if (soap->version == 1 || (action && *action)) + { sprintf(soap->tmpbuf, "\"%s\"", action?action:""); + if ((err = soap->fposthdr(soap, "SOAPAction", soap->tmpbuf))) + return err; + } + return soap->fposthdr(soap, NULL, NULL); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static int +http_send_header(struct soap *soap, const char *s) +{ register const char *t; + do + { t = strchr(s, '\n'); /* disallow \n in HTTP headers */ + if (!t) + t = s + strlen(s); + if (soap_send_raw(soap, s, t - s)) + return soap->error; + s = t + 1; + } while (*t); + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static int +http_post_header(struct soap *soap, const char *key, const char *val) +{ if (key) + { if (http_send_header(soap, key)) + return soap->error; + if (val && (soap_send_raw(soap, ": ", 2) || http_send_header(soap, val))) + return soap->error; + } + return soap_send_raw(soap, "\r\n", 2); +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +static int +http_response(struct soap *soap, int status, size_t count) +{ register int err; +#ifdef WMW_RPM_IO + if (soap->rpmreqid) + httpOutputEnable(soap->rpmreqid); +#endif + if (!status || status == SOAP_HTML || status == SOAP_FILE) + { const char *s; + if (count || ((soap->mode & SOAP_IO) == SOAP_IO_CHUNK)) + s = "200 OK"; + else + s = "202 ACCEPTED"; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Status = %s\n", s)); +#ifdef WMW_RPM_IO + if (soap->rpmreqid || soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* RPM behaves as if standalone */ +#else + if (soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* standalone application */ +#endif + { sprintf(soap->tmpbuf, "HTTP/%s %s", soap->http_version, s); + if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL))) + return err; + } + else if ((err = soap->fposthdr(soap, "Status", s))) + return err; + } + else if (status >= 200 && status < 600) + { sprintf(soap->tmpbuf, "HTTP/%s %d %s", soap->http_version, status, http_error(soap, status)); + if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL))) + return err; +#ifndef WITH_LEAN + if (status == 401) + { sprintf(soap->tmpbuf, "Basic realm=\"%s\"", soap->authrealm ? soap->authrealm : "gSOAP Web Service"); + if ((err = soap->fposthdr(soap, "WWW-Authenticate", soap->tmpbuf))) + return err; + } + else if ((status >= 301 && status <= 303) || status == 307) + { if ((err = soap->fposthdr(soap, "Location", soap->endpoint))) + return err; + } +#endif + } + else + { const char *s = *soap_faultcode(soap); + if (soap->version == 2 && !strcmp(s, "SOAP-ENV:Sender")) + s = "400 Bad Request"; + else + s = "500 Internal Server Error"; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Error %s (status=%d)\n", s, status)); +#ifdef WMW_RPM_IO + if (soap->rpmreqid || soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* RPM behaves as if standalone */ +#else + if (soap_valid_socket(soap->master) || soap_valid_socket(soap->socket)) /* standalone application */ +#endif + { sprintf(soap->tmpbuf, "HTTP/%s %s", soap->http_version, s); + if ((err = soap->fposthdr(soap, soap->tmpbuf, NULL))) + return err; + } + else if ((err = soap->fposthdr(soap, "Status", s))) /* CGI */ + return err; + } + if ((err = soap->fposthdr(soap, "Server", "gSOAP/2.7")) + || (err = soap_puthttphdr(soap, status, count))) + return err; +#ifdef WITH_COOKIES + if (soap_putsetcookies(soap)) + return soap->error; +#endif + return soap->fposthdr(soap, NULL, NULL); +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_response(struct soap *soap, int status) +{ register size_t count; + if (!(soap->omode & (SOAP_ENC_XML | SOAP_IO_STORE /* this tests for chunking too */)) + && (status == SOAP_HTML || status == SOAP_FILE)) + { soap->omode &= ~SOAP_IO; + soap->omode |= SOAP_IO_STORE; + } + soap->status = status; + count = soap_count_attachments(soap); + if (soap_begin_send(soap)) + return soap->error; +#ifndef WITH_NOHTTP + if ((soap->mode & SOAP_IO) != SOAP_IO_STORE && !(soap->mode & SOAP_ENC_XML)) + { register int n = soap->mode; + soap->mode &= ~(SOAP_IO | SOAP_ENC_ZLIB); + if ((n & SOAP_IO) != SOAP_IO_FLUSH) + soap->mode |= SOAP_IO_BUFFER; + if ((soap->error = soap->fresponse(soap, status, count))) + return soap->error; +#ifndef WITH_LEANER + if ((n & SOAP_IO) == SOAP_IO_CHUNK) + { if (soap_flush(soap)) + return soap->error; + } +#endif + soap->mode = n; + } +#endif + return SOAP_OK; +} +#endif + +/******************************************************************************/ +#ifndef WITH_LEAN +static const char* +soap_set_validation_fault(struct soap *soap, const char *s, const char *t) +{ if (*soap->tag) + sprintf(soap->msgbuf, "Validation constraint violation: %s%s in element <%s>", s, t?t:SOAP_STR_EOS, soap->tag); + else + sprintf(soap->msgbuf, "Validation constraint violation: %s%s", s, t?t:SOAP_STR_EOS); + return soap->msgbuf; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_set_fault(struct soap *soap) +{ const char **c = soap_faultcode(soap); + const char **s = soap_faultstring(soap); + if (soap->fseterror) + soap->fseterror(soap, c, s); + if (!*c) + { if (soap->version == 2) + *c = "SOAP-ENV:Sender"; + else + *c = "SOAP-ENV:Client"; + } + if (*s) + return; + switch (soap->error) + { +#ifndef WITH_LEAN + case SOAP_CLI_FAULT: + *s = "Client fault"; + break; + case SOAP_SVR_FAULT: + *s = "Server fault"; + break; + case SOAP_TAG_MISMATCH: + *s = soap_set_validation_fault(soap, "tag name or namespace mismatch", NULL); + break; + case SOAP_TYPE: + *s = soap_set_validation_fault(soap, "data type mismatch ", soap->type); + break; + case SOAP_SYNTAX_ERROR: + *s = "Well-formedness violation"; + break; + case SOAP_NO_TAG: + *s = "No XML element tag"; + break; + case SOAP_MUSTUNDERSTAND: + *c = "SOAP-ENV:MustUnderstand"; + sprintf(soap->msgbuf, "The data in element '%s' must be understood but cannot be handled", soap->tag); + *s = soap->msgbuf; + break; + case SOAP_VERSIONMISMATCH: + *c = "SOAP-ENV:VersionMismatch"; + *s = "SOAP version mismatch or invalid SOAP message"; + break; + case SOAP_DATAENCODINGUNKNOWN: + *c = "SOAP-ENV:DataEncodingUnknown"; + *s = "Unsupported SOAP data encoding"; + break; + case SOAP_NAMESPACE: + *s = soap_set_validation_fault(soap, "namespace mismatch", NULL); + break; + case SOAP_USER_ERROR: + *s = "User error"; + break; + case SOAP_FATAL_ERROR: + *s = "Fatal error"; + break; + case SOAP_NO_METHOD: + sprintf(soap->msgbuf, "Method '%s' not implemented: method name or namespace not recognized", soap->tag); + *s = soap->msgbuf; + break; + case SOAP_GET_METHOD: + *s = "HTTP GET method not implemented"; + break; + case SOAP_EOM: + *s = "Out of memory"; + break; + case SOAP_IOB: + *s = "Array index out of bounds"; + break; + case SOAP_NULL: + *s = soap_set_validation_fault(soap, "nil not allowed", NULL); + break; + case SOAP_DUPLICATE_ID: + *s = soap_set_validation_fault(soap, "multiple definitions of id ", soap->id); + if (soap->version == 2) + *soap_faultsubcode(soap) = "SOAP-ENC:DuplicateID"; + break; + case SOAP_MISSING_ID: + *s = soap_set_validation_fault(soap, "missing id for ref ", soap->id); + if (soap->version == 2) + *soap_faultsubcode(soap) = "SOAP-ENC:MissingID"; + break; + case SOAP_HREF: + *s = soap_set_validation_fault(soap, "incompatible object ref ", soap->id); + break; + case SOAP_FAULT: + break; +#ifndef WITH_NOIO + case SOAP_UDP_ERROR: + *s = "Message too large for UDP packet"; + break; + case SOAP_TCP_ERROR: + *s = tcp_error(soap); + break; +#endif + case SOAP_HTTP_ERROR: + *s = "HTTP error"; + break; + case SOAP_SSL_ERROR: +#ifdef WITH_OPENSSL + *s = "SSL error"; +#else + *s = "OpenSSL not installed: recompile with -DWITH_OPENSSL"; +#endif + break; + case SOAP_PLUGIN_ERROR: + *s = "Plugin registry error"; + break; + case SOAP_DIME_ERROR: + *s = "DIME format error"; + break; + case SOAP_DIME_HREF: + *s = "DIME href to missing attachment"; + break; + case SOAP_DIME_MISMATCH: + *s = "DIME version/transmission error"; + break; + case SOAP_DIME_END: + *s = "End of DIME error"; + break; + case SOAP_MIME_ERROR: + *s = "MIME format error"; + break; + case SOAP_MIME_HREF: + *s = "MIME href to missing attachment"; + break; + case SOAP_MIME_END: + *s = "End of MIME error"; + break; + case SOAP_ZLIB_ERROR: +#ifdef WITH_ZLIB + sprintf(soap->msgbuf, "Zlib/gzip error: '%s'", soap->d_stream.msg?soap->d_stream.msg:""); + *s = soap->msgbuf; +#else + *s = "Zlib/gzip not installed for (de)compression: recompile with -DWITH_GZIP"; +#endif + break; + case SOAP_REQUIRED: + *s = soap_set_validation_fault(soap, "missing required attribute", NULL); + break; + case SOAP_PROHIBITED: + *s = soap_set_validation_fault(soap, "prohibited attribute present", NULL); + break; + case SOAP_OCCURS: + *s = soap_set_validation_fault(soap, "min/maxOccurs violation", NULL); + break; + case SOAP_LENGTH: + *s = soap_set_validation_fault(soap, "content length violation", NULL); + break; + case SOAP_FD_EXCEEDED: + *s = "Maximum number of open connections was reached"; + break; + case SOAP_STOP: + *s = "Stopped: no response sent"; + break; +#endif + case SOAP_EOF: +#ifndef WITH_NOIO + sprintf(soap->msgbuf, "End of file or no input: '%s'", soap_strerror(soap)); + *s = soap->msgbuf; + break; +#else + *s = "End of file or no input"; + break; +#endif + default: +#ifndef WITH_NOHTTP +#ifndef WITH_LEAN + if (soap->error > 200 && soap->error < 600) + { sprintf(soap->msgbuf, "HTTP Error: %d %s", soap->error, http_error(soap, soap->error)); + *s = soap->msgbuf; + } + else +#endif +#endif + { sprintf(soap->msgbuf, "Error %d", soap->error); + *s = soap->msgbuf; + } + } +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_send_fault(struct soap *soap) +{ register int status = soap->error; + int r = 1; + if (status == SOAP_STOP) + return status; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Sending back fault struct for error code %d\n", soap->error)); + soap->keep_alive = 0; /* to terminate connection */ + soap_set_fault(soap); +#ifndef WITH_NOIO +#ifndef WITH_LEAN + if (soap_valid_socket(soap->socket)) + { struct timeval timeout; + fd_set rfd, sfd; + timeout.tv_sec = 0; + timeout.tv_usec = 0; + FD_ZERO(&rfd); + FD_ZERO(&sfd); + FD_SET((SOAP_SOCKET)soap->socket, &rfd); + FD_SET((SOAP_SOCKET)soap->socket, &sfd); + r = select((SOAP_SOCKET)(soap->socket + 1), &rfd, &sfd, NULL, &timeout); + if (r > 0) + { if (!FD_ISSET((SOAP_SOCKET)soap->socket, &sfd) + || (FD_ISSET((SOAP_SOCKET)soap->socket, &rfd) + && recv((SOAP_SOCKET)soap->socket, soap->tmpbuf, 1, MSG_PEEK) < 0)) + r = 0; + } + } +#endif +#endif + if ((status != SOAP_EOF || (!soap->recv_timeout && !soap->send_timeout)) && r > 0) + { soap->error = SOAP_OK; + soap_serializeheader(soap); + soap_serializefault(soap); + soap_begin_count(soap); + if (soap->mode & SOAP_IO_LENGTH) + { soap_envelope_begin_out(soap); + soap_putheader(soap); + soap_body_begin_out(soap); + soap_putfault(soap); + soap_body_end_out(soap); + soap_envelope_end_out(soap); + } + soap_end_count(soap); + if (soap_response(soap, status) + || soap_envelope_begin_out(soap) + || soap_putheader(soap) + || soap_body_begin_out(soap) + || soap_putfault(soap) + || soap_body_end_out(soap) + || soap_envelope_end_out(soap)) + return soap_closesock(soap); + soap_end_send(soap); + } + soap->error = status; + return soap_closesock(soap); +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_recv_fault(struct soap *soap) +{ register int status = soap->error; + DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Receiving SOAP Fault\n")); + soap->error = SOAP_OK; + if (soap_getfault(soap)) + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Error: soap_get_soapfault() failed. Is this a SOAP message at all?\n")); + *soap_faultcode(soap) = (soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client"); + soap->error = status; + soap_set_fault(soap); + } + else + { register const char *s = *soap_faultcode(soap); + if (!soap_match_tag(soap, s, "SOAP-ENV:Server") || !soap_match_tag(soap, s, "SOAP-ENV:Receiver")) + status = SOAP_SVR_FAULT; + else if (!soap_match_tag(soap, s, "SOAP-ENV:Client") || !soap_match_tag(soap, s, "SOAP-ENV:Sender")) + status = SOAP_CLI_FAULT; + else if (!soap_match_tag(soap, s, "SOAP-ENV:MustUnderstand")) + status = SOAP_MUSTUNDERSTAND; + else if (!soap_match_tag(soap, s, "SOAP-ENV:VersionMismatch")) + status = SOAP_VERSIONMISMATCH; + else + { DBGLOG(TEST,SOAP_MESSAGE(fdebug, "Fault code %s\n", s)); + status = SOAP_FAULT; + } + if (soap_body_end_in(soap) + || soap_envelope_end_in(soap) + || soap_end_recv(soap)) + return soap_closesock(soap); + soap->error = status; + } + return soap_closesock(soap); +} +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_send_empty_response(struct soap *soap, int status) +{ register soap_mode m = soap->omode; + soap->count = 0; + if ((m & SOAP_IO) == SOAP_IO_CHUNK) + { soap->omode &= ~SOAP_IO_CHUNK; + soap->omode |= SOAP_IO_BUFFER; + } + if (soap_response(soap, status) || soap_end_send(soap)) + { soap->omode = m; + return soap_closesock(soap); + } + soap->omode = m; + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOHTTP +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_recv_empty_response(struct soap *soap) +{ if (soap_begin_recv(soap) || soap_end_recv(soap)) + { if (soap->error != 202) + return soap_closesock(soap); + soap->error = SOAP_OK; + } + return SOAP_OK; +} +#endif +#endif + +/******************************************************************************/ +#ifndef WITH_NOIO +#ifndef PALM_1 +static const char* +soap_strerror(struct soap *soap) +{ register int err = soap->errnum; + if (err) + { +#ifndef WIN32 + return strerror(err); +#else + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, (LPTSTR)&soap->errorstr, sizeof(soap->errorstr)/sizeof(soap->errorstr[0]), NULL); + return soap->errorstr; +#endif + } + return "Operation interrupted or timed out"; +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_2 +static int +soap_set_error(struct soap *soap, const char *faultcode, const char *faultsubcode, const char *faultstring, const char *faultdetail, int soaperror) +{ *soap_faultcode(soap) = faultcode; + if (faultsubcode) + *soap_faultsubcode(soap) = faultsubcode; + *soap_faultstring(soap) = faultstring; + if (faultdetail && *faultdetail) + { register const char **s = soap_faultdetail(soap); + if (s) + *s = faultdetail; + } + return soap->error = soaperror; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_set_sender_error(struct soap *soap, const char *faultstring, const char *faultdetail, int soaperror) +{ return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", NULL, faultstring, faultdetail, soaperror); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_set_receiver_error(struct soap *soap, const char *faultstring, const char *faultdetail, int soaperror) +{ return soap_set_error(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", NULL, faultstring, faultdetail, soaperror); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +static int +soap_copy_fault(struct soap *soap, const char *faultcode, const char *faultsubcode, const char *faultstring, const char *faultdetail) +{ char *r = NULL, *s = NULL, *t = NULL; + if (faultsubcode) + r = soap_strdup(soap, faultsubcode); + if (faultstring) + s = soap_strdup(soap, faultstring); + if (faultdetail) + t = soap_strdup(soap, faultdetail); + return soap_set_error(soap, faultcode, r, s, t, SOAP_FAULT); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_sender_fault(struct soap *soap, const char *faultstring, const char *faultdetail) +{ return soap_sender_fault_subcode(soap, NULL, faultstring, faultdetail); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_sender_fault_subcode(struct soap *soap, const char *faultsubcode, const char *faultstring, const char *faultdetail) +{ return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Sender" : "SOAP-ENV:Client", faultsubcode, faultstring, faultdetail); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_receiver_fault(struct soap *soap, const char *faultstring, const char *faultdetail) +{ return soap_receiver_fault_subcode(soap, NULL, faultstring, faultdetail); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_receiver_fault_subcode(struct soap *soap, const char *faultsubcode, const char *faultstring, const char *faultdetail) +{ return soap_copy_fault(soap, soap->version == 2 ? "SOAP-ENV:Receiver" : "SOAP-ENV:Server", faultsubcode, faultstring, faultdetail); +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +#ifndef WITH_NOSTDLIB +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_print_fault(struct soap *soap, FILE *fd) +{ if (soap_check_state(soap)) + fprintf(fd, "Error: soap struct not initialized\n"); + else if (soap->error) + { const char *c, *v = NULL, *s, **d; + d = soap_faultcode(soap); + if (!*d) + soap_set_fault(soap); + c = *d; + if (soap->version == 2) + v = *soap_faultsubcode(soap); + s = *soap_faultstring(soap); + d = soap_faultdetail(soap); + fprintf(fd, "%s%d fault: %s [%s]\n\"%s\"\nDetail: %s\n", soap->version ? "SOAP 1." : "Error ", soap->version ? (int)soap->version : soap->error, c, v ? v : "no subcode", s ? s : "[no reason]", d && *d ? *d : "[no detail]"); + } +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +#ifndef WITH_NOSTDLIB +SOAP_FMAC1 +void +SOAP_FMAC2 +soap_print_fault_location(struct soap *soap, FILE *fd) +{ +#ifndef WITH_LEAN + int i, j, c1, c2; + if (soap->error && soap->buflen > 0) + { i = (int)soap->bufidx - 1; + if (i <= 0) + i = 0; + c1 = soap->buf[i]; + soap->buf[i] = '\0'; + if ((int)soap->buflen >= i + 1024) + j = i + 1023; + else + j = (int)soap->buflen - 1; + c2 = soap->buf[j]; + soap->buf[j] = '\0'; + fprintf(fd, "%s%c\n\n", soap->buf, c1); + if (soap->bufidx < soap->buflen) + fprintf(fd, "%s\n", soap->buf + soap->bufidx); + soap->buf[i] = c1; + soap->buf[j] = c2; + } +#endif +} +#endif +#endif + +/******************************************************************************/ +#ifndef PALM_1 +SOAP_FMAC1 +int +SOAP_FMAC2 +soap_register_plugin_arg(struct soap *soap, int (*fcreate)(struct soap*, struct soap_plugin*, void*), void *arg) +{ register struct soap_plugin *p; + register int r; + if (!(p = (struct soap_plugin*)SOAP_MALLOC(soap, sizeof(struct soap_plugin)))) + return soap->error = SOAP_EOM; + p->id = NULL; + p->data = NULL; + p->fcopy = NULL; + p->fdelete = NULL; + r = fcreate(soap, p, arg); + if (!r && p->fdelete) + { p->next = soap->plugins; + soap->plugins = p; + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Registered '%s' plugin\n", p->id)); + return SOAP_OK; + } + DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Could not register plugin '%s': plugin returned error %d (or fdelete callback not set)\n", p->id?p->id:"?", r)); + SOAP_FREE(soap, p); + return r; +} +#endif + +/******************************************************************************/ +#ifndef PALM_1 +static void * +fplugin(struct soap *soap, const char *id) +{ register struct soap_plugin *p; + for (p = soap->plugins; p; p = p->next) + if (p->id == id || !strcmp(p->id, id)) + return p->data; + return NULL; +} +#endif + +/******************************************************************************/ +#ifndef PALM_2 +SOAP_FMAC1 +void * +SOAP_FMAC2 +soap_lookup_plugin(struct soap *soap, const char *id) +{ return soap->fplugin(soap, id); +} +#endif + +/******************************************************************************/ +#ifdef __cplusplus +} +#endif + +/******************************************************************************\ + * + * C++ soap struct methods + * +\******************************************************************************/ + +#ifdef __cplusplus +#ifndef WITH_LEAN +soap::soap() +{ soap_init(this); +} +#endif +#endif + +/******************************************************************************/ +#ifdef __cplusplus +#ifndef WITH_LEAN +soap::soap(soap_mode m) +{ soap_init1(this, m); +} +#endif +#endif + +/******************************************************************************/ +#ifdef __cplusplus +#ifndef WITH_LEAN +soap::soap(soap_mode im, soap_mode om) +{ soap_init2(this, im, om); +} +#endif +#endif + +/******************************************************************************/ +#ifdef __cplusplus +#ifndef WITH_LEAN +soap::soap(struct soap& soap) +{ soap_copy_context(this, &soap); +} +#endif +#endif + +/******************************************************************************/ +#ifdef __cplusplus +#ifndef WITH_LEAN +soap::~soap() +{ soap_destroy(this); + soap_end(this); + soap_done(this); +} +#endif +#endif + +/******************************************************************************/ diff --git a/pcucontrol/models/racadm.py b/pcucontrol/models/racadm.py new file mode 100755 index 0000000..f4e69dc --- /dev/null +++ b/pcucontrol/models/racadm.py @@ -0,0 +1,124 @@ +#!/usr/bin/python + +import threading +import socket +import os +import popen2 +#import logger + +def runcmd(command, args, username, password, timeout = None): + + result = [None] + result_ready = threading.Condition() + + def set_result(x): + + result_ready.acquire() + try: + result[0] = x + finally: + result_ready.notify() + result_ready.release() + + def do_command(command, username, password): + + try: + # Popen4 is a popen-type class that combines stdout and stderr + p = popen2.Popen4(command) + + # read all output data + p.tochild.write("%s\n" % username) + p.tochild.write("%s\n" % password) + p.tochild.close() + data = p.fromchild.read() + + while True: + # might get interrupted by a signal in poll() or waitpid() + try: + retval = p.wait() + set_result((retval, data)) + break + except OSError, ex: + if ex.errno == errno.EINTR: + continue + raise ex + except Exception, ex: + set_result(ex) + + if args: + command = " ".join([command] + args) + + worker = threading.Thread(target = do_command, args = (command, username, password, )) + worker.setDaemon(True) + result_ready.acquire() + worker.start() + result_ready.wait(timeout) + try: + if result == [None]: + raise Exception, "command timed-out: '%s'" % command + finally: + result_ready.release() + result = result[0] + + if isinstance(result, Exception): + raise result + else: + (retval, data) = result + if os.WIFEXITED(retval) and os.WEXITSTATUS(retval) == 0: + return data + else: + out = "system command ('%s') " % command + if os.WIFEXITED(retval): + out += "failed, rc = %d" % os.WEXITSTATUS(retval) + else: + out += "killed by signal %d" % os.WTERMSIG(retval) + if data: + out += "; output follows:\n" + data + raise Exception, out + +def racadm_reboot(host, username, password, dryrun, state="powercycle"): + + ip = socket.gethostbyname(host) + try: + cmd = "/usr/sbin/racadm" + os.stat(cmd) + if not dryrun: + output = runcmd(cmd, ["-r %s -i serveraction %s" % (ip, state)], + username, password) + else: + output = runcmd(cmd, ["-r %s -i getsysinfo" % ip], + username, password) + + print "RUNCMD: %s" % output + return 0 + + except Exception, err: + #logger.debug("runcmd raised exception %s" % err) + print "runcmd raised exception %s" % err + return -1 + + +from optparse import OptionParser +parser = OptionParser() +parser.set_defaults(ip="", user="", password="", dryrun=False, state="powercycle") +parser.add_option("-d", "", dest="dryrun", action="store_true", + help="enable dryrun tests. no action is taken") +parser.add_option("-r", "", dest="ip", metavar="nodename.edu", + help="A single node name to add to the nodegroup") +parser.add_option("-u", "", dest="user", metavar="username", + help="") +parser.add_option("-s", "", dest="state", metavar="powercycle", + help="") +parser.add_option("-p", "", dest="password", metavar="password", + help="") +(options, args) = parser.parse_args() + +if __name__ == '__main__': + print options + if options.ip is not "" and \ + options.user is not "" and \ + options.password is not "": + + racadm_reboot(options.ip, options.user, options.password, options.dryrun, options.state) + else: + parser.print_help() diff --git a/pcucontrol/reboot.py b/pcucontrol/reboot.py new file mode 100755 index 0000000..d8fdb27 --- /dev/null +++ b/pcucontrol/reboot.py @@ -0,0 +1,478 @@ +#!/usr/bin/python +# +# Reboot specified nodes +# + +import getpass, getopt +import os, sys +import xml, xmlrpclib +import errno, time, traceback +import urllib2 +import urllib +import threading, popen2 +import array, struct +import base64 +from subprocess import PIPE, Popen +import pcucontrol.transports.ssh.pxssh as pxssh +import pcucontrol.transports.ssh.pexpect as pexpect +import socket + + + +# Use our versions of telnetlib and pyssh +sys.path.insert(0, os.path.dirname(sys.argv[0])) +import pcucontrol.transports.telnetlib as telnetlib +sys.path.insert(0, os.path.dirname(sys.argv[0]) + "/pyssh") +import pcucontrol.transports.pyssh as pyssh + +# Event class ID from pcu events +#NODE_POWER_CONTROL = 3 + +# Monitor user ID +#MONITOR_USER_ID = 11142 + +import logging +verbose = 1 +#dryrun = 0; + +class ExceptionNoTransport(Exception): pass +class ExceptionNotFound(Exception): pass +class ExceptionPassword(Exception): pass +class ExceptionTimeout(Exception): pass +class ExceptionPrompt(Exception): pass +class ExceptionSequence(Exception): pass +class ExceptionReset(Exception): pass +class ExceptionPort(Exception): pass +class ExceptionUsername(Exception): pass + + + +# PCU has model, host, preferred-port, user, passwd, + +# This is an object derived directly form the PLCAPI DB fields +class PCU(object): + def __init__(self, plc_pcu_dict): + for field in ['username', 'password', 'site_id', + 'hostname', 'ip', + 'pcu_id', 'model', + 'node_ids', 'ports', ]: + if field in plc_pcu_dict: + if type(u"") == type(plc_pcu_dict[field]): + # NOTE: if is a unicode string, convert it. + self.__setattr__(field, str(plc_pcu_dict[field])) + else: + self.__setattr__(field, plc_pcu_dict[field]) + else: + raise Exception("No such field %s in PCU object" % field) + +# These are the convenience functions build around the PCU object. +class PCUModel(PCU): + def __init__(self, plc_pcu_dict): + PCU.__init__(self, plc_pcu_dict) + self.host = self.pcu_name() + + def pcu_name(self): + if self.hostname is not None and self.hostname is not "": + return self.hostname + elif self.ip is not None and self.ip is not "": + return self.ip + else: + return None + + def nodeidToPort(self, node_id): + if node_id in self.node_ids: + for i in range(0, len(self.node_ids)): + if node_id == self.node_ids[i]: + return self.ports[i] + + raise Exception("No such Node ID: %d" % node_id) + +# This class captures the observed pcu records from FindBadPCUs.py +class PCURecord: + def __init__(self, pcu_record_dict): + for field in ['port_status', + 'dns_status', + 'entry_complete', ]: + if field in pcu_record_dict: + if field == "reboot": + self.__setattr__("reboot_str", pcu_record_dict[field]) + else: + self.__setattr__(field, pcu_record_dict[field]) + #else: + # raise Exception("No such field %s in pcu record dict" % field) + +class Transport: + TELNET = "telnet" + SSH = "ssh" + HTTP = "http" + HTTPS = "https" + IPAL = "ipal" + DRAC = "drac" + AMT = "amt" + + TELNET_TIMEOUT = 120 + + porttypemap = { + 5869 : DRAC, + 22 : SSH, + 23 : TELNET, + 443 : HTTPS, + 80 : HTTP, + 9100 : IPAL, + 16992 : AMT, + } + + def __init__(self, type, verbose): + self.type = type + self.verbose = verbose + self.transport = None + + def open(self, host, username=None, password=None, prompt="User Name"): + transport = None + + if self.type == self.TELNET: + transport = telnetlib.Telnet(host, timeout=self.TELNET_TIMEOUT) + transport.set_debuglevel(self.verbose) + if username is not None: + self.transport = transport + self.ifThenSend(prompt, username, ExceptionUsername) + + elif self.type == self.SSH: + if username is not None: + transport = pyssh.Ssh(username, host) + transport.set_debuglevel(self.verbose) + transport.open() + # TODO: have an ssh set_debuglevel() also... + else: + raise Exception("Username cannot be None for ssh transport.") + elif self.type == self.HTTP: + # NOTE: this does not work for all web-based services... + self.url = "http://%s:%d/" % (host,80) + uri = "%s:%d" % (host,80) + + # create authinfo + authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm() + authinfo.add_password (None, uri, username, password) + authhandler = urllib2.HTTPBasicAuthHandler( authinfo ) + + transport = urllib2.build_opener(authhandler) + else: + raise Exception("Unknown transport type: %s" % self.type) + + self.transport = transport + return True + + def close(self): + if self.type == self.TELNET: + self.transport.close() + elif self.type == self.SSH: + self.transport.close() + elif self.type == self.HTTP: + pass + else: + raise Exception("Unknown transport type %s" % self.type) + self.transport = None + + def write(self, msg): + return self.send(msg) + + def send(self, msg): + if self.transport == None: + raise ExceptionNoTransport("transport object is type None") + + return self.transport.write(msg) + + def sendPassword(self, password, prompt=None): + if self.type == self.TELNET: + if prompt == None: + self.ifThenSend("Password", password, ExceptionPassword) + else: + self.ifThenSend(prompt, password, ExceptionPassword) + elif self.type == self.SSH: + self.ifThenSend("password:", password, ExceptionPassword) + elif self.type == self.HTTP: + pass + else: + raise Exception("Unknown transport type: %s" % self.type) + + def sendHTTP(self, resource, data): + if self.verbose: + print "POSTing '%s' to %s" % (data,self.url + resource) + + try: + f = self.transport.open(self.url + resource ,data) + r = f.read() + if self.verbose: + print r + + except urllib2.URLError,err: + print 'Could not open http connection', err + return "http transport error" + + return 0 + + def ifThenSend(self, expected, buffer, ErrorClass=ExceptionPrompt): + + if self.transport != None: + output = self.transport.read_until(expected, self.TELNET_TIMEOUT) + if output.find(expected) == -1: + print "OUTPUT: --%s--" % output + raise ErrorClass, "'%s' not found" % expected + else: + self.transport.write(buffer + "\r\n") + else: + raise ExceptionNoTransport("transport object is type None") + + def ifElse(self, expected, ErrorClass): + try: + self.transport.read_until(expected, self.TELNET_TIMEOUT) + except: + raise ErrorClass("Could not find '%s' within timeout" % expected) + +class PCUControl(PCUModel,PCURecord): + + """ + There are three cases: + 1) the pcu_record passed below includes port_status from an + external probe. + 2) the external probe failed, and the values are empty + 3) this call is made independent of port_status. + + In the first case, the first open port is used. + In the third case, the ports are tried in sequence. + + In this way, the port_status value serves only as an optimization, + because closed ports are avoided. The supported_ports value should + order ports by their preferred usage. + """ + + supported_ports = [] + + def __init__(self, plc_pcu_record, verbose, ignored=None): + PCUModel.__init__(self, plc_pcu_record) + PCURecord.__init__(self, plc_pcu_record) + + def reboot(self, node_port, dryrun): + + port_list = [] + # There are two sources of potential ports. Those that are open and + # those that are part of the PCU's supported_ports. + # I think we should start with supported_ports and then filter that + # by the open ports. + + port_list = self.supported_ports + + if hasattr(self, 'port_status') and self.port_status: + # get out the open ports + port_list = filter(lambda x: self.port_status[x] == "open" , self.port_status.keys()) + port_list = [ int(x) for x in port_list ] + # take only the open ports that are supported_ports + port_list = filter(lambda x: x in self.supported_ports, port_list) + if port_list == []: + raise ExceptionPort("No Open Port: No transport from open ports") + + print port_list + + ret = "No implementation for open ports on selected PCU model" + for port in port_list: + if port not in Transport.porttypemap: + continue + + type = Transport.porttypemap[port] + self.transport = Transport(type, verbose) + + print "checking for run_%s" % type + if hasattr(self, "run_%s" % type): + print "found run_%s" % type + fxn = getattr(self, "run_%s" % type) + ret = self.catcherror(fxn, node_port, dryrun) + if ret == 0: # NOTE: success!, so stop + break + else: + continue + + return ret + + def run(self, node_port, dryrun): + """ This function is to be defined by the specific PCU instance. """ + raise Exception("This function is not implemented") + pass + + #def reboot(self, node_port, dryrun): + + def catcherror(self, function, node_port, dryrun): + try: + return function(node_port, dryrun) + except ExceptionNotFound, err: + return "error: " + str(err) + except ExceptionPassword, err: + return "Password exception: " + str(err) + except ExceptionTimeout, err: + return "Timeout exception: " + str(err) + except ExceptionUsername, err: + return "No username prompt: " + str(err) + except ExceptionSequence, err: + return "Sequence error: " + str(err) + except ExceptionPrompt, err: + return "Prompt exception: " + str(err) + except ExceptionNoTransport, err: + return "No Transport: " + str(err) + except ExceptionPort, err: + return "No ports exception: " + str(err) + except socket.error, err: + return "socket error: timeout: " + str(err) + except urllib2.HTTPError, err: + return "HTTPError: " + str(err) + except urllib2.URLError, err: + return "URLError: " + str(err) + except EOFError, err: + self.transport.close() + import traceback + traceback.print_exc() + return "EOF connection reset" + str(err) + except Exception, err: + #from monitor.common import email_exception + #email_exception(self.host) + raise Exception(err) + +from pcucontrol.util import command +from pcucontrol.models import * + +def pcu_name(pcu): + if pcu['hostname'] is not None and pcu['hostname'] is not "": + return pcu['hostname'] + elif pcu['ip'] is not None and pcu['ip'] is not "": + return pcu['ip'] + else: + return None + +class Unknown(PCUControl): + supported_ports = [22,23,80,443,5869,9100,16992] + +def model_to_object(modelname): + if modelname is None: + return ManualPCU + if "AMT" in modelname: + return IntelAMT + elif "BayTech" in modelname: + return BayTech + elif "HPiLO" in modelname: + return HPiLO + elif "IPAL" in modelname: + return IPAL + elif "APC" in modelname: + return APCControl + elif "DRAC" in modelname: + return DRAC + elif "WTI" in modelname: + return WTIIPS4 + elif "ePowerSwitch" in modelname: + return ePowerSwitchNew + elif "IPMI" in modelname: + return OpenIPMI + elif "BlackBoxPSMaverick" in modelname: + return BlackBoxPSMaverick + elif "PM211MIP" in modelname: + return PM211MIP + elif "ManualPCU" in modelname: + return ManualPCU + else: + print "UNKNOWN model %s"%modelname + return Unknown + +def reboot_api(node, pcu): + rb_ret = "" + + try: + modelname = pcu['model'] + if modelname: + # get object instance + instance = eval('%s(pcu, verbose)' % modelname) + # get pcu port + i = pcu['node_ids'].index(node['node_id']) + p = pcu['ports'][i] + # reboot + rb_ret = instance.reboot(p, False) + else: + rb_ret = "No modelname in PCU record." + # TODO: how to handle the weird, georgetown pcus, the drac faults, and ilo faults + except Exception, err: + rb_ret = "Exception Model(%s): " % modelname + rb_ret += str(err) + + return rb_ret + +def convert_oldmodelname_to_newmodelname(oldmodelname, pcu_id): + newmodelname = None + update = { 'AP79xx' : 'APCControl13p13', + 'Masterswitch' : 'APCControl13p13', + 'DS4-RPC' : 'BayTech', + 'IP-41x_IP-81x' : 'IPAL', + 'DRAC3' : 'DRAC', + 'DRAC4' : 'DRAC', + 'ePowerSwitch' : 'ePowerSwitchOld', + 'ilo2' : 'HPiLO', + 'ilo1' : 'HPiLO', + 'PM211-MIP' : 'PM211MIP', + 'AMT2.5' : 'IntelAMT', + 'AMT3.0' : 'IntelAMT', + 'WTI_IPS-4' : 'WTIIPS4', + 'unknown' : 'ManualPCU', + 'DRAC5' : 'DRAC', + 'ipmi' : 'OpenIPMI', + 'bbsemaverick' : 'BlackBoxPSMaverick', + 'manualadmin' : 'ManualPCU', + } + + if oldmodelname in update: + newmodelname = update[oldmodelname] + else: + newmodelname = oldmodelname + + if pcu_id in [1102,1163,1055,1111,1231,1113,1127,1128,1148]: + newmodelname = 'APCControl12p3' + elif pcu_id in [1110,86]: + newmodelname = 'APCControl1p4' + elif pcu_id in [1221,1225,1220,1192]: + newmodelname = 'APCControl121p3' + elif pcu_id in [1173,1240,47,1363,1405,1401,1372,1371]: + newmodelname = 'APCControl121p1' + elif pcu_id in [1056,1237,1052,1209,1002,1008,1013,1022]: + newmodelname = 'BayTechCtrlC' + elif pcu_id in [93]: + newmodelname = 'BayTechRPC3NC' + elif pcu_id in [1057]: + newmodelname = 'BayTechCtrlCUnibe' + elif pcu_id in [1012]: + newmodelname = 'BayTechRPC16' + elif pcu_id in [1089, 1071, 1046, 1035, 1118]: + newmodelname = 'ePowerSwitchNew' + + return newmodelname + +def reboot_test_new(nodename, values, verbose, dryrun): + rb_ret = "" + if 'plc_pcu_stats' in values: + values.update(values['plc_pcu_stats']) + + try: + #modelname = convert_oldmodelname_to_newmodelname(values['model'], values['pcu_id']) + modelname = values['model'] + if modelname: + object = eval('%s(values, verbose)' % modelname) + rb_ret = object.reboot(values[nodename], dryrun) + else: + rb_ret = "Not_Run" + # TODO: how to handle the weird, georgetown pcus, the drac faults, and ilo faults + except ExceptionPort, err: + rb_ret = str(err) + except NameError, err: + rb_ret = str(err) + + return rb_ret + +def main(): + print "this does not work." + +if __name__ == '__main__': + main() diff --git a/pcucontrol/transports/__init__.py b/pcucontrol/transports/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pcucontrol/transports/pyssh/.cvsignore b/pcucontrol/transports/pyssh/.cvsignore new file mode 100644 index 0000000..7b27c59 --- /dev/null +++ b/pcucontrol/transports/pyssh/.cvsignore @@ -0,0 +1 @@ +*.swp *.swo *.pyc *.log *.dat auth.py diff --git a/pcucontrol/transports/pyssh/__init__.py b/pcucontrol/transports/pyssh/__init__.py new file mode 100644 index 0000000..78bb951 --- /dev/null +++ b/pcucontrol/transports/pyssh/__init__.py @@ -0,0 +1,336 @@ +"""A SSH Interface class. + +An interface to ssh on posix systems, and plink (part of the Putty +suite) on Win32 systems. + +By Rasjid Wilcox. +Copyright (c) 2002. + +Version: 0.2 +Last modified 4 September 2002. + +Drawing on ideas from work by Julian Schaefer-Jasinski, Guido's telnetlib and +version 0.1 of pyssh (http://pyssh.sourceforge.net) by Chuck Esterbrook. + +Licenced under a Python 2.2 style license. See License.txt. +""" + +DEBUG_LEVEL = 1 + +import os, getpass +import signal # should cause all KeyboardInterrupts to go to the main thread + # try for Linux, does not seem to be try under Cygwin +import nbpipe +import time + +# Constants +SSH_PORT=806 +SSH_PATH='' + +CTRL_C=chr(3) + +READ_LAZY=0 +READ_SOME=1 +READ_ALL=2 +READ_UNTIL=3 + +# set the path to ssh / plink, and chose the popen2 funciton to use +if os.name=='posix': + import fssa # we can look for ssh-agent on posix + # XXX Can we on Win32/others? + import ptyext # if my patch gets accepted, change this to check for a + # sufficiently high version of python, and assign ptyext=pty + # if sufficient. + sshpopen2=ptyext.popen2 + CLOSE_STR='~.' + tp=os.popen('/usr/bin/which ssh') + SSH_PATH=tp.read().strip() + try: + tp.close() + except IOError: + # probably no child process + pass + if SSH_PATH == '': + tp=os.popen('command -v ssh') # works in bash, ash etc, not csh etc. + SSH_PATH=tp.read().strip() + tp.close() + if SSH_PATH == '': + check = ['/usr/bin/ssh', '/usr/local/bin/ssh', '/bin/ssh'] + for item in check: + if os.path.isfile(item): + SSH_PATH=item + break + PORT_STR='-p ' +else: + sshpopen2=os.popen2 + CLOSE_STR=CTRL_C # FIX-ME: This does not work. + # I think I need to implement a 'kill' component + # to the close function using win32api. + SSH_PATH='' + PORT_STR='-P ' + +class mysshError(Exception): + """Error class for myssh.""" + pass + +# Helper functions +def _prompt(prompt): + """Print the message as the prompt for input. + Return the text entered.""" + noecho = (prompt.lower().find('password:') >= 0) or \ + (prompt.lower().find('passphrase:') >=0) + print """User input required for ssh connection. + (Type Ctrl-C to abort connection.)""" + abort = 0 + try: + if noecho: + response = getpass.getpass(prompt) + else: + response = raw_input(prompt) + except KeyboardInterrupt: + response = '' + abort = 1 + return response, abort + +class Ssh: + """A SSH connection class.""" + def __init__(self, username=None, host='localhost', port=None): + """Constructor. This does not try to connect.""" + self.debuglevel = DEBUG_LEVEL + self.sshpath = SSH_PATH + self.username = username + self.host = host + self.port = port + self.isopen = 0 + self.sshpid = 0 # perhaps merge this with isopen + #self.old_handler = signal.getsignal(signal.SIGCHLD) + #sig_handler = signal.signal(signal.SIGCHLD, self.sig_handler) + + def __del__(self): + """Destructor -- close the connection.""" + if self.isopen: + self.close() + + def sig_handler(self, signum, stack): + """ Handle SIGCHLD signal """ + if signum == signal.SIGCHLD: + try: + os.waitpid(self.sshpid, 0) + except: + pass + if self.old_handler != signal.SIG_DFL: + self.old_handler(signum, stack) + + def attach_agent(self, key=None): + if os.name != 'posix': + # only posix support at this time + return + if 'SSH_AUTH_SOCK' not in os.environ.keys(): + fssa.fssa(key) + + def set_debuglevel(self, debuglevel): + """Set the debug level.""" + self.debuglevel = debuglevel + + def set_sshpath(self, sshpath): + """Set the ssh path.""" + self.sshpath=sshpath + + # Low level functions + def open(self, cmd=None): + """Opens a ssh connection. + + Raises an mysshError if myssh.sshpath is not a file. + Raises an error if attempting to open an already open connection. + """ + #self.attach_agent() + + if not os.path.isfile(self.sshpath): + raise mysshError, \ + "Path to ssh or plink is not defined or invalid.\nsshpath='%s'" \ + % self.sshpath + if self.isopen: + raise mysshError, "Connection already open." + sshargs = '' + if self.sshpath.lower().find('plink') != -1: + sshargs = '-ssh ' + if self.port and self.port != '': + sshargs += PORT_STR + self.port + ' ' + sshargs += " -o StrictHostKeyChecking=no -o PasswordAuthentication=yes -o PubkeyAuthentication=no " + if self.username and self.username !='': + sshargs += self.username + '@' + sshargs += self.host + if cmd: + sshargs += ' ' + cmd + if self.debuglevel: + print ">> Running %s %s." % (self.sshpath, sshargs) + # temporary workaround until I get pid's working under win32 + #print sshargs + if os.name == 'posix': + self.sshin, self.sshoutblocking, self.sshpid = \ + sshpopen2(self.sshpath + ' ' + sshargs) + else: + self.sshin, self.sshoutblocking = \ + sshpopen2(self.sshpath + ' ' + sshargs) + self.sshout = nbpipe.nbpipe(self.sshoutblocking) + self.isopen = 1 + if self.debuglevel: + print ">> ssh pid is %s." % self.sshpid + + def close(self, addnewline=1): + """Close the ssh connection by closing the input and output pipes. + Returns the closing messages. + + On Posix systems, by default it adds a newline before sending the + disconnect escape sequence. Turn this off by setting addnewline=0. + """ + if os.name == 'posix': + try: + if addnewline: + self.write('\n') + self.write(CLOSE_STR) + except (OSError, IOError, mysshError): + pass + output = self.read_lazy() + try: + self.sshin.close() + self.sshoutblocking.close() + except: + pass + if os.name == 'posix': + try: + os.kill(self.sshpid, signal.SIGHUP) + os.waitpid(self.sshpid, 0) + except: + pass + self.isopen = 0 + if self.debuglevel: + print ">> Connection closed." + return output + + def write(self, text): + """Send text to the ssh process.""" + # May block?? Probably not in practice, as ssh has a large input buffer. + if self.debuglevel: + print ">> Sending %s" % text + if self.isopen: + while len(text): + numtaken = os.write(self.sshin.fileno(),text) + if self.debuglevel: + print ">> %s characters taken" % numtaken + text = text[numtaken:] + else: + raise mysshError, "Attempted to write to closed connection." + + # There is a question about what to do with connections closed by the other + # end. Should write and read check for this, and force proper close? + def read_lazy(self): + """Lazy read from sshout. Waits a little, but does not block.""" + return self.sshout.read_lazy() + + def read_some(self): + """Always read at least one block, unless the connection is closed. + My block.""" + if self.isopen: + return self.sshout.read_some() + else: + return self.sshout.read_lazy() + + def read_until(self, match, timeout=None): + """Read until a given string is encountered or until timeout. + + When no match is found, return whatever is available instead, + possibly the empty string. Raise EOFError if the connection + is closed and no cooked data is available. + + """ + if self.isopen: + return self.sshout.read_until(match, timeout) + else: + return self.sshout.read_lazy() + + def read_all(self): + """Reads until end of file hit. May block.""" + if self.isopen: + return self.sshout.read_all() + else: + return self.sshout.read_lazy() + + # High level funcitons + def login(self, logintext='Last login:', prompt_callback=_prompt): + """Logs in to the ssh host. Checks for standard prompts, and calls + the function passed as promptcb to process them. + Returns the login banner, or 'None' if login process aborted. + """ + self.open() + banner = self.read_some() + if self.debuglevel: + print ">> 1st banner read is: %s" % banner + while banner.find(logintext) == -1: + response, abort = prompt_callback(banner) + if abort: + return self.close() + self.write(response + '\n') + banner = self.read_some() + return banner + + def logout(self): + """Logs out the session.""" + self.close() + + def sendcmd(self, cmd, readtype=READ_SOME, expected=None, timeout=None): + """Sends the command 'cmd' over the ssh connection, and returns the + result. By default it uses read_some, which may block. + """ + if cmd[-1] != '\n': + cmd += '\n' + self.write(cmd) + if readtype == READ_ALL: + return self.read_all() + elif readtype == READ_LAZY: + return self.read_lazy() + elif readtype == READ_UNTIL and expected is not None: + return self.read_until(expected, timeout) + else: + return self.read_some() + +def test(): + """Test routine for myssh. + + Usage: python myssh.py [-d] [-sshp path-to-ssh] [username@host | host] [port] + + Default host is localhost, default port is 22. + """ + import sys + debug = 0 + if sys.argv[1:] and sys.argv[1] == '-d': + debug = 1 + del sys.argv[1] + testsshpath = SSH_PATH + if sys.argv[1:] and sys.argv[1] == '-sshp': + testsshpath = sys.argv[2] + del sys.argv[1] + del sys.argv[1] + testusername = None + testhost = 'localhost' + testport = '22' + if sys.argv[1:]: + testhost = sys.argv[1] + if testhost.find('@') != -1: + testusername, testhost = testhost.split('@') + if sys.argv[2:]: + testport = sys.argv[2] + + testcon = Ssh(testusername, testhost, testport) + testcon.set_debuglevel(debug) + testcon.set_sshpath(testsshpath) + testcon.login() + + cmd = None + while (cmd != 'exit') and testcon.isopen: + cmd = raw_input("Enter command to send: ") + print testcon.sendcmd(cmd) + testcon.close() + +if __name__ == '__main__': + test() diff --git a/pcucontrol/transports/pyssh/fssa.py b/pcucontrol/transports/pyssh/fssa.py new file mode 100644 index 0000000..6ca17be --- /dev/null +++ b/pcucontrol/transports/pyssh/fssa.py @@ -0,0 +1,75 @@ +# vi:et:ts=4:tw=0 +""" fssa.py + + Search for an ssh-agent for the calling user and attach to it + if found. + + Tested on poxix only +""" +# This is a Python port of Steve Allen's fsa.sh script found +# at http://www.ucolick.org/~sla/ssh/sshcron.html +# Ported by Mark W. Alexander + +import os +if os.name == 'posix': + import pwd, stat, sys + from commands import getoutput + def fssa(key=None): + """ fssa(key=None) + + Searches /tmp/ssh-* owned by the calling user for ssh-agent + sockets. If key is provided, only sockets matching the key will be + considered. If key is not provided, the calling users username + will be used instead. + """ + user, pw, uid, gid, gecos, home, shell = pwd.getpwuid(os.getuid()) + if key is None: + key = user + + # Find /tmp/ssh-* dirs owned by this user + candidate_dirs=[] + for filename in os.listdir('/tmp'): + file_stat = os.stat("/tmp/%s" % (filename)) + if file_stat[stat.ST_UID] == os.getuid() \ + and stat.S_ISDIR(file_stat[stat.ST_MODE]) \ + and filename.find('ssh-') == 0: + candidate_dirs.append("/tmp/%s" % filename) + + candidate_sockets=[] + for d in candidate_dirs: + for f in os.listdir(d): + file_stat = os.stat("%s/%s" % (d, f)) + if file_stat[stat.ST_UID] == os.getuid() \ + and stat.S_ISSOCK(file_stat[stat.ST_MODE]) \ + and f.find('agent.') == 0: + candidate_sockets.append("%s/%s" % (d, f)) + alive = None + # order by pid, prefering sockets where the parent pid + # is gone. This gives preference to agents running in the + # background and reaped by init (maybe). Only works on + # systems with a /proc filesystem + if stat.S_ISDIR(os.stat("/proc")[stat.ST_MODE]): + reorder=[] + for s in candidate_sockets: + pid = s[s.find('.')+1:] + try: + stat.S_ISDIR(os.stat("/proc/%s" % pid)[stat.ST_MODE]) + reorder.append(s) + except: + reorder.insert(0,s) + candidate_sockets = reorder + + for s in candidate_sockets: + os.environ['SSH_AUTH_SOCK'] = s + try: + pubkey = getoutput("ssh-add -l 2>/dev/null") + except: + continue + if pubkey.find(key): + alive = 1 + break + os.environ.pop('SSH_AUTH_SOCK') + if alive: + return pubkey + else: + return None diff --git a/pcucontrol/transports/pyssh/nbpipe.py b/pcucontrol/transports/pyssh/nbpipe.py new file mode 100644 index 0000000..08b4f97 --- /dev/null +++ b/pcucontrol/transports/pyssh/nbpipe.py @@ -0,0 +1,111 @@ +"""Implements a non-blocking pipe class.""" + +# Since it uses thread rather than select, it is portable to at least +# posix and windows environments. + +# Author: Rasjid Wilcox, copyright (c) 2002 +# Ideas taken from the Python 2.2 telnetlib.py library. +# +# Last modified: 3 August 2002 +# Licence: Python 2.2 Style License. See license.txt. + +# TO DO: +# * Handle excpetions better, particularly Keyboard Interupts. +# * Possibly do a threadless version for posix environments +# where we can use select (is probably more efficient). +# * A test function. + +import Queue +import thread +import os +import time +import types + +#INT_TYPE = type(1) +MIN_TIMEOUT = 0.01 + +class nbpipe: + def __init__(self, readfile, pipesize=0, blocksize=1024): + """Initialise a non-blocking pipe object, given a real file or file-descriptor. + pipesize = the size (in blocks) of the queue used to buffer the blocks read + blocksize = the maximum block size for a raw read.""" + if type(readfile) == types.IntType: + self.fd = readfile + else: + self.fd = readfile.fileno() + self.pipesize = pipesize + self.blocksize = blocksize + self.eof = 0 + self._q = Queue.Queue(self.pipesize) + self.data = '' + thread.start_new_thread(self._readtoq, ()) + def _readtoq(self): + finish = 0 + while (1): + try: + item = os.read(self.fd, self.blocksize) + except (IOError, OSError): + finish = 1 + if (item == '') or finish: + # Wait until everything has been read from the queue before + # setting eof = 1 and exiting. + while not self._q.empty(): + time.sleep(MIN_TIMEOUT) + self.eof = 1 + thread.exit() + else: + self._q.put(item) + def has_data(self): + return self.data + def eof(self): + return self.eof + def read_lazy(self): + """Process and return data that's already in the queues (lazy). + + Return '' if no data available. Don't block. + + """ + while not self._q.empty(): + self.data += self._q.get() + data = self.data + self.data = '' + return data + def read_some(self, until_eof=False): + """Read at least one byte of cooked data unless EOF is hit. + + Return '' if EOF is hit. Block if no data is immediately + available. + + """ + data = '' + while (until_eof or not data) and not self.eof: + data += self.read_lazy() + time.sleep(MIN_TIMEOUT) + return data + def read_until(self, match, timeout=None): + """Read until a given string is encountered or until timeout. + + If no match is found or EOF is hit, return whatever is + available instead, possibly the empty string. + """ + if timeout is not None: + timeout = timeout / MIN_TIMEOUT + else: + timeout = 1 + n = len(match) + data = self.read_lazy() + i = 0 + while timeout >= 0 and not self.eof: + i = data.find(match, i) + if i >= 0: + i += n + self.data = data[i:] + return data[:i] + time.sleep(MIN_TIMEOUT) + timeout -= 1 + i = max(0, len(data) - n) + data += self.read_lazy() + return data + def read_all(self): + """Read until the EOF. May block.""" + return read_some(until_eof=True) diff --git a/pcucontrol/transports/pyssh/ptyext.py b/pcucontrol/transports/pyssh/ptyext.py new file mode 100644 index 0000000..b22835b --- /dev/null +++ b/pcucontrol/transports/pyssh/ptyext.py @@ -0,0 +1,209 @@ +"""Pseudo terminal utilities.""" + +# Bugs: No signal handling. Doesn't set slave termios and window size. +# Only tested on Linux. +# See: W. Richard Stevens. 1992. Advanced Programming in the +# UNIX Environment. Chapter 19. +# Author: Steen Lumholt -- with additions by Guido. + +from select import select, error +import os + +# Absurd: import termios and then delete it. This is to force an attempt +# to import pty to raise an ImportError on platforms that lack termios. +# Without this explicit import of termios here, some other module may +# import tty first, which in turn imports termios and dies with an +# ImportError then. But since tty *does* exist across platforms, that +# leaves a damaged module object for tty in sys.modules, and the import +# of tty here then appears to work despite that the tty imported is junk. +import termios +del termios + +import tty + +__all__ = ["openpty","fork","spawn","th_spawn","popen2"] + +STDIN_FILENO = 0 +STDOUT_FILENO = 1 +STDERR_FILENO = 2 + +CHILD = 0 + +def openpty(): + """openpty() -> (master_fd, slave_fd) + Open a pty master/slave pair, using os.openpty() if possible.""" + + try: + return os.openpty() + except (AttributeError, OSError): + pass + master_fd, slave_name = _open_terminal() + slave_fd = slave_open(slave_name) + return master_fd, slave_fd + +def master_open(): + """master_open() -> (master_fd, slave_name) + Open a pty master and return the fd, and the filename of the slave end. + Deprecated, use openpty() instead.""" + + try: + master_fd, slave_fd = os.openpty() + except (AttributeError, OSError): + pass + else: + slave_name = os.ttyname(slave_fd) + os.close(slave_fd) + return master_fd, slave_name + + return _open_terminal() + +def _open_terminal(): + """Open pty master and return (master_fd, tty_name). + SGI and generic BSD version, for when openpty() fails.""" + try: + import sgi + except ImportError: + pass + else: + try: + tty_name, master_fd = sgi._getpty(os.O_RDWR, 0666, 0) + except IOError, msg: + raise os.error, msg + return master_fd, tty_name + for x in 'pqrstuvwxyzPQRST': + for y in '0123456789abcdef': + pty_name = '/dev/pty' + x + y + try: + fd = os.open(pty_name, os.O_RDWR) + except os.error: + continue + return (fd, '/dev/tty' + x + y) + raise os.error, 'out of pty devices' + +def slave_open(tty_name): + """slave_open(tty_name) -> slave_fd + Open the pty slave and acquire the controlling terminal, returning + opened filedescriptor. + Deprecated, use openpty() instead.""" + + return os.open(tty_name, os.O_RDWR) + +def fork(): + """fork() -> (pid, master_fd) + Fork and make the child a session leader with a controlling terminal.""" + + try: + pid, fd = os.forkpty() + except (AttributeError, OSError): + pass + else: + if pid == CHILD: + try: + os.setsid() + except OSError: + # os.forkpty() already set us session leader + pass + return pid, fd + + master_fd, slave_fd = openpty() + pid = os.fork() + if pid == CHILD: + # Establish a new session. + os.setsid() + os.close(master_fd) + + # Slave becomes stdin/stdout/stderr of child. + os.dup2(slave_fd, STDIN_FILENO) + os.dup2(slave_fd, STDOUT_FILENO) + os.dup2(slave_fd, STDERR_FILENO) + if (slave_fd > STDERR_FILENO): + os.close (slave_fd) + + # Parent and child process. + return pid, master_fd + +def _writen(fd, data): + """Write all the data to a descriptor.""" + while data != '': + n = os.write(fd, data) + data = data[n:] + +def _read(fd): + """Default read function.""" + return os.read(fd, 1024) + +def _copy(master_fd, master_read=_read, stdin_read=_read, stdin_fd=STDIN_FILENO, + stdout_fd=STDOUT_FILENO): + """Parent copy loop. + Copies + pty master -> stdout_fd (master_read) + stdin_fd -> pty master (stdin_read)""" + try: + mode = tty.tcgetattr(stdin_fd) + tty.setraw(stdin_fd) + restore = 1 + except tty.error: # This is the same as termios.error + restore = 0 + try: + while 1: + rfds, wfds, xfds = select( + [master_fd, stdin_fd], [], []) + if master_fd in rfds: + data = master_read(master_fd) + os.write(stdout_fd, data) + if stdin_fd in rfds: + data = stdin_read(stdin_fd) + _writen(master_fd, data) + except (IOError, OSError, error): # The last entry is select.error + if restore: + tty.tcsetattr(stdin_fd, tty.TCSAFLUSH, mode) + if stdin_fd > STDERR_FILENO: + os.close(stdin_fd) + if stdout_fd > STDERR_FILENO: + os.close(stdout_fd) + +def spawn(argv, master_read=_read, stdin_read=_read, stdin_fd=STDIN_FILENO, + stdout_fd=STDOUT_FILENO): + """Create a spawned process. The controlling terminal reads and + writes its data to stdin_fd and stdout_fd respectively. + + NOTE: This function does not return until one of the input or output file + descriptors are closed, or the child process exits.""" + if type(argv) == type(''): + argv = (argv,) + pid, master_fd = fork() + if pid == CHILD: + apply(os.execlp, (argv[0],) + argv) + _copy(master_fd, master_read, stdin_read, stdin_fd, stdout_fd) + +def th_spawn(argv, master_read=_read, stdin_read=_read, stdin_fd=STDIN_FILENO, + stdout_fd=STDOUT_FILENO): + """Create a spawned process. The controlling terminal reads and + writes its data to stdin_fd and stdout_fd respectively. The function + returns the pid of the spawned process. (It returns immediately.)""" + import thread + if type(argv) == type(''): + argv = (argv,) + pid, master_fd = fork() + if pid == CHILD: + apply(os.execlp, (argv[0],) + argv) + thread.start_new_thread(_copy, (master_fd, master_read, stdin_read, \ + stdin_fd, stdout_fd)) + return pid + +def popen2(cmd, bufsize=1024, master_read=_read, stdin_read=_read): + """Execute the shell command 'cmd' in a sub-process. + + If 'bufsize' is specified, it sets the buffer size for the I/O pipes. + The function returns (child_stdin, child_stdout, child_pid), where the + file objects are pipes connected to the spawned process's controling + terminal, and the child_pid is the pid of the child process. + """ + argv = ('/bin/sh', '-c', cmd) + child_stdin_rfd, child_stdin_wfd = os.pipe() + child_stdout_rfd, child_stdout_wfd = os.pipe() + child_pid = th_spawn(argv, master_read, stdin_read, child_stdin_rfd, \ + child_stdout_wfd) + child_stdin = os.fdopen(child_stdin_wfd, 'w', bufsize) + child_stdout = os.fdopen(child_stdout_rfd, 'r', bufsize) + return child_stdin, child_stdout, child_pid diff --git a/pcucontrol/transports/ssh/LICENSE b/pcucontrol/transports/ssh/LICENSE new file mode 100644 index 0000000..27bb809 --- /dev/null +++ b/pcucontrol/transports/ssh/LICENSE @@ -0,0 +1,21 @@ +Free, open source, and all that good stuff. +Pexpect Copyright (c) 2006 Noah Spurrier + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/pcucontrol/transports/ssh/__init__.py b/pcucontrol/transports/ssh/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pcucontrol/transports/ssh/fdpexpect.py b/pcucontrol/transports/ssh/fdpexpect.py new file mode 100644 index 0000000..4f10c5f --- /dev/null +++ b/pcucontrol/transports/ssh/fdpexpect.py @@ -0,0 +1,73 @@ +""" +TODO: This is BETA. When it gets stable I will move it into the pexpect.py file. +""" + +from pexpect import * +import os + +__all__ = ['fdspawn'] + +class fdspawn (spawn): + """This is like pexpect.spawn but allows you to supply your own, + already open file descriptor. For example, you could use it to + read through a file looking for patterns, or to control a modem or + serial device. + """ + def __init__ (self, fd, args=[], timeout=30, maxread=2000, searchwindowsize=None, logfile=None): + """This takes a file descriptor (an int) or an object that support the fileno() method + (returning an int). All Python file-like objects support fileno(). + """ + ### TODO: Add better handling of trying to use fdspawn in place of spawn + ### TODO: (overload to allow fdspawn to also handle commands as spawn does. + + if type(fd) != type(0) and hasattr(fd, 'fileno'): + fd = fd.fileno() + + if type(fd) != type(0): + raise ExceptionPexpect ('The fd argument is not an int. If this is a command string then maybe you want to use pexpect.spawn.') + + try: # make sure fd is a valid file descriptor + os.fstat(fd) + except OSError: + raise ExceptionPexpect, 'The fd argument is not a valid file descriptor.' + + self.args = None + self.command = None + spawn.__init__(self, None, args, timeout, maxread, searchwindowsize, logfile) + self.child_fd = fd + self.own_fd = False + self.closed = False + self.name = '' % fd + + def __del__ (self): + return + + def close (self): + if super(fdspawn, self).child_fd == -1: + return + if self.own_fd: + super(fdspawn, self).close (self) + else: + self.flush() + os.close(super(fdspawn, self).child_fd) + self.child_fd = -1 + self.closed = True + + def isalive (self): + """This checks if the file descriptor is still valid. + If os.fstat() does not raise an exception then we assume it is alive. + """ + if self.child_fd == -1: + return False + try: + os.fstat(self.child_fd) + return True + except: + return False + + def terminate (self, force=False): + raise ExceptionPexpect ('This method is not valid for file descriptors.') + + def kill (self, sig): + return + diff --git a/pcucontrol/transports/ssh/pexpect.py b/pcucontrol/transports/ssh/pexpect.py new file mode 100644 index 0000000..4eab532 --- /dev/null +++ b/pcucontrol/transports/ssh/pexpect.py @@ -0,0 +1,1397 @@ +"""Pexpect is a Python module for spawning child applications and controlling +them automatically. Pexpect can be used for automating interactive applications +such as ssh, ftp, passwd, telnet, etc. It can be used to a automate setup +scripts for duplicating software package installations on different servers. It +can be used for automated software testing. Pexpect is in the spirit of Don +Libes' Expect, but Pexpect is pure Python. Other Expect-like modules for Python +require TCL and Expect or require C extensions to be compiled. Pexpect does not +use C, Expect, or TCL extensions. It should work on any platform that supports +the standard Python pty module. The Pexpect interface focuses on ease of use so +that simple tasks are easy. + +There are two main interfaces to Pexpect -- the function, run() and the class, +spawn. You can call the run() function to execute a command and return the +output. This is a handy replacement for os.system(). + +For example: + pexpect.run('ls -la') + +The more powerful interface is the spawn class. You can use this to spawn an +external child command and then interact with the child by sending lines and +expecting responses. + +For example: + child = pexpect.spawn('scp foo myname@host.example.com:.') + child.expect ('Password:') + child.sendline (mypassword) + +This works even for commands that ask for passwords or other input outside of +the normal stdio streams. + +Credits: +Noah Spurrier, Richard Holden, Marco Molteni, Kimberley Burchett, Robert Stone, +Hartmut Goebel, Chad Schroeder, Erick Tryzelaar, Dave Kirby, Ids vander Molen, +George Todd, Noel Taylor, Nicolas D. Cesar, Alexander Gattin, +Geoffrey Marshall, Francisco Lourenco, Glen Mabey, Karthik Gurusamy, +Fernando Perez +(Let me know if I forgot anyone.) + +Free, open source, and all that good stuff. + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +Pexpect Copyright (c) 2006 Noah Spurrier +http://pexpect.sourceforge.net/ + +$Revision: 395 $ +$Date: 2006-05-31 20:07:18 -0700 (Wed, 31 May 2006) $ +""" +try: + import os, sys, time + import select + import string + import re + import struct + import resource + import types + import pty + import tty + import termios + import fcntl + import errno + import traceback + import signal +except ImportError, e: + raise ImportError (str(e) + """ +A critical module was not found. Probably this operating system does not support it. +Pexpect is intended for UNIX-like operating systems.""") + +__version__ = '2.1' +__revision__ = '$Revision: 395 $' +__all__ = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'run', 'which', 'split_command_line', + '__version__', '__revision__'] + +# Exception classes used by this module. +class ExceptionPexpect(Exception): + """Base class for all exceptions raised by this module. + """ + def __init__(self, value): + self.value = value + def __str__(self): + return str(self.value) + def get_trace(self): + """This returns an abbreviated stack trace with lines that only concern the caller. + In other words, the stack trace inside the Pexpect module is not included. + """ + tblist = traceback.extract_tb(sys.exc_info()[2]) + tblist = filter(self.__filter_not_pexpect, tblist) + tblist = traceback.format_list(tblist) + return ''.join(tblist) + def __filter_not_pexpect(self, trace_list_item): + if trace_list_item[0].find('pexpect.py') == -1: + return True + else: + return False +class EOF(ExceptionPexpect): + """Raised when EOF is read from a child. + """ +class TIMEOUT(ExceptionPexpect): + """Raised when a read time exceeds the timeout. + """ +##class TIMEOUT_PATTERN(TIMEOUT): +## """Raised when the pattern match time exceeds the timeout. +## This is different than a read TIMEOUT because the child process may +## give output, thus never give a TIMEOUT, but the output +## may never match a pattern. +## """ +##class MAXBUFFER(ExceptionPexpect): +## """Raised when a scan buffer fills before matching an expected pattern.""" + +def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None, logfile=None): + """This function runs the given command; waits for it to finish; + then returns all output as a string. STDERR is included in output. + If the full path to the command is not given then the path is searched. + + Note that lines are terminated by CR/LF (\\r\\n) combination + even on UNIX-like systems because this is the standard for pseudo ttys. + If you set withexitstatus to true, then run will return a tuple of + (command_output, exitstatus). If withexitstatus is false then this + returns just command_output. + + The run() function can often be used instead of creating a spawn instance. + For example, the following code uses spawn: + from pexpect import * + child = spawn('scp foo myname@host.example.com:.') + child.expect ('(?i)password') + child.sendline (mypassword) + The previous code can be replace with the following, which you may + or may not find simpler: + from pexpect import * + run ('scp foo myname@host.example.com:.', events={'(?i)password': mypassword}) + + Examples: + Start the apache daemon on the local machine: + from pexpect import * + run ("/usr/local/apache/bin/apachectl start") + Check in a file using SVN: + from pexpect import * + run ("svn ci -m 'automatic commit' my_file.py") + Run a command and capture exit status: + from pexpect import * + (command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1) + + Tricky Examples: + The following will run SSH and execute 'ls -l' on the remote machine. + The password 'secret' will be sent if the '(?i)password' pattern is ever seen. + run ("ssh username@machine.example.com 'ls -l'", events={'(?i)password':'secret\n'}) + + This will start mencoder to rip a video from DVD. This will also display + progress ticks every 5 seconds as it runs. + from pexpect import * + def print_ticks(d): + print d['event_count'], + run ("mencoder dvd://1 -o video.avi -oac copy -ovc copy", events={TIMEOUT:print_ticks}, timeout=5) + + The 'events' argument should be a dictionary of patterns and responses. + Whenever one of the patterns is seen in the command out + run() will send the associated response string. Note that you should + put newlines in your string if Enter is necessary. + The responses may also contain callback functions. + Any callback is function that takes a dictionary as an argument. + The dictionary contains all the locals from the run() function, so + you can access the child spawn object or any other variable defined + in run() (event_count, child, and extra_args are the most useful). + A callback may return True to stop the current run process otherwise + run() continues until the next event. + A callback may also return a string which will be sent to the child. + 'extra_args' is not used by directly run(). It provides a way to pass data to + a callback function through run() through the locals dictionary passed to a callback. + """ + if timeout == -1: + child = spawn(command, maxread=2000, logfile=logfile) + else: + child = spawn(command, timeout=timeout, maxread=2000, logfile=logfile) + if events is not None: + patterns = events.keys() + responses = events.values() + else: + patterns=None # We assume that EOF or TIMEOUT will save us. + responses=None + child_result_list = [] + event_count = 0 + while 1: + try: + index = child.expect (patterns) + if type(child.after) is types.StringType: + child_result_list.append(child.before + child.after) + else: # child.after may have been a TIMEOUT or EOF, so don't cat those. + child_result_list.append(child.before) + if type(responses[index]) is types.StringType: + child.send(responses[index]) + elif type(responses[index]) is types.FunctionType: + callback_result = responses[index](locals()) + sys.stdout.flush() + if type(callback_result) is types.StringType: + child.send(callback_result) + elif callback_result: + break + else: + raise TypeError ('The callback must be a string or function type.') + event_count = event_count + 1 + except TIMEOUT, e: + child_result_list.append(child.before) + break + except EOF, e: + child_result_list.append(child.before) + break + child_result = ''.join(child_result_list) + if withexitstatus: + child.close() + return (child_result, child.exitstatus) + else: + return child_result + +class spawn (object): + """This is the main class interface for Pexpect. + Use this class to start and control child applications. + """ + + def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None, logfile=None, env=None): + """This is the constructor. The command parameter may be a string + that includes a command and any arguments to the command. For example: + p = pexpect.spawn ('/usr/bin/ftp') + p = pexpect.spawn ('/usr/bin/ssh user@example.com') + p = pexpect.spawn ('ls -latr /tmp') + You may also construct it with a list of arguments like so: + p = pexpect.spawn ('/usr/bin/ftp', []) + p = pexpect.spawn ('/usr/bin/ssh', ['user@example.com']) + p = pexpect.spawn ('ls', ['-latr', '/tmp']) + After this the child application will be created and + will be ready to talk to. For normal use, see expect() and + send() and sendline(). + + The maxread attribute sets the read buffer size. + This is maximum number of bytes that Pexpect will try to read + from a TTY at one time. + Seeting the maxread size to 1 will turn off buffering. + Setting the maxread value higher may help performance in cases + where large amounts of output are read back from the child. + This feature is useful in conjunction with searchwindowsize. + + The searchwindowsize attribute sets the how far back in + the incomming seach buffer Pexpect will search for pattern matches. + Every time Pexpect reads some data from the child it will append the data to + the incomming buffer. The default is to search from the beginning of the + imcomming buffer each time new data is read from the child. + But this is very inefficient if you are running a command that + generates a large amount of data where you want to match + The searchwindowsize does not effect the size of the incomming data buffer. + You will still have access to the full buffer after expect() returns. + + The logfile member turns on or off logging. + All input and output will be copied to the given file object. + Set logfile to None to stop logging. This is the default. + Set logfile to sys.stdout to echo everything to standard output. + The logfile is flushed after each write. + Example 1: + child = pexpect.spawn('some_command') + fout = file('mylog.txt','w') + child.logfile = fout + Example 2: + child = pexpect.spawn('some_command') + child.logfile = sys.stdout + + The delaybeforesend helps overcome a weird behavior that many users were experiencing. + The typical problem was that a user would expect() a "Password:" prompt and + then immediately call sendline() to send the password. The user would then + see that their password was echoed back to them. Passwords don't + normally echo. The problem is caused by the fact that most applications + print out the "Password" prompt and then turn off stdin echo, but if you + send your password before the application turned off echo, then you get + your password echoed. Normally this wouldn't be a problem when interacting + with a human at a real heyboard. If you introduce a slight delay just before + writing then this seems to clear up the problem. This was such a common problem + for many users that I decided that the default pexpect behavior + should be to sleep just before writing to the child application. + 1/10th of a second (100 ms) seems to be enough to clear up the problem. + You can set delaybeforesend to 0 to return to the old behavior. + + Note that spawn is clever about finding commands on your path. + It uses the same logic that "which" uses to find executables. + + If you wish to get the exit status of the child you must call + the close() method. The exit or signal status of the child will be + stored in self.exitstatus or self.signalstatus. + If the child exited normally then exitstatus will store the exit return code and + signalstatus will be None. + If the child was terminated abnormally with a signal then signalstatus will store + the signal value and exitstatus will be None. + If you need more detail you can also read the self.status member which stores + the status returned by os.waitpid. You can interpret this using + os.WIFEXITED/os.WEXITSTATUS or os.WIFSIGNALED/os.TERMSIG. + """ + self.STDIN_FILENO = pty.STDIN_FILENO + self.STDOUT_FILENO = pty.STDOUT_FILENO + self.STDERR_FILENO = pty.STDERR_FILENO + self.stdin = sys.stdin + self.stdout = sys.stdout + self.stderr = sys.stderr + + self.patterns = None + self.ignorecase = False + self.before = None + self.after = None + self.match = None + self.match_index = None + self.terminated = True + self.exitstatus = None + self.signalstatus = None + self.status = None # status returned by os.waitpid + self.flag_eof = False + self.pid = None + self.child_fd = -1 # initially closed + self.timeout = timeout + self.delimiter = EOF + self.logfile = logfile + self.maxread = maxread # Max bytes to read at one time into buffer. + self.buffer = '' # This is the read buffer. See maxread. + self.searchwindowsize = searchwindowsize # Anything before searchwindowsize point is preserved, but not searched. + self.delaybeforesend = 0.1 # Sets sleep time used just before sending data to child. + self.delayafterclose = 0.1 # Sets delay in close() method to allow kernel time to update process status. + self.delayafterterminate = 0.1 # Sets delay in terminate() method to allow kernel time to update process status. + self.softspace = False # File-like object. + self.name = '<' + repr(self) + '>' # File-like object. + self.encoding = None # File-like object. + self.closed = True # File-like object. + self.env = env + self.__irix_hack = sys.platform.lower().find('irix') >= 0 # This flags if we are running on irix + self.use_native_pty_fork = not (sys.platform.lower().find('solaris') >= 0) # Solaris uses internal __fork_pty(). All other use pty.fork(). + self.allstr = "" + + # allow dummy instances for subclasses that may not use command or args. + if command is None: + self.command = None + self.args = None + self.name = '' + return + + # If command is an int type then it may represent a file descriptor. + if type(command) == type(0): + raise ExceptionPexpect ('Command is an int type. If this is a file descriptor then maybe you want to use fdpexpect.fdspawn which takes an existing file descriptor instead of a command string.') + + if type (args) != type([]): + raise TypeError ('The argument, args, must be a list.') + + if args == []: + self.args = split_command_line(command) + self.command = self.args[0] + else: + self.args = args[:] # work with a copy + self.args.insert (0, command) + self.command = command + + command_with_path = which(self.command) + if command_with_path is None: + raise ExceptionPexpect ('The command was not found or was not executable: %s.' % self.command) + self.command = command_with_path + self.args[0] = self.command + + self.name = '<' + ' '.join (self.args) + '>' + self.__spawn() + + def __del__(self): + """This makes sure that no system resources are left open. + Python only garbage collects Python objects. OS file descriptors + are not Python objects, so they must be handled explicitly. + If the child file descriptor was opened outside of this class + (passed to the constructor) then this does not close it. + """ + if not self.closed: + self.close() + + def __str__(self): + """This returns the current state of the pexpect object as a string. + """ + s = [] + s.append(repr(self)) + s.append('version: ' + __version__ + ' (' + __revision__ + ')') + s.append('command: ' + str(self.command)) + s.append('args: ' + str(self.args)) + if self.patterns is None: + s.append('patterns: None') + else: + s.append('patterns:') + for p in self.patterns: + if type(p) is type(re.compile('')): + s.append(' ' + str(p.pattern)) + else: + s.append(' ' + str(p)) + s.append('buffer (last 100 chars): ' + str(self.buffer)[-100:]) + s.append('before (last 100 chars): ' + str(self.before)[-100:]) + s.append('after: ' + str(self.after)) + s.append('match: ' + str(self.match)) + s.append('match_index: ' + str(self.match_index)) + s.append('exitstatus: ' + str(self.exitstatus)) + s.append('flag_eof: ' + str(self.flag_eof)) + s.append('pid: ' + str(self.pid)) + s.append('child_fd: ' + str(self.child_fd)) + s.append('closed: ' + str(self.closed)) + s.append('timeout: ' + str(self.timeout)) + s.append('delimiter: ' + str(self.delimiter)) + s.append('logfile: ' + str(self.logfile)) + s.append('maxread: ' + str(self.maxread)) + s.append('ignorecase: ' + str(self.ignorecase)) + s.append('searchwindowsize: ' + str(self.searchwindowsize)) + s.append('delaybeforesend: ' + str(self.delaybeforesend)) + s.append('delayafterclose: ' + str(self.delayafterclose)) + s.append('delayafterterminate: ' + str(self.delayafterterminate)) + return '\n'.join(s) + + def __spawn(self): + """This starts the given command in a child process. + This does all the fork/exec type of stuff for a pty. + This is called by __init__. + """ + # The pid and child_fd of this object get set by this method. + # Note that it is difficult for this method to fail. + # You cannot detect if the child process cannot start. + # So the only way you can tell if the child process started + # or not is to try to read from the file descriptor. If you get + # EOF immediately then it means that the child is already dead. + # That may not necessarily be bad because you may haved spawned a child + # that performs some task; creates no stdout output; and then dies. + + assert self.pid is None, 'The pid member should be None.' + assert self.command is not None, 'The command member should not be None.' + + if self.use_native_pty_fork: + try: + self.pid, self.child_fd = pty.fork() + except OSError, e: + raise ExceptionPexpect('Error! pty.fork() failed: ' + str(e)) + else: # Use internal __fork_pty + self.pid, self.child_fd = self.__fork_pty() + + if self.pid == 0: # Child + try: + self.child_fd = sys.stdout.fileno() # used by setwinsize() + self.setwinsize(24, 80) + except: + # Some platforms do not like setwinsize (Cygwin). + # This will cause problem when running applications that + # are very picky about window size. + # This is a serious limitation, but not a show stopper. + pass + # Do not allow child to inherit open file descriptors from parent. + max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[0] + for i in range (3, max_fd): + try: + os.close (i) + except OSError: + pass + + # I don't know why this works, but ignoring SIGHUP fixes a + # problem when trying to start a Java daemon with sudo + # (specifically, Tomcat). + signal.signal(signal.SIGHUP, signal.SIG_IGN) + + if self.env is None: + os.execv(self.command, self.args) + else: + os.execvpe(self.command, self.args, self.env) + + # Parent + self.terminated = False + self.closed = False + + def __fork_pty(self): + """This implements a substitute for the forkpty system call. + This should be more portable than the pty.fork() function. + Specifically, this should work on Solaris. + + Modified 10.06.05 by Geoff Marshall: + Implemented __fork_pty() method to resolve the issue with Python's + pty.fork() not supporting Solaris, particularly ssh. + Based on patch to posixmodule.c authored by Noah Spurrier: + http://mail.python.org/pipermail/python-dev/2003-May/035281.html + """ + parent_fd, child_fd = os.openpty() + if parent_fd < 0 or child_fd < 0: + raise ExceptionPexpect, "Error! Could not open pty with os.openpty()." + + pid = os.fork() + if pid < 0: + raise ExceptionPexpect, "Error! Failed os.fork()." + elif pid == 0: + # Child. + os.close(parent_fd) + self.__pty_make_controlling_tty(child_fd) + + os.dup2(child_fd, 0) + os.dup2(child_fd, 1) + os.dup2(child_fd, 2) + + if child_fd > 2: + os.close(child_fd) + else: + # Parent. + os.close(child_fd) + + return pid, parent_fd + + def __pty_make_controlling_tty(self, tty_fd): + """This makes the pseudo-terminal the controlling tty. + This should be more portable than the pty.fork() function. + Specifically, this should work on Solaris. + """ + child_name = os.ttyname(tty_fd) + + # Disconnect from controlling tty if still connected. + fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY); + if fd >= 0: + os.close(fd) + + os.setsid() + + # Verify we are disconnected from controlling tty + try: + fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY); + if fd >= 0: + os.close(fd) + raise ExceptionPexpect, "Error! We are not disconnected from a controlling tty." + except: + # Good! We are disconnected from a controlling tty. + pass + + # Verify we can open child pty. + fd = os.open(child_name, os.O_RDWR); + if fd < 0: + raise ExceptionPexpect, "Error! Could not open child pty, " + child_name + else: + os.close(fd) + + # Verify we now have a controlling tty. + fd = os.open("/dev/tty", os.O_WRONLY) + if fd < 0: + raise ExceptionPexpect, "Error! Could not open controlling tty, /dev/tty" + else: + os.close(fd) + + def fileno (self): # File-like object. + """This returns the file descriptor of the pty for the child. + """ + return self.child_fd + + def close (self, force=True): # File-like object. + """This closes the connection with the child application. + Note that calling close() more than once is valid. + This emulates standard Python behavior with files. + Set force to True if you want to make sure that the child is terminated + (SIGKILL is sent if the child ignores SIGHUP and SIGINT). + """ + if not self.closed: + self.flush() + os.close (self.child_fd) + self.child_fd = -1 + self.closed = True + time.sleep(self.delayafterclose) # Give kernel time to update process status. + if self.isalive(): + if not self.terminate(force): + raise ExceptionPexpect ('close() could not terminate the child using terminate()') + + def flush (self): # File-like object. + """This does nothing. It is here to support the interface for a File-like object. + """ + pass + + def isatty (self): # File-like object. + """This returns True if the file descriptor is open and connected to a tty(-like) device, else False. + """ + return os.isatty(self.child_fd) + + def setecho (self, state): + """This sets the terminal echo mode on or off. + Note that anything the child sent before the echo will be lost, so + you should be sure that your input buffer is empty before you setecho. + For example, the following will work as expected. + p = pexpect.spawn('cat') + p.sendline ('1234') # We will see this twice (once from tty echo and again from cat). + p.expect (['1234']) + p.expect (['1234']) + p.setecho(False) # Turn off tty echo + p.sendline ('abcd') # We will set this only once (echoed by cat). + p.sendline ('wxyz') # We will set this only once (echoed by cat) + p.expect (['abcd']) + p.expect (['wxyz']) + The following WILL NOT WORK because the lines sent before the setecho + will be lost: + p = pexpect.spawn('cat') + p.sendline ('1234') # We will see this twice (once from tty echo and again from cat). + p.setecho(False) # Turn off tty echo + p.sendline ('abcd') # We will set this only once (echoed by cat). + p.sendline ('wxyz') # We will set this only once (echoed by cat) + p.expect (['1234']) + p.expect (['1234']) + p.expect (['abcd']) + p.expect (['wxyz']) + """ + self.child_fd + new = termios.tcgetattr(self.child_fd) + if state: + new[3] = new[3] | termios.ECHO + else: + new[3] = new[3] & ~termios.ECHO + # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent + # and blocked on some platforms. TCSADRAIN is probably ideal if it worked. + termios.tcsetattr(self.child_fd, termios.TCSANOW, new) + + def read_nonblocking (self, size = 1, timeout = -1): + """This reads at most size characters from the child application. + It includes a timeout. If the read does not complete within the + timeout period then a TIMEOUT exception is raised. + If the end of file is read then an EOF exception will be raised. + If a log file was set using setlog() then all data will + also be written to the log file. + + If timeout==None then the read may block indefinitely. + If timeout==-1 then the self.timeout value is used. + If timeout==0 then the child is polled and + if there was no data immediately ready then this will raise a TIMEOUT exception. + + The "timeout" refers only to the amount of time to read at least one character. + This is not effected by the 'size' parameter, so if you call + read_nonblocking(size=100, timeout=30) and only one character is + available right away then one character will be returned immediately. + It will not wait for 30 seconds for another 99 characters to come in. + + This is a wrapper around os.read(). + It uses select.select() to implement a timeout. + """ + if self.closed: + raise ValueError ('I/O operation on closed file in read_nonblocking().') + + if timeout == -1: + timeout = self.timeout + + # Note that some systems such as Solaris do not give an EOF when + # the child dies. In fact, you can still try to read + # from the child_fd -- it will block forever or until TIMEOUT. + # For this case, I test isalive() before doing any reading. + # If isalive() is false, then I pretend that this is the same as EOF. + if not self.isalive(): + r,w,e = self.__select([self.child_fd], [], [], 0) # timeout of 0 means "poll" + if not r: + self.flag_eof = True + raise EOF ('End Of File (EOF) in read_nonblocking(). Braindead platform.') + elif self.__irix_hack: + # This is a hack for Irix. It seems that Irix requires a long delay before checking isalive. + # This adds a 2 second delay, but only when the child is terminated. + r, w, e = self.__select([self.child_fd], [], [], 2) + if not r and not self.isalive(): + self.flag_eof = True + raise EOF ('End Of File (EOF) in read_nonblocking(). Pokey platform.') + + r,w,e = self.__select([self.child_fd], [], [], timeout) + + if not r: + if not self.isalive(): + # Some platforms, such as Irix, will claim that their processes are alive; + # then timeout on the select; and then finally admit that they are not alive. + self.flag_eof = True + raise EOF ('End of File (EOF) in read_nonblocking(). Very pokey platform.') + else: + raise TIMEOUT ('Timeout exceeded in read_nonblocking().') + + if self.child_fd in r: + try: + s = os.read(self.child_fd, size) + except OSError, e: # Linux does this + self.flag_eof = True + raise EOF ('End Of File (EOF) in read_nonblocking(). Exception style platform.') + if s == '': # BSD style + self.flag_eof = True + raise EOF ('End Of File (EOF) in read_nonblocking(). Empty string style platform.') + + if self.logfile is not None: + self.logfile.write (s) + self.logfile.flush() + + return s + + raise ExceptionPexpect ('Reached an unexpected state in read_nonblocking().') + + def read (self, size = -1): # File-like object. + """This reads at most "size" bytes from the file + (less if the read hits EOF before obtaining size bytes). + If the size argument is negative or omitted, + read all data until EOF is reached. + The bytes are returned as a string object. + An empty string is returned when EOF is encountered immediately. + """ + if size == 0: + return '' + if size < 0: + self.expect (self.delimiter) # delimiter default is EOF + return self.before + + # I could have done this more directly by not using expect(), but + # I deliberately decided to couple read() to expect() so that + # I would catch any bugs early and ensure consistant behavior. + # It's a little less efficient, but there is less for me to + # worry about if I have to later modify read() or expect(). + # Note, it's OK if size==-1 in the regex. That just means it + # will never match anything in which case we stop only on EOF. + cre = re.compile('.{%d}' % size, re.DOTALL) + index = self.expect ([cre, self.delimiter]) # delimiter default is EOF + if index == 0: + return self.after ### self.before should be ''. Should I assert this? + return self.before + + def readline (self, size = -1): # File-like object. + """This reads and returns one entire line. A trailing newline is kept in + the string, but may be absent when a file ends with an incomplete line. + Note: This readline() looks for a \\r\\n pair even on UNIX because + this is what the pseudo tty device returns. So contrary to what you + may expect you will receive the newline as \\r\\n. + An empty string is returned when EOF is hit immediately. + Currently, the size agument is mostly ignored, so this behavior is not + standard for a file-like object. If size is 0 then an empty string + is returned. + """ + if size == 0: + return '' + index = self.expect (['\r\n', self.delimiter]) # delimiter default is EOF + if index == 0: + return self.before + '\r\n' + else: + return self.before + + def __iter__ (self): # File-like object. + """This is to support iterators over a file-like object. + """ + return self + + def next (self): # File-like object. + """This is to support iterators over a file-like object. + """ + result = self.readline() + if result == "": + raise StopIteration + return result + + def readlines (self, sizehint = -1): # File-like object. + """This reads until EOF using readline() and returns a list containing + the lines thus read. The optional "sizehint" argument is ignored. + """ + lines = [] + while True: + line = self.readline() + if not line: + break + lines.append(line) + return lines + + def write(self, str): # File-like object. + """This is similar to send() except that there is no return value. + """ + self.send (str) + + def writelines (self, sequence): # File-like object. + """This calls write() for each element in the sequence. + The sequence can be any iterable object producing strings, + typically a list of strings. This does not add line separators + There is no return value. + """ + for str in sequence: + self.write (str) + + def send(self, str): + """This sends a string to the child process. + This returns the number of bytes written. + If a log file was set then the data is also written to the log. + """ + time.sleep(self.delaybeforesend) + if self.logfile is not None: + self.logfile.write (str) + self.logfile.flush() + c = os.write(self.child_fd, str) + return c + + def sendline(self, str=''): + """This is like send(), but it adds a line feed (os.linesep). + This returns the number of bytes written. + """ + n = self.send(str) + n = n + self.send (os.linesep) + return n + + def sendeof(self): + """This sends an EOF to the child. + This sends a character which causes the pending parent output + buffer to be sent to the waiting child program without + waiting for end-of-line. If it is the first character of the + line, the read() in the user program returns 0, which + signifies end-of-file. This means to work as expected + a sendeof() has to be called at the begining of a line. + This method does not send a newline. It is the responsibility + of the caller to ensure the eof is sent at the beginning of a line. + """ + ### Hmmm... how do I send an EOF? + ###C if ((m = write(pty, *buf, p - *buf)) < 0) + ###C return (errno == EWOULDBLOCK) ? n : -1; + fd = sys.stdin.fileno() + old = termios.tcgetattr(fd) # remember current state + new = termios.tcgetattr(fd) + new[3] = new[3] | termios.ICANON # ICANON must be set to recognize EOF + try: # use try/finally to ensure state gets restored + termios.tcsetattr(fd, termios.TCSADRAIN, new) + if 'CEOF' in dir(termios): + os.write (self.child_fd, '%c' % termios.CEOF) + else: + os.write (self.child_fd, '%c' % 4) # Silly platform does not define CEOF so assume CTRL-D + finally: # restore state + termios.tcsetattr(fd, termios.TCSADRAIN, old) + + def eof (self): + """This returns True if the EOF exception was ever raised. + """ + return self.flag_eof + + def terminate(self, force=False): + """This forces a child process to terminate. + It starts nicely with SIGHUP and SIGINT. If "force" is True then + moves onto SIGKILL. + This returns True if the child was terminated. + This returns False if the child could not be terminated. + """ + if not self.isalive(): + return True + self.kill(signal.SIGHUP) + time.sleep(self.delayafterterminate) + if not self.isalive(): + return True + self.kill(signal.SIGCONT) + time.sleep(self.delayafterterminate) + if not self.isalive(): + return True + self.kill(signal.SIGINT) + time.sleep(self.delayafterterminate) + if not self.isalive(): + return True + if force: + self.kill(signal.SIGKILL) + time.sleep(self.delayafterterminate) + if not self.isalive(): + return True + else: + return False + return False + #raise ExceptionPexpect ('terminate() could not terminate child process. Try terminate(force=True)?') + + def wait(self): + """This waits until the child exits. This is a blocking call. + This will not read any data from the child, so this will block forever + if the child has unread output and has terminated. In other words, the child + may have printed output then called exit(); but, technically, the child is + still alive until its output is read. + """ + if self.isalive(): + pid, status = os.waitpid(self.pid, 0) + else: + raise ExceptionPexpect ('Cannot wait for dead child process.') + self.exitstatus = os.WEXITSTATUS(status) + if os.WIFEXITED (status): + self.status = status + self.exitstatus = os.WEXITSTATUS(status) + self.signalstatus = None + self.terminated = True + elif os.WIFSIGNALED (status): + self.status = status + self.exitstatus = None + self.signalstatus = os.WTERMSIG(status) + self.terminated = True + elif os.WIFSTOPPED (status): + raise ExceptionPexpect ('Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?') + return self.exitstatus + + def isalive(self): + """This tests if the child process is running or not. + This is non-blocking. If the child was terminated then this + will read the exitstatus or signalstatus of the child. + This returns True if the child process appears to be running or False if not. + It can take literally SECONDS for Solaris to return the right status. + """ + if self.terminated: + return False + + if self.flag_eof: + # This is for Linux, which requires the blocking form of waitpid to get + # status of a defunct process. This is super-lame. The flag_eof would have + # been set in read_nonblocking(), so this should be safe. + waitpid_options = 0 + else: + waitpid_options = os.WNOHANG + + try: + pid, status = os.waitpid(self.pid, waitpid_options) + except OSError, e: # No child processes + if e[0] == errno.ECHILD: + raise ExceptionPexpect ('isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?') + else: + raise e + + # I have to do this twice for Solaris. I can't even believe that I figured this out... + # If waitpid() returns 0 it means that no child process wishes to + # report, and the value of status is undefined. + if pid == 0: + try: + pid, status = os.waitpid(self.pid, waitpid_options) ### os.WNOHANG) # Solaris! + except OSError, e: # This should never happen... + if e[0] == errno.ECHILD: + raise ExceptionPexpect ('isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?') + else: + raise e + + # If pid is still 0 after two calls to waitpid() then + # the process really is alive. This seems to work on all platforms, except + # for Irix which seems to require a blocking call on waitpid or select, so I let read_nonblocking + # take care of this situation (unfortunately, this requires waiting through the timeout). + if pid == 0: + return True + + if pid == 0: + return True + + if os.WIFEXITED (status): + self.status = status + self.exitstatus = os.WEXITSTATUS(status) + self.signalstatus = None + self.terminated = True + elif os.WIFSIGNALED (status): + self.status = status + self.exitstatus = None + self.signalstatus = os.WTERMSIG(status) + self.terminated = True + elif os.WIFSTOPPED (status): + raise ExceptionPexpect ('isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?') + return False + + def kill(self, sig): + """This sends the given signal to the child application. + In keeping with UNIX tradition it has a misleading name. + It does not necessarily kill the child unless + you send the right signal. + """ + # Same as os.kill, but the pid is given for you. + if self.isalive(): + os.kill(self.pid, sig) + + def compile_pattern_list(self, patterns): + """This compiles a pattern-string or a list of pattern-strings. + Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or + a list of those. Patterns may also be None which results in + an empty list. + + This is used by expect() when calling expect_list(). + Thus expect() is nothing more than:: + cpl = self.compile_pattern_list(pl) + return self.expect_list(clp, timeout) + + If you are using expect() within a loop it may be more + efficient to compile the patterns first and then call expect_list(). + This avoid calls in a loop to compile_pattern_list(): + cpl = self.compile_pattern_list(my_pattern) + while some_condition: + ... + i = self.expect_list(clp, timeout) + ... + """ + if patterns is None: + return [] + if type(patterns) is not types.ListType: + patterns = [patterns] + + compile_flags = re.DOTALL # Allow dot to match \n + if self.ignorecase: + compile_flags = compile_flags | re.IGNORECASE + compiled_pattern_list = [] + for p in patterns: + if type(p) is types.StringType: + compiled_pattern_list.append(re.compile(p, compile_flags)) + elif p is EOF: + compiled_pattern_list.append(EOF) + elif p is TIMEOUT: + compiled_pattern_list.append(TIMEOUT) + elif type(p) is type(re.compile('')): + compiled_pattern_list.append(p) + else: + raise TypeError ('Argument must be one of StringType, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str(type(p))) + + return compiled_pattern_list + + def expect(self, pattern, timeout = -1, searchwindowsize=None): + + """This seeks through the stream until a pattern is matched. + The pattern is overloaded and may take several types including a list. + The pattern can be a StringType, EOF, a compiled re, or a list of + those types. Strings will be compiled to re types. This returns the + index into the pattern list. If the pattern was not a list this + returns index 0 on a successful match. This may raise exceptions for + EOF or TIMEOUT. To avoid the EOF or TIMEOUT exceptions add + EOF or TIMEOUT to the pattern list. + + After a match is found the instance attributes + 'before', 'after' and 'match' will be set. + You can see all the data read before the match in 'before'. + You can see the data that was matched in 'after'. + The re.MatchObject used in the re match will be in 'match'. + If an error occured then 'before' will be set to all the + data read so far and 'after' and 'match' will be None. + + If timeout is -1 then timeout will be set to the self.timeout value. + + Note: A list entry may be EOF or TIMEOUT instead of a string. + This will catch these exceptions and return the index + of the list entry instead of raising the exception. + The attribute 'after' will be set to the exception type. + The attribute 'match' will be None. + This allows you to write code like this: + index = p.expect (['good', 'bad', pexpect.EOF, pexpect.TIMEOUT]) + if index == 0: + do_something() + elif index == 1: + do_something_else() + elif index == 2: + do_some_other_thing() + elif index == 3: + do_something_completely_different() + instead of code like this: + try: + index = p.expect (['good', 'bad']) + if index == 0: + do_something() + elif index == 1: + do_something_else() + except EOF: + do_some_other_thing() + except TIMEOUT: + do_something_completely_different() + These two forms are equivalent. It all depends on what you want. + You can also just expect the EOF if you are waiting for all output + of a child to finish. For example: + p = pexpect.spawn('/bin/ls') + p.expect (pexpect.EOF) + print p.before + + If you are trying to optimize for speed then see expect_list(). + """ + compiled_pattern_list = self.compile_pattern_list(pattern) + return self.expect_list(compiled_pattern_list, timeout, searchwindowsize) + + def expect_list(self, pattern_list, timeout = -1, searchwindowsize = -1): + """This takes a list of compiled regular expressions and returns + the index into the pattern_list that matched the child output. + The list may also contain EOF or TIMEOUT (which are not + compiled regular expressions). This method is similar to + the expect() method except that expect_list() does not + recompile the pattern list on every call. + This may help if you are trying to optimize for speed, otherwise + just use the expect() method. This is called by expect(). + If timeout==-1 then the self.timeout value is used. + If searchwindowsize==-1 then the self.searchwindowsize value is used. + """ + + self.patterns = pattern_list + + if timeout == -1: + timeout = self.timeout + if timeout is not None: + end_time = time.time() + timeout + if searchwindowsize == -1: + searchwindowsize = self.searchwindowsize + + try: + incoming = self.buffer + while True: # Keep reading until exception or return. + # Sequence through the list of patterns looking for a match. + first_match = -1 + for cre in pattern_list: + if cre is EOF or cre is TIMEOUT: + continue # The patterns for PexpectExceptions are handled differently. + if searchwindowsize is None: # search everything + match = cre.search(incoming) + else: + startpos = max(0, len(incoming) - searchwindowsize) + match = cre.search(incoming, startpos) + if match is None: + continue + if first_match > match.start() or first_match == -1: + first_match = match.start() + self.match = match + self.match_index = pattern_list.index(cre) + if first_match > -1: + self.buffer = incoming[self.match.end() : ] + self.before = incoming[ : self.match.start()] + self.after = incoming[self.match.start() : self.match.end()] + #print "MATCH--", self.after, "--EOM" + return self.match_index + # No match at this point + if timeout < 0 and timeout is not None: + raise TIMEOUT ('Timeout exceeded in expect_list().') + # Still have time left, so read more data + c = self.read_nonblocking (self.maxread, timeout) + time.sleep (0.0001) + incoming = incoming + c + self.allstr += c + #print "INCOMING--", c, "--EOI" + if timeout is not None: + timeout = end_time - time.time() + except EOF, e: + self.buffer = '' + self.before = incoming + self.after = EOF + if EOF in pattern_list: + self.match = EOF + self.match_index = pattern_list.index(EOF) + return self.match_index + else: + self.match = None + self.match_index = None + raise EOF (str(e) + '\n' + str(self)) + except TIMEOUT, e: + self.before = incoming + self.after = TIMEOUT + if TIMEOUT in pattern_list: + self.match = TIMEOUT + self.match_index = pattern_list.index(TIMEOUT) + return self.match_index + else: + self.match = None + self.match_index = None + raise TIMEOUT (str(e) + '\n' + str(self)) + except Exception: + self.before = incoming + self.after = None + self.match = None + self.match_index = None + raise + + def getwinsize(self): + """This returns the terminal window size of the child tty. + The return value is a tuple of (rows, cols). + """ + if 'TIOCGWINSZ' in dir(termios): + TIOCGWINSZ = termios.TIOCGWINSZ + else: + TIOCGWINSZ = 1074295912L # assume if not defined + s = struct.pack('HHHH', 0, 0, 0, 0) + x = fcntl.ioctl(self.fileno(), TIOCGWINSZ, s) + return struct.unpack('HHHH', x)[0:2] + + def setwinsize(self, r, c): + """This sets the terminal window size of the child tty. + This will cause a SIGWINCH signal to be sent to the child. + This does not change the physical window size. + It changes the size reported to TTY-aware applications like + vi or curses -- applications that respond to the SIGWINCH signal. + """ + # Check for buggy platforms. Some Python versions on some platforms + # (notably OSF1 Alpha and RedHat 7.1) truncate the value for + # termios.TIOCSWINSZ. It is not clear why this happens. + # These platforms don't seem to handle the signed int very well; + # yet other platforms like OpenBSD have a large negative value for + # TIOCSWINSZ and they don't have a truncate problem. + # Newer versions of Linux have totally different values for TIOCSWINSZ. + # Note that this fix is a hack. + if 'TIOCSWINSZ' in dir(termios): + TIOCSWINSZ = termios.TIOCSWINSZ + else: + TIOCSWINSZ = -2146929561 + if TIOCSWINSZ == 2148037735L: # L is not required in Python >= 2.2. + TIOCSWINSZ = -2146929561 # Same bits, but with sign. + # Note, assume ws_xpixel and ws_ypixel are zero. + s = struct.pack('HHHH', r, c, 0, 0) + fcntl.ioctl(self.fileno(), TIOCSWINSZ, s) + + def interact(self, escape_character = chr(29), input_filter = None, output_filter = None): + """This gives control of the child process to the interactive user + (the human at the keyboard). + Keystrokes are sent to the child process, and the stdout and stderr + output of the child process is printed. + This simply echos the child stdout and child stderr to the real + stdout and it echos the real stdin to the child stdin. + When the user types the escape_character this method will stop. + The default for escape_character is ^]. This should not be confused + with ASCII 27 -- the ESC character. ASCII 29 was chosen + for historical merit because this is the character used + by 'telnet' as the escape character. The escape_character will + not be sent to the child process. + + You may pass in optional input and output filter functions. + These functions should take a string and return a string. + The output_filter will be passed all the output from the child process. + The input_filter will be passed all the keyboard input from the user. + The input_filter is run BEFORE the check for the escape_character. + + Note that if you change the window size of the parent + the SIGWINCH signal will not be passed through to the child. + If you want the child window size to change when the parent's + window size changes then do something like the following example: + import pexpect, struct, fcntl, termios, signal, sys + def sigwinch_passthrough (sig, data): + s = struct.pack("HHHH", 0, 0, 0, 0) + a = struct.unpack('hhhh', fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ , s)) + global p + p.setwinsize(a[0],a[1]) + p = pexpect.spawn('/bin/bash') # Note this is global and used in sigwinch_passthrough. + signal.signal(signal.SIGWINCH, sigwinch_passthrough) + p.interact() + """ + # Flush the buffer. + self.stdout.write (self.buffer) + self.stdout.flush() + self.buffer = '' + mode = tty.tcgetattr(self.STDIN_FILENO) + tty.setraw(self.STDIN_FILENO) + try: + self.__interact_copy(escape_character, input_filter, output_filter) + finally: + tty.tcsetattr(self.STDIN_FILENO, tty.TCSAFLUSH, mode) + + def __interact_writen(self, fd, data): + """This is used by the interact() method. + """ + while data != '' and self.isalive(): + n = os.write(fd, data) + data = data[n:] + def __interact_read(self, fd): + """This is used by the interact() method. + """ + return os.read(fd, 1000) + def __interact_copy(self, escape_character = None, input_filter = None, output_filter = None): + """This is used by the interact() method. + """ + while self.isalive(): + r,w,e = self.__select([self.child_fd, self.STDIN_FILENO], [], []) + if self.child_fd in r: + data = self.__interact_read(self.child_fd) + if output_filter: data = output_filter(data) + if self.logfile is not None: + self.logfile.write (data) + self.logfile.flush() + os.write(self.STDOUT_FILENO, data) + if self.STDIN_FILENO in r: + data = self.__interact_read(self.STDIN_FILENO) + if input_filter: data = input_filter(data) + i = data.rfind(escape_character) + if i != -1: + data = data[:i] + self.__interact_writen(self.child_fd, data) + break + self.__interact_writen(self.child_fd, data) + def __select (self, iwtd, owtd, ewtd, timeout=None): + """This is a wrapper around select.select() that ignores signals. + If select.select raises a select.error exception and errno is an EINTR error then + it is ignored. Mainly this is used to ignore sigwinch (terminal resize). + """ + # if select() is interrupted by a signal (errno==EINTR) then + # we loop back and enter the select() again. + if timeout is not None: + end_time = time.time() + timeout + while True: + try: + return select.select (iwtd, owtd, ewtd, timeout) + except select.error, e: + if e[0] == errno.EINTR: + # if we loop back we have to subtract the amount of time we already waited. + if timeout is not None: + timeout = end_time - time.time() + if timeout < 0: + return ([],[],[]) + else: # something else caused the select.error, so this really is an exception + raise + +############################################################################## +# The following methods are no longer supported or allowed.. + def setmaxread (self, maxread): + """This method is no longer supported or allowed. + I don't like getters and setters without a good reason. + """ + raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the maxread member variable.') + def expect_exact (self, pattern_list, timeout = -1): + """This method is no longer supported or allowed. + It was too hard to maintain and keep it up to date with expect_list. + Few people used this method. Most people favored reliability over speed. + The implementation is left in comments in case anyone needs to hack this + feature back into their copy. + If someone wants to diff this with expect_list and make them work + nearly the same then I will consider adding this make in. + """ + raise ExceptionPexpect ('This method is no longer supported or allowed.') + def setlog (self, fileobject): + """This method is no longer supported or allowed. + """ + raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the logfile member variable.') + +############################################################################## +# End of spawn class +############################################################################## + +def which (filename): + """This takes a given filename; tries to find it in the environment path; + then checks if it is executable. + This returns the full path to the filename if found and executable. + Otherwise this returns None. + """ + # Special case where filename already contains a path. + if os.path.dirname(filename) != '': + if os.access (filename, os.X_OK): + return filename + + if not os.environ.has_key('PATH') or os.environ['PATH'] == '': + p = os.defpath + else: + p = os.environ['PATH'] + + # Oddly enough this was the one line that made Pexpect + # incompatible with Python 1.5.2. + #pathlist = p.split (os.pathsep) + pathlist = string.split (p, os.pathsep) + + for path in pathlist: + f = os.path.join(path, filename) + if os.access(f, os.X_OK): + return f + return None + +def split_command_line(command_line): + """This splits a command line into a list of arguments. + It splits arguments on spaces, but handles + embedded quotes, doublequotes, and escaped characters. + It's impossible to do this with a regular expression, so + I wrote a little state machine to parse the command line. + """ + arg_list = [] + arg = '' + + # Constants to name the states we can be in. + state_basic = 0 + state_esc = 1 + state_singlequote = 2 + state_doublequote = 3 + state_whitespace = 4 # The state of consuming whitespace between commands. + state = state_basic + + for c in command_line: + if state == state_basic or state == state_whitespace: + if c == '\\': # Escape the next character + state = state_esc + elif c == r"'": # Handle single quote + state = state_singlequote + elif c == r'"': # Handle double quote + state = state_doublequote + elif c.isspace(): + # Add arg to arg_list if we aren't in the middle of whitespace. + if state == state_whitespace: + None # Do nothing. + else: + arg_list.append(arg) + arg = '' + state = state_whitespace + else: + arg = arg + c + state = state_basic + elif state == state_esc: + arg = arg + c + state = state_basic + elif state == state_singlequote: + if c == r"'": + state = state_basic + else: + arg = arg + c + elif state == state_doublequote: + if c == r'"': + state = state_basic + else: + arg = arg + c + + if arg != '': + arg_list.append(arg) + return arg_list + diff --git a/pcucontrol/transports/ssh/pxssh.py b/pcucontrol/transports/ssh/pxssh.py new file mode 100644 index 0000000..c73079b --- /dev/null +++ b/pcucontrol/transports/ssh/pxssh.py @@ -0,0 +1,137 @@ +from pexpect import * +#import os, sys, getopt, shutil + +class pxssh (spawn): + """This class extends pexpect.spawn to specialize setting up SSH connections. + This adds methods for login, logout, and expecting the prompt. + It does various hacky things to handle any situation in the SSH login process. + For example, if the session is your first login, then it automatically + accepts the certificate; or if you have public key authentication setup + and you don't need a password then this is OK too. + + Example usage that runs 'ls -l' on server and prints the result: + import pxssh + s = pxssh.pxssh() + if not s.login ('localhost', 'myusername', 'mypassword'): + print "SSH session failed on login." + print str(s) + else: + print "SSH session login successful" + s.sendline ('ls -l') + s.prompt() # match the prompt + print s.before # print everything before the prompt. + s.logout() + """ + + def __init__ (self): + # SUBTLE HACK ALERT! + # Note that the command to set the prompt uses a slightly different string + # than the regular expression to match it. This is because when you set the + # prompt the command will echo back, but we don't want to match the echoed + # command. So if we make the set command slightly different than the regex + # we eliminate the problem. To make the set command different we add a + # backslash in front of $. The $ doesn't need to be escaped, but it doesn't + # hurt and serves to make the set command different than the regex. + self.PROMPT = "\[PEXPECT\][\$\#] " # used to match the command-line prompt. + # used to set shell command-line prompt to something more unique. + self.PROMPT_SET_SH = "PS1='[PEXPECT]\$ '" + self.PROMPT_SET_CSH = "set prompt='[PEXPECT]\$ '" + + ### TODO: This is getting messy and I'm pretty sure this isn't perfect. + ### TODO: I need to draw a better flow chart for this. + def login (self,server,username,password='',ssh_options="",terminal_type='ansi',original_prompts=r"][#$]|~[#$]|-bash.*?[#$]|[#$] ",login_timeout=10): + """This logs the user into the given server. By default the prompt is + rather optimistic and should be considered more of an example. It's + better to try to match the prompt as exactly as possible to prevent + any false matches by server strings such as a "Message Of The Day" or + something. The closer you can make the original_prompt match your real prompt + then the better. A timeout will not necessarily cause the login to fail. + In the case of a timeout we assume that the prompt was so weird that + we could not match it. We still try to reset the prompt to something + more unique. If that still fails then we return False. + """ + cmd = "ssh %s -l %s %s" % (ssh_options, username, server) + print cmd + spawn.__init__(self, cmd, timeout=login_timeout) + #, "(?i)no route to host"]) + i = self.expect(["(?i)are you sure you want to continue connecting", original_prompts, "(?i)password", "(?i)permission denied", "(?i)terminal type", TIMEOUT, "(?i)connection closed by remote host"]) + if i==0: # New certificate -- always accept it. This is what you if SSH does not have the remote host's public key stored in the cache. + self.sendline("yes") + i = self.expect(["(?i)are you sure you want to continue connecting", original_prompts, "(?i)password", "(?i)permission denied", "(?i)terminal type", TIMEOUT]) + if i==2: # password + self.sendline(password) + i = self.expect(["(?i)are you sure you want to continue connecting", original_prompts, "(?i)password", "(?i)permission denied", "(?i)terminal type", TIMEOUT]) + if i==4: + self.sendline(terminal_type) + i = self.expect(["(?i)are you sure you want to continue connecting", original_prompts, "(?i)password", "(?i)permission denied", "(?i)terminal type", TIMEOUT]) + + if i==0: + # This is weird. This should not happen twice in a row. + self.close() + return False + elif i==1: # can occur if you have a public key pair set to authenticate. + ### TODO: May NOT be OK if expect() matched a false prompt. + pass + elif i==2: # password prompt again + # For incorrect passwords, some ssh servers will + # ask for the password again, others return 'denied' right away. + # If we get the password prompt again then this means + # we didn't get the password right the first time. + self.close() + return False + elif i==3: # permission denied -- password was bad. + self.close() + return False + elif i==4: # terminal type again? WTF? + self.close() + return False + elif i==5: # Timeout + # This is tricky... presume that we are at the command-line prompt. + # It may be that the prompt was so weird that we couldn't match it. + pass + elif i==6: # Connection closed by remote host + self.close() + return False + else: # Unexpected + self.close() + return False + # We appear to be in -- reset prompt to something more unique. + #if not self.set_unique_prompt(): + # print "couldn't reset prompt" + # self.close() + # return False + return True + + def logout (self): + """This sends exit. If there are stopped jobs then this sends exit twice. + """ + self.sendline("exit") + index = self.expect([EOF, "(?i)there are stopped jobs"]) + if index==1: + self.sendline("exit") + self.expect(EOF) + + def prompt (self, timeout=20): + """This expects the prompt. This returns True if the prompt was matched. + This returns False if there was a timeout. + """ + i = self.expect([self.PROMPT, TIMEOUT], timeout=timeout) + if i==1: + return False + return True + + def set_unique_prompt (self, optional_prompt=None): + """This attempts to reset the shell prompt to something more unique. + This makes it easier to match unambiguously. + """ + if optional_prompt is not None: + self.prompt = optional_prompt + self.sendline (self.PROMPT_SET_SH) # sh-style + i = self.expect ([TIMEOUT, self.PROMPT], timeout=10) + if i == 0: # csh-style + self.sendline (self.PROMPT_SET_CSH) + i = self.expect ([TIMEOUT, self.PROMPT], timeout=10) + if i == 0: + return 0 + return 1 + diff --git a/pcucontrol/transports/telnetlib.py b/pcucontrol/transports/telnetlib.py new file mode 100644 index 0000000..cfa96c9 --- /dev/null +++ b/pcucontrol/transports/telnetlib.py @@ -0,0 +1,659 @@ +"""TELNET client class. + +Based on RFC 854: TELNET Protocol Specification, by J. Postel and +J. Reynolds + +Example: + +>>> from telnetlib import Telnet +>>> tn = Telnet('www.python.org', 79) # connect to finger port +>>> tn.write('guido\r\n') +>>> print tn.read_all() +Login Name TTY Idle When Where +guido Guido van Rossum pts/2 snag.cnri.reston.. + +>>> + +Note that read_all() won't read until eof -- it just reads some data +-- but it guarantees to read at least one byte unless EOF is hit. + +It is possible to pass a Telnet object to select.select() in order to +wait until more data is available. Note that in this case, +read_eager() may return '' even if there was data on the socket, +because the protocol negotiation may have eaten the data. This is why +EOFError is needed in some cases to distinguish between "no data" and +"connection closed" (since the socket also appears ready for reading +when it is closed). + +To do: +- option negotiation +- timeout should be intrinsic to the connection object instead of an + option on one of the read calls only + +""" + + +# Imported modules +import sys +import socket +import select + +__all__ = ["Telnet"] + +# Tunable parameters +DEBUGLEVEL = 0 + +# Telnet protocol defaults +TELNET_PORT = 23 + +# Telnet protocol characters (don't change) +IAC = chr(255) # "Interpret As Command" +DONT = chr(254) +DO = chr(253) +WONT = chr(252) +WILL = chr(251) +theNULL = chr(0) + +SE = chr(240) # Subnegotiation End +NOP = chr(241) # No Operation +DM = chr(242) # Data Mark +BRK = chr(243) # Break +IP = chr(244) # Interrupt process +AO = chr(245) # Abort output +AYT = chr(246) # Are You There +EC = chr(247) # Erase Character +EL = chr(248) # Erase Line +GA = chr(249) # Go Ahead +SB = chr(250) # Subnegotiation Begin + + +# Telnet protocol options code (don't change) +# These ones all come from arpa/telnet.h +BINARY = chr(0) # 8-bit data path +ECHO = chr(1) # echo +RCP = chr(2) # prepare to reconnect +SGA = chr(3) # suppress go ahead +NAMS = chr(4) # approximate message size +STATUS = chr(5) # give status +TM = chr(6) # timing mark +RCTE = chr(7) # remote controlled transmission and echo +NAOL = chr(8) # negotiate about output line width +NAOP = chr(9) # negotiate about output page size +NAOCRD = chr(10) # negotiate about CR disposition +NAOHTS = chr(11) # negotiate about horizontal tabstops +NAOHTD = chr(12) # negotiate about horizontal tab disposition +NAOFFD = chr(13) # negotiate about formfeed disposition +NAOVTS = chr(14) # negotiate about vertical tab stops +NAOVTD = chr(15) # negotiate about vertical tab disposition +NAOLFD = chr(16) # negotiate about output LF disposition +XASCII = chr(17) # extended ascii character set +LOGOUT = chr(18) # force logout +BM = chr(19) # byte macro +DET = chr(20) # data entry terminal +SUPDUP = chr(21) # supdup protocol +SUPDUPOUTPUT = chr(22) # supdup output +SNDLOC = chr(23) # send location +TTYPE = chr(24) # terminal type +EOR = chr(25) # end or record +TUID = chr(26) # TACACS user identification +OUTMRK = chr(27) # output marking +TTYLOC = chr(28) # terminal location number +VT3270REGIME = chr(29) # 3270 regime +X3PAD = chr(30) # X.3 PAD +NAWS = chr(31) # window size +TSPEED = chr(32) # terminal speed +LFLOW = chr(33) # remote flow control +LINEMODE = chr(34) # Linemode option +XDISPLOC = chr(35) # X Display Location +OLD_ENVIRON = chr(36) # Old - Environment variables +AUTHENTICATION = chr(37) # Authenticate +ENCRYPT = chr(38) # Encryption option +NEW_ENVIRON = chr(39) # New - Environment variables +# the following ones come from +# http://www.iana.org/assignments/telnet-options +# Unfortunately, that document does not assign identifiers +# to all of them, so we are making them up +TN3270E = chr(40) # TN3270E +XAUTH = chr(41) # XAUTH +CHARSET = chr(42) # CHARSET +RSP = chr(43) # Telnet Remote Serial Port +COM_PORT_OPTION = chr(44) # Com Port Control Option +SUPPRESS_LOCAL_ECHO = chr(45) # Telnet Suppress Local Echo +TLS = chr(46) # Telnet Start TLS +KERMIT = chr(47) # KERMIT +SEND_URL = chr(48) # SEND-URL +FORWARD_X = chr(49) # FORWARD_X +PRAGMA_LOGON = chr(138) # TELOPT PRAGMA LOGON +SSPI_LOGON = chr(139) # TELOPT SSPI LOGON +PRAGMA_HEARTBEAT = chr(140) # TELOPT PRAGMA HEARTBEAT +EXOPL = chr(255) # Extended-Options-List +NOOPT = chr(0) + +class Telnet: + + """Telnet interface class. + + An instance of this class represents a connection to a telnet + server. The instance is initially not connected; the open() + method must be used to establish a connection. Alternatively, the + host name and optional port number can be passed to the + constructor, too. + + Don't try to reopen an already connected instance. + + This class has many read_*() methods. Note that some of them + raise EOFError when the end of the connection is read, because + they can return an empty string for other reasons. See the + individual doc strings. + + read_until(expected, [timeout]) + Read until the expected string has been seen, or a timeout is + hit (default is no timeout); may block. + + read_all() + Read all data until EOF; may block. + + read_some() + Read at least one byte or EOF; may block. + + read_very_eager() + Read all data available already queued or on the socket, + without blocking. + + read_eager() + Read either data already queued or some data available on the + socket, without blocking. + + read_lazy() + Read all data in the raw queue (processing it first), without + doing any socket I/O. + + read_very_lazy() + Reads all data in the cooked queue, without doing any socket + I/O. + + read_sb_data() + Reads available data between SB ... SE sequence. Don't block. + + set_option_negotiation_callback(callback) + Each time a telnet option is read on the input flow, this callback + (if set) is called with the following parameters : + callback(telnet socket, command, option) + option will be chr(0) when there is no option. + No other action is done afterwards by telnetlib. + + """ + + def __init__(self, host=None, port=0, timeout=None): + """Constructor. + + When called without arguments, create an unconnected instance. + With a hostname argument, it connects the instance; a port + number and connect timeout is optional. + + """ + self.debuglevel = DEBUGLEVEL + self.host = host + self.port = port + self.sock = None + self.rawq = '' + self.irawq = 0 + self.cookedq = '' + self.eof = 0 + self.iacseq = '' # Buffer for IAC sequence. + self.sb = 0 # flag for SB and SE sequence. + self.sbdataq = '' + self.option_callback = None + if host is not None: + self.open(host, port, timeout) + + def open(self, host, port=0, timeout=None): + """Connect to a host. + + The optional second argument is the port number, which + defaults to the standard telnet port (23). The optional third + argument is a timeout in seconds; if None, the default timeout + of the underlying socket will be used. + + Don't try to reopen an already connected instance. + + """ + self.eof = 0 + if not port: + port = TELNET_PORT + self.host = host + self.port = port + msg = "getaddrinfo returns an empty list" + for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM): + af, socktype, proto, canonname, sa = res + try: + self.sock = socket.socket(af, socktype, proto) + if timeout is not None: + self.sock.settimeout(timeout) + self.sock.connect(sa) + except socket.error, msg: + if self.sock: + self.sock.close() + self.sock = None + continue + break + if not self.sock: + raise socket.error, msg + + def __del__(self): + """Destructor -- close the connection.""" + self.close() + + def msg(self, msg, *args): + """Print a debug message, when the debug level is > 0. + + If extra arguments are present, they are substituted in the + message using the standard string formatting operator. + + """ + if self.debuglevel > 0: + print 'Telnet(%s,%d):' % (self.host, self.port), + if args: + print msg % args + else: + print msg + + def set_debuglevel(self, debuglevel): + """Set the debug level. + + The higher it is, the more debug output you get (on sys.stdout). + + """ + self.debuglevel = debuglevel + + def close(self): + """Close the connection.""" + if self.sock: + self.sock.close() + self.sock = 0 + self.eof = 1 + self.iacseq = '' + self.sb = 0 + + def get_socket(self): + """Return the socket object used internally.""" + return self.sock + + def fileno(self): + """Return the fileno() of the socket object used internally.""" + return self.sock.fileno() + + def write(self, buffer): + """Write a string to the socket, doubling any IAC characters. + + Can block if the connection is blocked. May raise + socket.error if the connection is closed. + + """ + if IAC in buffer: + buffer = buffer.replace(IAC, IAC+IAC) + self.msg("send %s", `buffer`) + self.sock.sendall(buffer) + + def read_until(self, match, timeout=None): + """Read until a given string is encountered or until timeout. + + When no match is found, return whatever is available instead, + possibly the empty string. Raise EOFError if the connection + is closed and no cooked data is available. + + """ + n = len(match) + self.process_rawq() + i = self.cookedq.find(match) + if i >= 0: + i = i+n + buf = self.cookedq[:i] + self.cookedq = self.cookedq[i:] + return buf + s_reply = ([self], [], []) + s_args = s_reply + if timeout is not None: + s_args = s_args + (timeout,) + while not self.eof and select.select(*s_args) == s_reply: + i = max(0, len(self.cookedq)-n) + self.fill_rawq() + self.process_rawq() + i = self.cookedq.find(match, i) + if i >= 0: + i = i+n + buf = self.cookedq[:i] + self.cookedq = self.cookedq[i:] + return buf + return self.read_very_lazy() + + def read_all(self): + """Read all data until EOF; block until connection closed.""" + self.process_rawq() + while not self.eof: + self.fill_rawq() + self.process_rawq() + buf = self.cookedq + self.cookedq = '' + return buf + + def read_some(self): + """Read at least one byte of cooked data unless EOF is hit. + + Return '' if EOF is hit. Block if no data is immediately + available. + + """ + self.process_rawq() + while not self.cookedq and not self.eof: + self.fill_rawq() + self.process_rawq() + buf = self.cookedq + self.cookedq = '' + return buf + + def read_very_eager(self): + """Read everything that's possible without blocking in I/O (eager). + + Raise EOFError if connection closed and no cooked data + available. Return '' if no cooked data available otherwise. + Don't block unless in the midst of an IAC sequence. + + """ + self.process_rawq() + while not self.eof and self.sock_avail(): + self.fill_rawq() + self.process_rawq() + return self.read_very_lazy() + + def read_eager(self): + """Read readily available data. + + Raise EOFError if connection closed and no cooked data + available. Return '' if no cooked data available otherwise. + Don't block unless in the midst of an IAC sequence. + + """ + self.process_rawq() + while not self.cookedq and not self.eof and self.sock_avail(): + self.fill_rawq() + self.process_rawq() + return self.read_very_lazy() + + def read_lazy(self): + """Process and return data that's already in the queues (lazy). + + Raise EOFError if connection closed and no data available. + Return '' if no cooked data available otherwise. Don't block + unless in the midst of an IAC sequence. + + """ + self.process_rawq() + return self.read_very_lazy() + + def read_very_lazy(self): + """Return any data available in the cooked queue (very lazy). + + Raise EOFError if connection closed and no data available. + Return '' if no cooked data available otherwise. Don't block. + + """ + buf = self.cookedq + self.cookedq = '' + if not buf and self.eof and not self.rawq: + raise EOFError, 'telnet connection closed' + return buf + + def read_sb_data(self): + """Return any data available in the SB ... SE queue. + + Return '' if no SB ... SE available. Should only be called + after seeing a SB or SE command. When a new SB command is + found, old unread SB data will be discarded. Don't block. + + """ + buf = self.sbdataq + self.sbdataq = '' + return buf + + def set_option_negotiation_callback(self, callback): + """Provide a callback function called after each receipt of a telnet option.""" + self.option_callback = callback + + def process_rawq(self): + """Transfer from raw queue to cooked queue. + + Set self.eof when connection is closed. Don't block unless in + the midst of an IAC sequence. + + """ + buf = ['', ''] + try: + while self.rawq: + c = self.rawq_getchar() + if not self.iacseq: + if c == theNULL: + continue + if c == "\021": + continue + if c != IAC: + buf[self.sb] = buf[self.sb] + c + continue + else: + self.iacseq += c + elif len(self.iacseq) == 1: + 'IAC: IAC CMD [OPTION only for WILL/WONT/DO/DONT]' + if c in (DO, DONT, WILL, WONT): + self.iacseq += c + continue + + self.iacseq = '' + if c == IAC: + buf[self.sb] = buf[self.sb] + c + else: + if c == SB: # SB ... SE start. + self.sb = 1 + self.sbdataq = '' + elif c == SE: + self.sb = 0 + self.sbdataq = self.sbdataq + buf[1] + buf[1] = '' + if self.option_callback: + # Callback is supposed to look into + # the sbdataq + self.option_callback(self.sock, c, NOOPT) + else: + # We can't offer automatic processing of + # suboptions. Alas, we should not get any + # unless we did a WILL/DO before. + self.msg('IAC %d not recognized' % ord(c)) + elif len(self.iacseq) == 2: + cmd = self.iacseq[1] + self.iacseq = '' + opt = c + if cmd in (DO, DONT): + self.msg('IAC %s %d', + cmd == DO and 'DO' or 'DONT', ord(opt)) + if self.option_callback: + self.option_callback(self.sock, cmd, opt) + else: + self.sock.sendall(IAC + WONT + opt) + elif cmd in (WILL, WONT): + self.msg('IAC %s %d', + cmd == WILL and 'WILL' or 'WONT', ord(opt)) + if self.option_callback: + self.option_callback(self.sock, cmd, opt) + else: + self.sock.sendall(IAC + DONT + opt) + except EOFError: # raised by self.rawq_getchar() + self.iacseq = '' # Reset on EOF + self.sb = 0 + pass + self.cookedq = self.cookedq + buf[0] + self.sbdataq = self.sbdataq + buf[1] + + def rawq_getchar(self): + """Get next char from raw queue. + + Block if no data is immediately available. Raise EOFError + when connection is closed. + + """ + if not self.rawq: + self.fill_rawq() + if self.eof: + raise EOFError + c = self.rawq[self.irawq] + self.irawq = self.irawq + 1 + if self.irawq >= len(self.rawq): + self.rawq = '' + self.irawq = 0 + return c + + def fill_rawq(self): + """Fill raw queue from exactly one recv() system call. + + Block if no data is immediately available. Set self.eof when + connection is closed. + + """ + if self.irawq >= len(self.rawq): + self.rawq = '' + self.irawq = 0 + # The buffer size should be fairly small so as to avoid quadratic + # behavior in process_rawq() above + buf = self.sock.recv(50) + self.msg("recv %s", `buf`) + self.eof = (not buf) + self.rawq = self.rawq + buf + + def sock_avail(self): + """Test whether data is available on the socket.""" + return select.select([self], [], [], 0) == ([self], [], []) + + def interact(self): + """Interaction function, emulates a very dumb telnet client.""" + if sys.platform == "win32": + self.mt_interact() + return + while 1: + rfd, wfd, xfd = select.select([self, sys.stdin], [], []) + if self in rfd: + try: + text = self.read_eager() + except EOFError: + print '*** Connection closed by remote host ***' + break + if text: + sys.stdout.write(text) + sys.stdout.flush() + if sys.stdin in rfd: + line = sys.stdin.readline() + if not line: + break + self.write(line) + + def mt_interact(self): + """Multithreaded version of interact().""" + import thread + thread.start_new_thread(self.listener, ()) + while 1: + line = sys.stdin.readline() + if not line: + break + self.write(line) + + def listener(self): + """Helper for mt_interact() -- this executes in the other thread.""" + while 1: + try: + data = self.read_eager() + except EOFError: + print '*** Connection closed by remote host ***' + return + if data: + sys.stdout.write(data) + else: + sys.stdout.flush() + + def expect(self, list, timeout=None): + """Read until one from a list of a regular expressions matches. + + The first argument is a list of regular expressions, either + compiled (re.RegexObject instances) or uncompiled (strings). + The optional second argument is a timeout, in seconds; default + is no timeout. + + Return a tuple of three items: the index in the list of the + first regular expression that matches; the match object + returned; and the text read up till and including the match. + + If EOF is read and no text was read, raise EOFError. + Otherwise, when nothing matches, return (-1, None, text) where + text is the text received so far (may be the empty string if a + timeout happened). + + If a regular expression ends with a greedy match (e.g. '.*') + or if more than one expression can match the same input, the + results are undeterministic, and may depend on the I/O timing. + + """ + re = None + list = list[:] + indices = range(len(list)) + for i in indices: + if not hasattr(list[i], "search"): + if not re: import re + list[i] = re.compile(list[i]) + while 1: + self.process_rawq() + for i in indices: + m = list[i].search(self.cookedq) + if m: + e = m.end() + text = self.cookedq[:e] + self.cookedq = self.cookedq[e:] + return (i, m, text) + if self.eof: + break + if timeout is not None: + r, w, x = select.select([self.fileno()], [], [], timeout) + if not r: + break + self.fill_rawq() + text = self.read_very_lazy() + if not text and self.eof: + raise EOFError + return (-1, None, text) + + +def test(): + """Test program for telnetlib. + + Usage: python telnetlib.py [-d] ... [host [port]] + + Default host is localhost; default port is 23. + + """ + debuglevel = 0 + while sys.argv[1:] and sys.argv[1] == '-d': + debuglevel = debuglevel+1 + del sys.argv[1] + host = 'localhost' + if sys.argv[1:]: + host = sys.argv[1] + port = 0 + if sys.argv[2:]: + portstr = sys.argv[2] + try: + port = int(portstr) + except ValueError: + port = socket.getservbyname(portstr, 'tcp') + tn = Telnet() + tn.set_debuglevel(debuglevel) + tn.open(host, port) + tn.interact() + tn.close() + +if __name__ == '__main__': + test() diff --git a/pcucontrol/util/__init__.py b/pcucontrol/util/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pcucontrol/util/command.py b/pcucontrol/util/command.py new file mode 100644 index 0000000..6f112fb --- /dev/null +++ b/pcucontrol/util/command.py @@ -0,0 +1,244 @@ +import os +from select import select +import subprocess +import signal +import time +import traceback +import fcntl + +DEBUG= 0 + +class ExceptionTimeout(Exception): pass +class ExceptionReadTimeout(Exception): pass +COMMAND_TIMEOUT = 60 +ssh_options = { 'StrictHostKeyChecking':'no', + 'BatchMode':'yes', + 'PasswordAuthentication':'no', + 'ConnectTimeout':'%s' % COMMAND_TIMEOUT} + +class Sopen(subprocess.Popen): + def kill(self, sig = signal.SIGTERM): + try: + # NOTE: this also kills parent... so doesn't work like I want. + # NOTE: adding 'exec' before the cmd removes the extra sh, and + # partially addresses this problem. + #os.killpg(os.getpgid(self.pid), signal.SIGKILL) + os.kill(self.pid, sig) + except OSError: + # no such process, due to it already exiting... + pass + + +def read_t(stream, count=1, timeout=COMMAND_TIMEOUT*2): + if count == 1: + retstr = "" + + while True: + lin, lout, lerr = select([stream], [], [], timeout) + if len(lin) == 0: + print "timeout!" + raise ExceptionReadTimeout("TIMEOUT reading from command") + + try: + outbytes = stream.read(count) + except IOError, err: + print 'no content yet.' + # due to no content. + # the select timeout should catch this. + continue + + if not outbytes: + break + retstr += outbytes + + return retstr + else: + lin, lout, lerr = select([stream], [], [], timeout) + if len(lin) == 0: + raise ExceptionReadTimeout("TIMEOUT reading from command") + + return stream.read(count) + +class CMD: + def __init__(self): + pass + + def run_noexcept(self, cmd, timeout=COMMAND_TIMEOUT*2): + + try: + return CMD.run(self,cmd,timeout) + except ExceptionTimeout: + print traceback.print_exc() + return ("", "ScriptTimeout") + except ExceptionReadTimeout: + print traceback.print_exc() + return ("", "RunningScriptTimeout") + except KeyboardInterrupt: + print "Interrupted, exiting..." + sys.exit(1) + except Exception, err: + #from monitor.common import email_exception + #email_exception() + return ("", str(err)) + + def system(self, cmd, timeout=COMMAND_TIMEOUT*2): + (o,e) = self.run(cmd, timeout) + self.output = o + self.error = e + if self.s.returncode is None: + self.s.wait() + return self.s.returncode + + def run(self, cmd, timeout=COMMAND_TIMEOUT*2): + + s = Sopen(cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True) + self.s = s + (f_in, f_out, f_err) = (s.stdin, s.stdout, s.stderr) + lout, lin, lerr = select([f_out], [], [f_err], timeout) + if len(lin) == 0 and len(lout) == 0 and len(lerr) == 0: + # Reached a timeout! Nuke process so it does not hang. + print "TIMEOUT!!!!!!!!!!!!!!!!!!!" + s.kill(signal.SIGKILL) + raise ExceptionTimeout("TIMEOUT Running: %s" % cmd) + else: + #print "RETURNING" + #print len(lin), len(lout), len(lerr) + pass + + o_value = "" + e_value = "" + + #o_value = f_out.read() + flags = fcntl.fcntl(f_out, fcntl.F_GETFL) + fcntl.fcntl(f_out, fcntl.F_SETFL, flags | os.O_NONBLOCK) + + try: + o_value = read_t(f_out,1,30) + except ExceptionReadTimeout: + s.kill(signal.SIGKILL) + raise ExceptionReadTimeout("TIMEOUT: failed to read from cmd: %s" % cmd) + + e_value = f_err.read() + + o_value = o_value.strip() + e_value = e_value.strip() + + f_out.close() + f_in.close() + f_err.close() + s.kill(signal.SIGKILL) + + return (o_value, e_value) + + def runargs(self, args, timeout=COMMAND_TIMEOUT*2): + + #print "CMD.run(%s)" % " ".join(args) + s = Sopen(args, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True) + self.s = s + (f_in, f_out, f_err) = (s.stdin, s.stdout, s.stderr) + lout, lin, lerr = select([f_out], [], [f_err], timeout) + if len(lin) == 0 and len(lout) == 0 and len(lerr) == 0: + # Reached a timeout! Nuke process so it does not hang. + s.kill(signal.SIGKILL) + raise ExceptionTimeout("TIMEOUT Running: %s" % cmd) + o_value = f_out.read() + e_value = "" + if o_value == "": # An error has occured + e_value = f_err.read() + + o_value = o_value.strip() + e_value = e_value.strip() + + f_out.close() + f_in.close() + f_err.close() + s.kill(signal.SIGKILL) + + return (o_value, e_value) + + +class SSH(CMD): + def __init__(self, user, host, port=22, options = ssh_options): + self.options = options + self.user = user + self.host = host + self.port = port + return + + def __options_to_str(self): + options = "" + for o,v in self.options.iteritems(): + options = options + "-o %s=%s " % (o,v) + return options + + def run(self, cmd, timeout=COMMAND_TIMEOUT*2): + cmd = "ssh -p %s %s %s@%s '%s'" % (self.port, self.__options_to_str(), + self.user, self.host, cmd) + #print "SSH.run(%s)" % cmd + return CMD.run(self, cmd, timeout) + + def get_file(self, rmt_filename, local_filename=None): + if local_filename == None: + local_filename = "./" + cmd = "scp -P %s -B %s %s@%s:%s %s" % (self.port, self.__options_to_str(), + self.user, self.host, + rmt_filename, local_filename) + # output : + # errors will be on stderr, + # success will have a blank stderr... + return CMD.run_noexcept(self, cmd) + + def run_noexcept(self, cmd): + cmd = "ssh -p %s %s %s@%s '%s'" % (self.port, self.__options_to_str(), + self.user, self.host, cmd) + #print "SSH.run_noexcept(%s)" % cmd + return CMD.run_noexcept(self, cmd) + + def run_noexcept2(self, cmd, timeout=COMMAND_TIMEOUT*2): + cmd = "exec ssh -p %s %s %s@%s %s" % (self.port, self.__options_to_str(), + self.user, self.host, cmd) + #print cmd + r = CMD.run_noexcept(self, cmd, timeout) + self.ret = -1 + + return r + + def system2(self, cmd, timeout=COMMAND_TIMEOUT*2): + cmd = "ssh -p %s %s %s@%s %s" % (self.port, self.__options_to_str(), + self.user, self.host, cmd) + #print "SSH.system2(%s)" % cmd + return CMD.system(self, cmd, timeout) + + def runE(self, cmd): + cmd = "ssh -p %s %s %s@%s '%s'" % (self.port, self.__options_to_str(), + self.user, self.host, cmd) + if ( DEBUG == 1 ): + print cmd, + (f_in, f_out, f_err) = os.popen3(cmd) + + value = f_out.read() + if value == "": # An error has occured + value = f_err.read() + value = value.strip() + + if ( DEBUG == 1 ): + print " == %s" % value + f_out.close() + f_in.close() + f_err.close() + return value.strip() + +class MyTimer: + def __init__(self): + self.start = time.time() + + def end(self): + self.end = time.time() + t = self.end-self.start + return t + + def diff(self): + self.end = time.time() + t = self.end-self.start + self.start = self.end + return t -- 2.43.0